language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 12:18:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Make repr private and accessible only via the interner

Browse source
This commit is contained in:
Ayaz Hafiz 2023-05-11 10:12:18 -05:00
parent 107c6b0777
commit 457cdabc5c
No known key found for this signature in database
GPG key ID: 0E2A37416A25EF58
30 changed files with 294 additions and 288 deletions
Download patch file Download diff file Expand all files Collapse all files

16
crates/compiler/gen_wasm/src/backend.rs
View file

@ -507,7 +507,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
let heap_return_ptr_id = LocalId(wrapper_arg_layouts.len() as u32 - 1);
let inner_ret_layout = match wrapper_arg_layouts
.last()
.map(|l| self.layout_interner.get(*l).repr)
.map(|l| self.layout_interner.get_repr(*l))
{
Some(LayoutRepr::Boxed(inner)) => WasmLayout::new(self.layout_interner, inner),
x => internal_error!("Higher-order wrapper: invalid return layout {:?}", x),
@ -539,7 +539,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
continue;
}
let inner_layout = match self.layout_interner.get(*wrapper_arg).repr {
let inner_layout = match self.layout_interner.get_repr(*wrapper_arg) {
LayoutRepr::Boxed(inner) => inner,
x => internal_error!("Expected a Boxed layout, got {:?}", x),
};
@ -558,7 +558,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
if self.layout_interner.stack_size(closure_data_layout) > 0 {
// The closure data exists, and will have been passed in to the wrapper as a
// one-element struct.
let inner_closure_data_layout = match self.layout_interner.get(closure_data_layout).repr
let inner_closure_data_layout = match self.layout_interner.get_repr(closure_data_layout)
{
LayoutRepr::Struct([inner]) => inner,
other => internal_error!(
@ -633,7 +633,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
n_inner_args += 1;
}
let inner_layout = match self.layout_interner.get(value_layout).repr {
let inner_layout = match self.layout_interner.get_repr(value_layout) {
LayoutRepr::Boxed(inner) => inner,
x => internal_error!("Expected a Boxed layout, got {:?}", x),
};
@ -662,7 +662,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
fn dereference_boxed_value(&mut self, inner: InLayout) {
use Align::*;
match self.layout_interner.get(inner).repr {
match self.layout_interner.get_repr(inner) {
LayoutRepr::Builtin(Builtin::Int(IntWidth::U8 | IntWidth::I8)) => {
self.code_builder.i32_load8_u(Bytes1, 0);
}
@ -1362,7 +1362,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
arguments,
ret_symbol,
ret_layout,
ret_layout_raw: self.layout_interner.get(ret_layout),
ret_layout_raw: self.layout_interner.get_repr(ret_layout),
ret_storage: ret_storage.to_owned(),
};
low_level_call.generate(self);
@ -1440,7 +1440,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
storage: &StoredValue,
fields: &'a [Symbol],
) {
match self.layout_interner.get(layout).repr {
match self.layout_interner.get_repr(layout) {
LayoutRepr::Struct { .. } => {
match storage {
StoredValue::StackMemory { location, size, .. } => {
@ -1898,7 +1898,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
};
// allocate heap memory and load its data address onto the value stack
let arg_layout = match self.layout_interner.get(layout).repr {
let arg_layout = match self.layout_interner.get_repr(layout) {
LayoutRepr::Boxed(arg) => arg,
_ => internal_error!("ExprBox should always produce a Boxed layout"),
};

2
crates/compiler/gen_wasm/src/layout.rs
View file

@ -47,7 +47,7 @@ impl WasmLayout {
let (size, alignment_bytes) = interner.stack_size_and_alignment(layout);
match interner.get(layout).repr {
match interner.get_repr(layout) {
LayoutRepr::Builtin(Int(int_width)) => {
use IntWidth::*;

100
crates/compiler/gen_wasm/src/low_level.rs
View file

@ -126,7 +126,7 @@ pub struct LowLevelCall<'a> {
pub arguments: &'a [Symbol],
pub ret_symbol: Symbol,
pub ret_layout: InLayout<'a>,
pub ret_layout_raw: Layout<'a>,
pub ret_layout_raw: LayoutRepr<'a>,
pub ret_storage: StoredValue,
}
@ -237,14 +237,14 @@ impl<'a> LowLevelCall<'a> {
}
StrGetCapacity => self.load_args_and_call_zig(backend, bitcode::STR_CAPACITY),
StrToNum => {
let number_layout = match backend.layout_interner.get(self.ret_layout).repr {
let number_layout = match backend.layout_interner.get_repr(self.ret_layout) {
LayoutRepr::Struct(field_layouts) => field_layouts[0],
_ => {
internal_error!("Unexpected mono layout {:?} for StrToNum", self.ret_layout)
}
};
// match on the return layout to figure out which zig builtin we need
let intrinsic = match backend.layout_interner.get(number_layout).repr {
let intrinsic = match backend.layout_interner.get_repr(number_layout) {
LayoutRepr::Builtin(Builtin::Int(int_width)) => &bitcode::STR_TO_INT[int_width],
LayoutRepr::Builtin(Builtin::Float(float_width)) => {
&bitcode::STR_TO_FLOAT[float_width]
@ -391,11 +391,11 @@ impl<'a> LowLevelCall<'a> {
let (ret_list_offset, ret_elem_offset, elem_layout) = match self.ret_layout_raw.repr
{
LayoutRepr::Struct(&[f1, f2]) => {
let l1 = backend.layout_interner.get(f1);
let l2 = backend.layout_interner.get(f2);
match (l1.repr, l2.repr) {
let l1 = backend.layout_interner.get_repr(f1);
let l2 = backend.layout_interner.get_repr(f2);
match (l1, l2) {
(LayoutRepr::Builtin(Builtin::List(list_elem)), _)
if l2.repr == backend.layout_interner.get(list_elem).repr =>
if l2 == backend.layout_interner.get_repr(list_elem) =>
{
let list_offset = 0;
let elem_offset = LayoutRepr::Builtin(Builtin::List(list_elem))
@ -403,7 +403,7 @@ impl<'a> LowLevelCall<'a> {
(list_offset, elem_offset, f2)
}
(_, LayoutRepr::Builtin(Builtin::List(list_elem)))
if l1.repr == backend.layout_interner.get(list_elem).repr =>
if l1 == backend.layout_interner.get_repr(list_elem) =>
{
let list_offset =
l1.stack_size(backend.layout_interner, TARGET_INFO);
@ -809,7 +809,7 @@ impl<'a> LowLevelCall<'a> {
}
// Num
NumAdd => match self.ret_layout_raw.repr {
NumAdd => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_ADD_OR_PANIC_INT[width])
}
@ -829,7 +829,7 @@ impl<'a> LowLevelCall<'a> {
_ => panic_ret_type(),
},
NumAddWrap => match self.ret_layout_raw.repr {
NumAddWrap => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => match width {
IntWidth::I128 | IntWidth::U128 => {
// TODO: don't panic
@ -869,7 +869,7 @@ impl<'a> LowLevelCall<'a> {
NumToStr => self.num_to_str(backend),
NumAddChecked => {
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
match backend.layout_interner.get(arg_layout).repr {
match backend.layout_interner.get_repr(arg_layout) {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_ADD_CHECKED_INT[width])
}
@ -882,7 +882,7 @@ impl<'a> LowLevelCall<'a> {
x => internal_error!("NumAddChecked is not defined for {:?}", x),
}
}
NumAddSaturated => match self.ret_layout_raw.repr {
NumAddSaturated => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_ADD_SATURATED_INT[width])
}
@ -900,7 +900,7 @@ impl<'a> LowLevelCall<'a> {
_ => panic_ret_type(),
},
NumSub => match self.ret_layout_raw.repr {
NumSub => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_SUB_OR_PANIC_INT[width])
}
@ -920,7 +920,7 @@ impl<'a> LowLevelCall<'a> {
_ => panic_ret_type(),
},
NumSubWrap => match self.ret_layout_raw.repr {
NumSubWrap => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => match width {
IntWidth::I128 | IntWidth::U128 => {
// TODO: don't panic
@ -958,7 +958,7 @@ impl<'a> LowLevelCall<'a> {
},
NumSubChecked => {
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
match backend.layout_interner.get(arg_layout).repr {
match backend.layout_interner.get_repr(arg_layout) {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_SUB_CHECKED_INT[width])
}
@ -971,7 +971,7 @@ impl<'a> LowLevelCall<'a> {
x => internal_error!("NumSubChecked is not defined for {:?}", x),
}
}
NumSubSaturated => match self.ret_layout_raw.repr {
NumSubSaturated => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_SUB_SATURATED_INT[width])
}
@ -989,7 +989,7 @@ impl<'a> LowLevelCall<'a> {
_ => panic_ret_type(),
},
NumMul => match self.ret_layout_raw.repr {
NumMul => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_MUL_OR_PANIC_INT[width])
}
@ -1008,7 +1008,7 @@ impl<'a> LowLevelCall<'a> {
}
_ => panic_ret_type(),
},
NumMulWrap => match self.ret_layout_raw.repr {
NumMulWrap => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => match width {
IntWidth::I128 | IntWidth::U128 => {
self.load_args_and_call_zig(backend, &bitcode::NUM_MUL_WRAP_INT[width])
@ -1043,7 +1043,7 @@ impl<'a> LowLevelCall<'a> {
}
_ => panic_ret_type(),
},
NumMulSaturated => match self.ret_layout_raw.repr {
NumMulSaturated => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_MUL_SATURATED_INT[width])
}
@ -1063,7 +1063,7 @@ impl<'a> LowLevelCall<'a> {
NumMulChecked => {
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
match backend.layout_interner.get(arg_layout).repr {
match backend.layout_interner.get_repr(arg_layout) {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_MUL_CHECKED_INT[width])
}
@ -1245,7 +1245,7 @@ impl<'a> LowLevelCall<'a> {
x => todo!("{:?} for {:?}", self.lowlevel, x),
}
}
NumDivCeilUnchecked => match self.ret_layout_raw.repr {
NumDivCeilUnchecked => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_DIV_CEIL[width])
}
@ -1456,13 +1456,13 @@ impl<'a> LowLevelCall<'a> {
_ => todo!("{:?} for {:?}", self.lowlevel, self.ret_layout),
}
}
NumSin => match self.ret_layout_raw.repr {
NumSin => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_SIN[width]);
}
_ => panic_ret_type(),
},
NumCos => match self.ret_layout_raw.repr {
NumCos => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_COS[width]);
}
@ -1470,7 +1470,7 @@ impl<'a> LowLevelCall<'a> {
},
NumSqrtUnchecked => {
self.load_args(backend);
match self.ret_layout_raw.repr {
match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(FloatWidth::F32)) => {
backend.code_builder.f32_sqrt()
}
@ -1480,7 +1480,7 @@ impl<'a> LowLevelCall<'a> {
_ => panic_ret_type(),
}
}
NumLogUnchecked => match self.ret_layout_raw.repr {
NumLogUnchecked => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_LOG[width]);
}
@ -1504,7 +1504,7 @@ impl<'a> LowLevelCall<'a> {
_ => todo!("{:?}: {:?} -> {:?}", self.lowlevel, arg_type, ret_type),
}
}
NumPow => match self.ret_layout_raw.repr {
NumPow => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_POW[width]);
}
@ -1513,8 +1513,7 @@ impl<'a> LowLevelCall<'a> {
NumCountLeadingZeroBits => match backend
.layout_interner
.get(backend.storage.symbol_layouts[&self.arguments[0]])
.repr
.get_repr(backend.storage.symbol_layouts[&self.arguments[0]])
{
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(
@ -1526,8 +1525,7 @@ impl<'a> LowLevelCall<'a> {
},
NumCountTrailingZeroBits => match backend
.layout_interner
.get(backend.storage.symbol_layouts[&self.arguments[0]])
.repr
.get_repr(backend.storage.symbol_layouts[&self.arguments[0]])
{
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(
@ -1539,8 +1537,7 @@ impl<'a> LowLevelCall<'a> {
},
NumCountOneBits => match backend
.layout_interner
.get(backend.storage.symbol_layouts[&self.arguments[0]])
.repr
.get_repr(backend.storage.symbol_layouts[&self.arguments[0]])
{
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_COUNT_ONE_BITS[width]);
@ -1617,19 +1614,19 @@ impl<'a> LowLevelCall<'a> {
NumIsInfinite => num_is_infinite(backend, self.arguments[0]),
NumIsFinite => num_is_finite(backend, self.arguments[0]),
NumAtan => match self.ret_layout_raw.repr {
NumAtan => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_ATAN[width]);
}
_ => panic_ret_type(),
},
NumAcos => match self.ret_layout_raw.repr {
NumAcos => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_ACOS[width]);
}
_ => panic_ret_type(),
},
NumAsin => match self.ret_layout_raw.repr {
NumAsin => match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Float(width)) => {
self.load_args_and_call_zig(backend, &bitcode::NUM_ASIN[width]);
}
@ -1777,14 +1774,14 @@ impl<'a> LowLevelCall<'a> {
NumIntCast => {
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
let arg_type = CodeGenNumType::from(arg_layout);
let arg_width = match backend.layout_interner.get(arg_layout).repr {
let arg_width = match backend.layout_interner.get_repr(arg_layout) {
LayoutRepr::Builtin(Builtin::Int(w)) => w,
LayoutRepr::Builtin(Builtin::Bool) => IntWidth::U8,
x => internal_error!("Num.intCast is not defined for {:?}", x),
};
let ret_type = CodeGenNumType::from(self.ret_layout);
let ret_width = match self.ret_layout_raw.repr {
let ret_width = match self.ret_layout_raw {
LayoutRepr::Builtin(Builtin::Int(w)) => w,
x => internal_error!("Num.intCast is not defined for {:?}", x),
};
@ -1847,7 +1844,7 @@ impl<'a> LowLevelCall<'a> {
NumToFloatCast => {
self.load_args(backend);
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
let arg_signed = match backend.layout_interner.get(arg_layout).repr {
let arg_signed = match backend.layout_interner.get_repr(arg_layout) {
LayoutRepr::Builtin(Builtin::Int(w)) => w.is_signed(),
LayoutRepr::Builtin(Builtin::Float(_)) => true, // unused
LayoutRepr::Builtin(Builtin::Decimal) => true,
@ -1895,13 +1892,13 @@ impl<'a> LowLevelCall<'a> {
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
let (arg_width, ret_width) = match (
backend.layout_interner.get(arg_layout).repr,
self.ret_layout_raw.repr,
backend.layout_interner.get_repr(arg_layout),
self.ret_layout_raw,
) {
(
LayoutRepr::Builtin(Builtin::Int(arg_width)),
LayoutRepr::Struct(&[ret, ..]),
) => match backend.layout_interner.get(ret).repr {
) => match backend.layout_interner.get_repr(ret) {
LayoutRepr::Builtin(Builtin::Int(ret_width)) => (arg_width, ret_width),
_ => {
internal_error!(
@ -1993,19 +1990,19 @@ impl<'a> LowLevelCall<'a> {
let arg_layout = backend
.layout_interner
.runtime_representation_in(backend.storage.symbol_layouts[&self.arguments[0]]);
let arg_layout_raw = backend.layout_interner.get(arg_layout);
let arg_layout_raw = backend.layout_interner.get_repr(arg_layout);
let other_arg_layout = backend
.layout_interner
.runtime_representation(backend.storage.symbol_layouts[&self.arguments[1]]);
debug_assert_eq!(
arg_layout_raw.repr, other_arg_layout.repr,
arg_layout_raw, other_arg_layout,
"Cannot do `==` comparison on different types: {:?} vs {:?}",
arg_layout, other_arg_layout
);
let invert_result = matches!(self.lowlevel, LowLevel::NotEq);
match arg_layout_raw.repr {
match arg_layout_raw {
LayoutRepr::Builtin(
Builtin::Int(_) | Builtin::Float(_) | Builtin::Bool | Builtin::Decimal,
) => self.eq_or_neq_number(backend),
@ -2147,7 +2144,7 @@ impl<'a> LowLevelCall<'a> {
fn num_to_str(&self, backend: &mut WasmBackend<'a, '_>) {
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
match backend.layout_interner.get(arg_layout).repr {
match backend.layout_interner.get_repr(arg_layout) {
LayoutRepr::Builtin(Builtin::Int(width)) => {
self.load_args_and_call_zig(backend, &bitcode::STR_FROM_INT[width])
}
@ -2355,8 +2352,7 @@ pub fn call_higher_order_lowlevel<'a>(
// The wrapper around the passed function will access the actual closure data in the struct.
let (closure_data_layout, closure_data_exists) = match backend
.layout_interner
.get(backend.storage.symbol_layouts[captured_environment])
.repr
.get_repr(backend.storage.symbol_layouts[captured_environment])
{
LayoutRepr::LambdaSet(lambda_set) => {
if lambda_set.is_represented(backend.layout_interner).is_some() {
@ -2556,7 +2552,7 @@ pub fn call_higher_order_lowlevel<'a>(
let elem_layout = unwrap_list_elem_layout(
backend
.layout_interner
.get(backend.storage.symbol_layouts[xs]),
.get_repr(backend.storage.symbol_layouts[xs]),
);
let elem_layout = backend.layout_interner.get(elem_layout);
let (element_width, alignment) =
@ -2595,8 +2591,8 @@ pub fn call_higher_order_lowlevel<'a>(
}
}
fn unwrap_list_elem_layout(list_layout: Layout) -> InLayout {
match list_layout.repr {
fn unwrap_list_elem_layout(list_layout: LayoutRepr) -> InLayout {
match list_layout {
LayoutRepr::Builtin(Builtin::List(x)) => x,
e => internal_error!("expected List layout, got {:?}", e),
}
@ -2620,13 +2616,13 @@ fn list_map_n<'a>(
unwrap_list_elem_layout(
backend
.layout_interner
.get(backend.storage.symbol_layouts[sym]),
.get_repr(backend.storage.symbol_layouts[sym]),
)
}),
backend.env.arena,
);
let elem_ret = unwrap_list_elem_layout(backend.layout_interner.get(return_layout));
let elem_ret = unwrap_list_elem_layout(backend.layout_interner.get_repr(return_layout));
let elem_ret = backend.layout_interner.get(elem_ret);
let (elem_ret_size, elem_ret_align) =
elem_ret.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);

2
crates/compiler/gen_wasm/src/wasm32_result.rs
View file

@ -55,7 +55,7 @@ pub fn insert_wrapper_for_layout<'a>(
}
};
match interner.get(layout).repr {
match interner.get_repr(layout) {
LayoutRepr::Builtin(Builtin::Int(IntWidth::U8 | IntWidth::I8)) => {
i8::insert_wrapper(arena, module, wrapper_name, main_fn_index);
}