language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-28 06:14:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

cleanup

Browse source
This commit is contained in:
Folkert 2021-06-21 21:25:51 +02:00
parent 7a36c25848
commit ee941c9f2e
2 changed files with 0 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

91
compiler/gen_llvm/src/llvm/build.rs
View file

@ -1496,97 +1496,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>(
}
}
AccessAtIndex {
index,
structure,
field_layouts,
..
} => {
use BasicValueEnum::*;
let builder = env.builder;
// Determine types, assumes the discriminant is in the field layouts
let num_fields = field_layouts.len();
let mut field_types = Vec::with_capacity_in(num_fields, env.arena);
for field_layout in field_layouts.iter() {
let field_type = basic_type_from_layout(env, &field_layout);
field_types.push(field_type);
}
// cast the argument bytes into the desired shape for this tag
let (argument, structure_layout) = load_symbol_and_layout(scope, structure);
match argument {
StructValue(value) => {
let struct_layout = Layout::Struct(field_layouts);
let struct_type = env
.context
.struct_type(field_types.into_bump_slice(), false);
let struct_value = access_index_struct_value(builder, value, struct_type);
let result = builder
.build_extract_value(struct_value, *index as u32, "")
.expect("desired field did not decode");
if let Some(Layout::RecursivePointer) = field_layouts.get(*index as usize) {
let desired_type =
block_of_memory(env.context, &struct_layout, env.ptr_bytes);
// the value is a pointer to the actual value; load that value!
let ptr = env.builder.build_bitcast(
result,
desired_type.ptr_type(AddressSpace::Generic),
"cast_struct_value_pointer",
);
builder.build_load(ptr.into_pointer_value(), "load_recursive_field")
} else {
result
}
}
PointerValue(value) => match structure_layout {
Layout::Union(UnionLayout::NullableWrapped { .. }) if *index == 0 => {
panic!("this should not happen any more")
}
Layout::Union(UnionLayout::NullableUnwrapped { .. }) => {
if *index == 0 {
panic!("this should not happen any more")
} else {
let struct_type = env
.context
.struct_type(&field_types.into_bump_slice()[1..], false);
lookup_at_index_ptr(
env,
&field_layouts[1..],
*index as usize - 1,
value,
struct_type,
structure_layout,
)
}
}
_ => {
let struct_type = env
.context
.struct_type(field_types.into_bump_slice(), false);
lookup_at_index_ptr(
env,
field_layouts,
*index as usize,
value,
struct_type,
structure_layout,
)
}
},
_ => panic!("cannot look up index in {:?}", argument),
}
}
EmptyArray => empty_polymorphic_list(env),
Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems),
RuntimeErrorFunction(_) => todo!(),

17
compiler/mono/src/decision_tree.rs
View file

@ -1044,23 +1044,6 @@ fn path_to_expr_help<'a>(
debug_assert_eq!(*tag_id, 0);
debug_assert!(it.peek().is_none());
let field_layouts = vec![layout];
debug_assert!(*index < field_layouts.len() as u64);
debug_assert_eq!(field_layouts.len(), 1);
let inner_expr = Expr::AccessAtIndex {
index: *index,
field_layouts: env.arena.alloc(field_layouts),
structure: symbol,
wrapped: Wrapped::SingleElementRecord,
};
// symbol = env.unique_symbol();
// let inner_layout = layout;
// stores.push((symbol, inner_layout, inner_expr));
break;
}
true => {