mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-20 15:27:45 +03:00
Merge pull request #3742 from roc-lang/cleanup-mono-layout
Cleanup/refactoring of lambda set layout generation
This commit is contained in:
commit
334bc7174f
@ -6411,11 +6411,11 @@ fn to_cc_type<'a, 'ctx, 'env>(
|
||||
env: &Env<'a, 'ctx, 'env>,
|
||||
layout: &Layout<'a>,
|
||||
) -> BasicTypeEnum<'ctx> {
|
||||
match layout {
|
||||
Layout::Builtin(builtin) => to_cc_type_builtin(env, builtin),
|
||||
_ => {
|
||||
match layout.runtime_representation() {
|
||||
Layout::Builtin(builtin) => to_cc_type_builtin(env, &builtin),
|
||||
layout => {
|
||||
// TODO this is almost certainly incorrect for bigger structs
|
||||
basic_type_from_layout(env, layout)
|
||||
basic_type_from_layout(env, &layout)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -517,7 +517,7 @@ impl<'a> WasmBackend<'a> {
|
||||
|
||||
// Load all the arguments for the inner function
|
||||
for (i, wrapper_arg) in wrapper_arg_layouts.iter().enumerate() {
|
||||
let is_closure_data = i == 0; // Skip closure data (first for wrapper, last for inner)
|
||||
let is_closure_data = i == 0; // Skip closure data (first for wrapper, last for inner). We'll handle it below.
|
||||
let is_return_pointer = i == wrapper_arg_layouts.len() - 1; // Skip return pointer (may not be an arg for inner. And if it is, swaps from end to start)
|
||||
if is_closure_data || is_return_pointer {
|
||||
continue;
|
||||
@ -540,7 +540,23 @@ impl<'a> WasmBackend<'a> {
|
||||
// If the inner function has closure data, it's the last arg of the inner fn
|
||||
let closure_data_layout = wrapper_arg_layouts[0];
|
||||
if closure_data_layout.stack_size(TARGET_INFO) > 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 closure_data_layout {
|
||||
Layout::Struct {
|
||||
field_layouts: [inner],
|
||||
..
|
||||
} => inner,
|
||||
other => internal_error!(
|
||||
"Expected a boxed layout for wrapped closure data, got {:?}",
|
||||
other
|
||||
),
|
||||
};
|
||||
self.code_builder.get_local(LocalId(0));
|
||||
// Since the closure data is wrapped in a one-element struct, we've been passed in the
|
||||
// pointer to that struct in the stack memory. To get the closure data we just need to
|
||||
// dereference the pointer.
|
||||
self.dereference_boxed_value(inner_closure_data_layout);
|
||||
}
|
||||
|
||||
// Call the wrapped inner function
|
||||
|
@ -1857,11 +1857,15 @@ impl<'a> LowLevelCall<'a> {
|
||||
/// Equality and inequality
|
||||
/// These can operate on any data type (except functions) so they're more complex than other operators.
|
||||
fn eq_or_neq(&self, backend: &mut WasmBackend<'a>) {
|
||||
let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]];
|
||||
let other_arg_layout = backend.storage.symbol_layouts[&self.arguments[1]];
|
||||
let arg_layout =
|
||||
backend.storage.symbol_layouts[&self.arguments[0]].runtime_representation();
|
||||
let other_arg_layout =
|
||||
backend.storage.symbol_layouts[&self.arguments[1]].runtime_representation();
|
||||
debug_assert!(
|
||||
arg_layout == other_arg_layout,
|
||||
"Cannot do `==` comparison on different types"
|
||||
"Cannot do `==` comparison on different types: {:?} vs {:?}",
|
||||
arg_layout,
|
||||
other_arg_layout
|
||||
);
|
||||
|
||||
let invert_result = matches!(self.lowlevel, LowLevel::NotEq);
|
||||
@ -2113,6 +2117,18 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
..
|
||||
} = passed_function;
|
||||
|
||||
// The zig lowlevel builtins expect the passed functions' closure data to always
|
||||
// be sent as an opaque pointer. On the Roc side, however, we need to call the passed function
|
||||
// with the Roc representation of the closure data. There are three possible cases for that
|
||||
// representation:
|
||||
//
|
||||
// 1. The closure data is a struct
|
||||
// 2. The closure data is an unwrapped value
|
||||
// 3. There is no closure data
|
||||
//
|
||||
// To uniformly deal with the first two cases, always put the closure data, when it exists,
|
||||
// into a one-element struct. That way, we get a pointer (i32) that can be passed to the zig lowlevels.
|
||||
// The wrapper around the passed function will access the actual closure data in the struct.
|
||||
let (closure_data_layout, closure_data_exists) =
|
||||
match backend.storage.symbol_layouts[captured_environment] {
|
||||
Layout::LambdaSet(lambda_set) => {
|
||||
@ -2131,6 +2147,46 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
x => internal_error!("Closure data has an invalid layout\n{:?}", x),
|
||||
};
|
||||
|
||||
let (wrapped_captured_environment, wrapped_captures_layout) = if closure_data_exists {
|
||||
// If there is closure data, make sure we put in a struct it before passing it to the
|
||||
// external builtin impl. That way it's always an `i32` pointer.
|
||||
let wrapped_closure_data_sym = backend.create_symbol("wrapped_captures");
|
||||
let wrapped_captures_layout =
|
||||
Layout::struct_no_name_order(backend.env.arena.alloc([closure_data_layout]));
|
||||
|
||||
// make sure that the wrapping struct is available in stack memory, so we can hand out a
|
||||
// pointer to it.
|
||||
let wrapped_storage = backend.storage.allocate_var(
|
||||
wrapped_captures_layout,
|
||||
wrapped_closure_data_sym,
|
||||
crate::storage::StoredVarKind::Variable,
|
||||
);
|
||||
|
||||
let (wrapped_storage_local_ptr, wrapped_storage_offset) = match wrapped_storage {
|
||||
StoredValue::StackMemory { location, .. } => {
|
||||
location.local_and_offset(backend.storage.stack_frame_pointer)
|
||||
}
|
||||
other => internal_error!(
|
||||
"Struct should be allocated in stack memory, but it's in {:?}",
|
||||
other
|
||||
),
|
||||
};
|
||||
|
||||
// copy the actual closure data into the first and only element of the wrapping struct.
|
||||
backend.storage.copy_value_to_memory(
|
||||
&mut backend.code_builder,
|
||||
wrapped_storage_local_ptr,
|
||||
wrapped_storage_offset,
|
||||
*captured_environment,
|
||||
);
|
||||
|
||||
(wrapped_closure_data_sym, wrapped_captures_layout)
|
||||
} else {
|
||||
// If we don't capture anything, pass along the captured environment as-is - the wrapper
|
||||
// function will take care not to unwrap this.
|
||||
(*captured_environment, closure_data_layout)
|
||||
};
|
||||
|
||||
// We create a wrapper around the passed function, which just unboxes the arguments.
|
||||
// This allows Zig builtins to have a generic pointer-based interface.
|
||||
let helper_proc_source = {
|
||||
@ -2164,7 +2220,7 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
argument_layouts.len()
|
||||
};
|
||||
|
||||
wrapper_arg_layouts.push(closure_data_layout);
|
||||
wrapper_arg_layouts.push(wrapped_captures_layout);
|
||||
wrapper_arg_layouts.extend(
|
||||
argument_layouts
|
||||
.iter()
|
||||
@ -2204,7 +2260,7 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
.get_refcount_fn_index(Layout::Builtin(Builtin::Int(IntWidth::I32)), HelperOp::Inc);
|
||||
backend.get_fn_ptr(inc_fn)
|
||||
} else {
|
||||
let inc_fn = backend.get_refcount_fn_index(closure_data_layout, HelperOp::Inc);
|
||||
let inc_fn = backend.get_refcount_fn_index(wrapped_captures_layout, HelperOp::Inc);
|
||||
backend.get_fn_ptr(inc_fn)
|
||||
};
|
||||
|
||||
@ -2218,7 +2274,7 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
wrapper_fn_ptr,
|
||||
inc_fn_ptr,
|
||||
closure_data_exists,
|
||||
*captured_environment,
|
||||
wrapped_captured_environment,
|
||||
*owns_captured_environment,
|
||||
),
|
||||
|
||||
@ -2231,7 +2287,7 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
wrapper_fn_ptr,
|
||||
inc_fn_ptr,
|
||||
closure_data_exists,
|
||||
*captured_environment,
|
||||
wrapped_captured_environment,
|
||||
*owns_captured_environment,
|
||||
),
|
||||
|
||||
@ -2244,7 +2300,7 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
wrapper_fn_ptr,
|
||||
inc_fn_ptr,
|
||||
closure_data_exists,
|
||||
*captured_environment,
|
||||
wrapped_captured_environment,
|
||||
*owns_captured_environment,
|
||||
),
|
||||
|
||||
@ -2257,7 +2313,7 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
wrapper_fn_ptr,
|
||||
inc_fn_ptr,
|
||||
closure_data_exists,
|
||||
*captured_environment,
|
||||
wrapped_captured_environment,
|
||||
*owns_captured_environment,
|
||||
),
|
||||
|
||||
@ -2280,7 +2336,9 @@ pub fn call_higher_order_lowlevel<'a>(
|
||||
backend.storage.load_symbol_zig(cb, *xs);
|
||||
cb.i32_const(wrapper_fn_ptr);
|
||||
if closure_data_exists {
|
||||
backend.storage.load_symbols(cb, &[*captured_environment]);
|
||||
backend
|
||||
.storage
|
||||
.load_symbols(cb, &[wrapped_captured_environment]);
|
||||
} else {
|
||||
// load_symbols assumes that a zero-size arg should be eliminated in code gen,
|
||||
// but that's a specialization that our Zig code doesn't have! Pass a null pointer.
|
||||
|
@ -719,9 +719,10 @@ impl<'a> Storage<'a> {
|
||||
) => {
|
||||
debug_assert!(to_value_type == from_value_type);
|
||||
debug_assert!(to_size == from_size);
|
||||
// Note: load_symbols will not destroy the value, so we can use it again later.
|
||||
// It will leave a Popped marker in the VM stack model in CodeBuilder
|
||||
self.load_symbols(code_builder, &[from_symbol]);
|
||||
code_builder.set_local(*to_local_id);
|
||||
self.symbol_storage_map.insert(from_symbol, to.clone());
|
||||
}
|
||||
|
||||
(
|
||||
|
@ -1,8 +1,9 @@
|
||||
#![allow(clippy::manual_map)]
|
||||
|
||||
use crate::layout::{
|
||||
Builtin, CapturesNiche, ClosureRepresentation, LambdaName, LambdaSet, Layout, LayoutCache,
|
||||
LayoutProblem, RawFunctionLayout, TagIdIntType, UnionLayout, WrappedVariant,
|
||||
Builtin, CapturesNiche, ClosureCallOptions, ClosureRepresentation, EnumDispatch, LambdaName,
|
||||
LambdaSet, Layout, LayoutCache, LayoutProblem, RawFunctionLayout, TagIdIntType, UnionLayout,
|
||||
WrappedVariant,
|
||||
};
|
||||
use bumpalo::collections::{CollectIn, Vec};
|
||||
use bumpalo::Bump;
|
||||
@ -3114,6 +3115,8 @@ fn specialize_external<'a>(
|
||||
closure: opt_closure_layout,
|
||||
ret_layout,
|
||||
} => {
|
||||
let mut proc_args = Vec::from_iter_in(proc_args.iter().copied(), env.arena);
|
||||
|
||||
// unpack the closure symbols, if any
|
||||
match (opt_closure_layout, captured_symbols) {
|
||||
(Some(closure_layout), CapturedSymbols::Captured(captured)) => {
|
||||
@ -3233,41 +3236,35 @@ fn specialize_external<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
ClosureRepresentation::Other(layout) => match layout {
|
||||
Layout::Builtin(Builtin::Bool) => {
|
||||
// just ignore this value
|
||||
// IDEA don't pass this value in the future
|
||||
}
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
|
||||
// just ignore this value
|
||||
// IDEA don't pass this value in the future
|
||||
}
|
||||
other => {
|
||||
// NOTE other values always should be wrapped in a 1-element record
|
||||
unreachable!(
|
||||
"{:?} is not a valid closure data representation",
|
||||
other
|
||||
)
|
||||
}
|
||||
},
|
||||
ClosureRepresentation::UnwrappedCapture(_layout) => {
|
||||
debug_assert_eq!(captured.len(), 1);
|
||||
let (captured_symbol, _captured_layout) = captured[0];
|
||||
|
||||
// The capture set is unwrapped, so simply replace the closure argument
|
||||
// to the function with the unwrapped capture name.
|
||||
let captured_symbol = get_specialized_name(captured_symbol);
|
||||
let closure_arg = proc_args.last_mut().unwrap();
|
||||
debug_assert_eq!(closure_arg.1, Symbol::ARG_CLOSURE);
|
||||
closure_arg.1 = captured_symbol;
|
||||
}
|
||||
|
||||
ClosureRepresentation::EnumDispatch(_) => {
|
||||
// just ignore this value, since it's not a capture
|
||||
// IDEA don't pass this value in the future
|
||||
}
|
||||
}
|
||||
}
|
||||
(None, CapturedSymbols::None) | (None, CapturedSymbols::Captured([])) => {}
|
||||
_ => unreachable!("to closure or not to closure?"),
|
||||
}
|
||||
|
||||
let proc_args: Vec<_> = proc_args
|
||||
.iter()
|
||||
.map(|&(layout, symbol)| {
|
||||
// Grab the specialization symbol, if it exists.
|
||||
let symbol = procs
|
||||
.symbol_specializations
|
||||
.remove_single(symbol)
|
||||
.unwrap_or(symbol);
|
||||
|
||||
(layout, symbol)
|
||||
})
|
||||
.collect_in(env.arena);
|
||||
proc_args.iter_mut().for_each(|(_layout, symbol)| {
|
||||
// Grab the specialization symbol, if it exists.
|
||||
*symbol = procs
|
||||
.symbol_specializations
|
||||
.remove_single(*symbol)
|
||||
.unwrap_or(*symbol);
|
||||
});
|
||||
|
||||
// reset subs, so we don't get type errors when specializing for a different signature
|
||||
layout_cache.rollback_to(cache_snapshot);
|
||||
@ -5383,29 +5380,42 @@ where
|
||||
|
||||
Stmt::Let(assigned, expr, lambda_set_layout, hole)
|
||||
}
|
||||
ClosureRepresentation::Other(Layout::Builtin(Builtin::Bool)) => {
|
||||
debug_assert_eq!(symbols.len(), 0);
|
||||
ClosureRepresentation::UnwrappedCapture(_layout) => {
|
||||
debug_assert_eq!(symbols.len(), 1);
|
||||
|
||||
debug_assert_eq!(lambda_set.set.len(), 2);
|
||||
let tag_id = name.name() != lambda_set.iter_set().next().unwrap().name();
|
||||
let expr = Expr::Literal(Literal::Bool(tag_id));
|
||||
let mut symbols = symbols;
|
||||
let (captured_symbol, _) = symbols.next().unwrap();
|
||||
|
||||
Stmt::Let(assigned, expr, lambda_set_layout, hole)
|
||||
// The capture set is unwrapped, so just replaced the assigned capture symbol with the
|
||||
// only capture.
|
||||
let mut hole = hole.clone();
|
||||
substitute_in_exprs(env.arena, &mut hole, assigned, *captured_symbol);
|
||||
hole
|
||||
}
|
||||
ClosureRepresentation::Other(Layout::Builtin(Builtin::Int(IntWidth::U8))) => {
|
||||
debug_assert_eq!(symbols.len(), 0);
|
||||
ClosureRepresentation::EnumDispatch(repr) => match repr {
|
||||
EnumDispatch::Bool => {
|
||||
debug_assert_eq!(symbols.len(), 0);
|
||||
|
||||
debug_assert!(lambda_set.set.len() > 2);
|
||||
let tag_id = lambda_set
|
||||
.iter_set()
|
||||
.position(|s| s.name() == name.name())
|
||||
.unwrap() as u8;
|
||||
debug_assert_eq!(lambda_set.len(), 2);
|
||||
let tag_id = name.name() != lambda_set.iter_set().next().unwrap().name();
|
||||
let expr = Expr::Literal(Literal::Bool(tag_id));
|
||||
|
||||
let expr = Expr::Literal(Literal::Byte(tag_id));
|
||||
Stmt::Let(assigned, expr, lambda_set_layout, hole)
|
||||
}
|
||||
EnumDispatch::U8 => {
|
||||
debug_assert_eq!(symbols.len(), 0);
|
||||
|
||||
Stmt::Let(assigned, expr, lambda_set_layout, hole)
|
||||
}
|
||||
_ => unreachable!(),
|
||||
debug_assert!(lambda_set.len() > 2);
|
||||
let tag_id = lambda_set
|
||||
.iter_set()
|
||||
.position(|s| s.name() == name.name())
|
||||
.unwrap() as u8;
|
||||
|
||||
let expr = Expr::Literal(Literal::Byte(tag_id));
|
||||
|
||||
Stmt::Let(assigned, expr, lambda_set_layout, hole)
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
result
|
||||
@ -5844,10 +5854,7 @@ fn register_capturing_closure<'a>(
|
||||
Content::Structure(FlatType::Func(_, closure_var, _)) => {
|
||||
match LambdaSet::from_var(env.arena, env.subs, closure_var, env.target_info) {
|
||||
Ok(lambda_set) => {
|
||||
if let Layout::Struct {
|
||||
field_layouts: &[], ..
|
||||
} = lambda_set.runtime_representation()
|
||||
{
|
||||
if lambda_set.is_represented().is_none() {
|
||||
CapturedSymbols::None
|
||||
} else {
|
||||
let mut temp = Vec::from_iter_in(captured_symbols, env.arena);
|
||||
@ -9088,9 +9095,9 @@ fn lowlevel_match_on_lambda_set<'a, ToLowLevelCall>(
|
||||
where
|
||||
ToLowLevelCall: Fn(ToLowLevelCallArguments<'a>) -> Call<'a> + Copy,
|
||||
{
|
||||
match lambda_set.runtime_representation() {
|
||||
Layout::VOID => empty_lambda_set_error(),
|
||||
Layout::Union(union_layout) => {
|
||||
match lambda_set.call_by_name_options() {
|
||||
ClosureCallOptions::Void => empty_lambda_set_error(),
|
||||
ClosureCallOptions::Union(union_layout) => {
|
||||
let closure_tag_id_symbol = env.unique_symbol();
|
||||
|
||||
let result = lowlevel_union_lambda_set_to_switch(
|
||||
@ -9119,7 +9126,7 @@ where
|
||||
env.arena.alloc(result),
|
||||
)
|
||||
}
|
||||
Layout::Struct { .. } => match lambda_set.iter_set().next() {
|
||||
ClosureCallOptions::Struct { .. } => match lambda_set.iter_set().next() {
|
||||
Some(lambda_name) => {
|
||||
let call_spec_id = env.next_call_specialization_id();
|
||||
let update_mode = env.next_update_mode_id();
|
||||
@ -9144,39 +9151,58 @@ where
|
||||
hole.clone()
|
||||
}
|
||||
},
|
||||
Layout::Builtin(Builtin::Bool) => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
ClosureCallOptions::UnwrappedCapture(_) => {
|
||||
let lambda_name = lambda_set
|
||||
.iter_set()
|
||||
.next()
|
||||
.expect("no function in lambda set");
|
||||
|
||||
lowlevel_enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Bool),
|
||||
let call_spec_id = env.next_call_specialization_id();
|
||||
let update_mode = env.next_update_mode_id();
|
||||
let call = to_lowlevel_call((
|
||||
lambda_name,
|
||||
closure_data_symbol,
|
||||
lambda_set.is_represented(),
|
||||
to_lowlevel_call,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
}
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
call_spec_id,
|
||||
update_mode,
|
||||
));
|
||||
|
||||
lowlevel_enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)),
|
||||
closure_data_symbol,
|
||||
lambda_set.is_represented(),
|
||||
to_lowlevel_call,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
build_call(env, call, assigned, return_layout, env.arena.alloc(hole))
|
||||
}
|
||||
other => todo!("{:?}", other),
|
||||
ClosureCallOptions::EnumDispatch(repr) => match repr {
|
||||
EnumDispatch::Bool => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
|
||||
lowlevel_enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Bool),
|
||||
closure_data_symbol,
|
||||
lambda_set.is_represented(),
|
||||
to_lowlevel_call,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
}
|
||||
EnumDispatch::U8 => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
|
||||
lowlevel_enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)),
|
||||
closure_data_symbol,
|
||||
lambda_set.is_represented(),
|
||||
to_lowlevel_call,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@ -9267,15 +9293,14 @@ fn match_on_lambda_set<'a>(
|
||||
assigned: Symbol,
|
||||
hole: &'a Stmt<'a>,
|
||||
) -> Stmt<'a> {
|
||||
match lambda_set.runtime_representation() {
|
||||
Layout::VOID => empty_lambda_set_error(),
|
||||
Layout::Union(union_layout) => {
|
||||
match lambda_set.call_by_name_options() {
|
||||
ClosureCallOptions::Void => empty_lambda_set_error(),
|
||||
ClosureCallOptions::Union(union_layout) => {
|
||||
let closure_tag_id_symbol = env.unique_symbol();
|
||||
|
||||
let result = union_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set,
|
||||
Layout::Union(union_layout),
|
||||
closure_tag_id_symbol,
|
||||
union_layout.tag_id_layout(),
|
||||
closure_data_symbol,
|
||||
@ -9299,9 +9324,9 @@ fn match_on_lambda_set<'a>(
|
||||
env.arena.alloc(result),
|
||||
)
|
||||
}
|
||||
Layout::Struct {
|
||||
ClosureCallOptions::Struct {
|
||||
field_layouts,
|
||||
field_order_hash,
|
||||
field_order_hash: _,
|
||||
} => {
|
||||
let function_symbol = match lambda_set.iter_set().next() {
|
||||
Some(function_symbol) => function_symbol,
|
||||
@ -9325,10 +9350,6 @@ fn match_on_lambda_set<'a>(
|
||||
_ => ClosureInfo::Captures {
|
||||
lambda_set,
|
||||
closure_data_symbol,
|
||||
closure_data_layout: Layout::Struct {
|
||||
field_layouts,
|
||||
field_order_hash,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
@ -9343,15 +9364,21 @@ fn match_on_lambda_set<'a>(
|
||||
hole,
|
||||
)
|
||||
}
|
||||
Layout::Builtin(Builtin::Bool) => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
ClosureCallOptions::UnwrappedCapture(_) => {
|
||||
let function_symbol = lambda_set
|
||||
.iter_set()
|
||||
.next()
|
||||
.expect("no function in lambda set");
|
||||
|
||||
enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Bool),
|
||||
let closure_info = ClosureInfo::Captures {
|
||||
lambda_set,
|
||||
closure_data_symbol,
|
||||
};
|
||||
|
||||
union_lambda_set_branch_help(
|
||||
env,
|
||||
function_symbol,
|
||||
closure_info,
|
||||
argument_symbols,
|
||||
argument_layouts,
|
||||
return_layout,
|
||||
@ -9359,23 +9386,38 @@ fn match_on_lambda_set<'a>(
|
||||
hole,
|
||||
)
|
||||
}
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
ClosureCallOptions::EnumDispatch(repr) => match repr {
|
||||
EnumDispatch::Bool => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
|
||||
enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)),
|
||||
closure_data_symbol,
|
||||
argument_symbols,
|
||||
argument_layouts,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
}
|
||||
other => todo!("{:?}", other),
|
||||
enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Bool),
|
||||
argument_symbols,
|
||||
argument_layouts,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
}
|
||||
EnumDispatch::U8 => {
|
||||
let closure_tag_id_symbol = closure_data_symbol;
|
||||
|
||||
enum_lambda_set_to_switch(
|
||||
env,
|
||||
lambda_set.iter_set(),
|
||||
closure_tag_id_symbol,
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)),
|
||||
argument_symbols,
|
||||
argument_layouts,
|
||||
return_layout,
|
||||
assigned,
|
||||
hole,
|
||||
)
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@ -9383,7 +9425,6 @@ fn match_on_lambda_set<'a>(
|
||||
fn union_lambda_set_to_switch<'a>(
|
||||
env: &mut Env<'a, '_>,
|
||||
lambda_set: LambdaSet<'a>,
|
||||
closure_layout: Layout<'a>,
|
||||
closure_tag_id_symbol: Symbol,
|
||||
closure_tag_id_layout: Layout<'a>,
|
||||
closure_data_symbol: Symbol,
|
||||
@ -9393,7 +9434,7 @@ fn union_lambda_set_to_switch<'a>(
|
||||
assigned: Symbol,
|
||||
hole: &'a Stmt<'a>,
|
||||
) -> Stmt<'a> {
|
||||
if lambda_set.set.is_empty() {
|
||||
if lambda_set.is_empty() {
|
||||
// NOTE this can happen if there is a type error somewhere. Since the lambda set is empty,
|
||||
// there is really nothing we can do here. We generate a runtime error here which allows
|
||||
// code gen to proceed. We then assume that we hit another (more descriptive) error before
|
||||
@ -9403,7 +9444,7 @@ fn union_lambda_set_to_switch<'a>(
|
||||
|
||||
let join_point_id = JoinPointId(env.unique_symbol());
|
||||
|
||||
let mut branches = Vec::with_capacity_in(lambda_set.set.len(), env.arena);
|
||||
let mut branches = Vec::with_capacity_in(lambda_set.len(), env.arena);
|
||||
|
||||
for (i, lambda_name) in lambda_set.iter_set().enumerate() {
|
||||
let closure_info = if lambda_name.no_captures() {
|
||||
@ -9412,7 +9453,6 @@ fn union_lambda_set_to_switch<'a>(
|
||||
ClosureInfo::Captures {
|
||||
lambda_set,
|
||||
closure_data_symbol,
|
||||
closure_data_layout: closure_layout,
|
||||
}
|
||||
};
|
||||
|
||||
@ -9482,11 +9522,10 @@ fn union_lambda_set_branch<'a>(
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ClosureInfo<'a> {
|
||||
Captures {
|
||||
closure_data_symbol: Symbol,
|
||||
/// The layout of this closure variant
|
||||
closure_data_layout: Layout<'a>,
|
||||
/// The whole lambda set representation this closure is a variant of
|
||||
lambda_set: LambdaSet<'a>,
|
||||
},
|
||||
@ -9508,34 +9547,21 @@ fn union_lambda_set_branch_help<'a>(
|
||||
ClosureInfo::Captures {
|
||||
lambda_set,
|
||||
closure_data_symbol,
|
||||
closure_data_layout,
|
||||
} => match closure_data_layout {
|
||||
Layout::Struct {
|
||||
field_layouts: &[], ..
|
||||
}
|
||||
| Layout::Builtin(Builtin::Bool)
|
||||
| Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
|
||||
(argument_layouts_slice, argument_symbols_slice)
|
||||
}
|
||||
_ => {
|
||||
// extend layouts with the layout of the closure environment
|
||||
let mut argument_layouts =
|
||||
Vec::with_capacity_in(argument_layouts_slice.len() + 1, env.arena);
|
||||
argument_layouts.extend(argument_layouts_slice);
|
||||
argument_layouts.push(Layout::LambdaSet(lambda_set));
|
||||
|
||||
} => {
|
||||
let argument_layouts =
|
||||
lambda_set.extend_argument_list(env.arena, argument_layouts_slice);
|
||||
let argument_symbols = if argument_layouts.len() > argument_layouts_slice.len() {
|
||||
// extend symbols with the symbol of the closure environment
|
||||
let mut argument_symbols =
|
||||
Vec::with_capacity_in(argument_symbols_slice.len() + 1, env.arena);
|
||||
argument_symbols.extend(argument_symbols_slice);
|
||||
argument_symbols.push(closure_data_symbol);
|
||||
|
||||
(
|
||||
argument_layouts.into_bump_slice(),
|
||||
argument_symbols.into_bump_slice(),
|
||||
)
|
||||
}
|
||||
},
|
||||
argument_symbols.into_bump_slice()
|
||||
} else {
|
||||
argument_symbols_slice
|
||||
};
|
||||
(argument_layouts, argument_symbols)
|
||||
}
|
||||
ClosureInfo::DoesNotCapture => {
|
||||
// sometimes unification causes a function that does not itself capture anything
|
||||
// to still get a lambda set that does store information. We must not pass a closure
|
||||
@ -9559,13 +9585,14 @@ fn union_lambda_set_branch_help<'a>(
|
||||
build_call(env, call, assigned, *return_layout, hole)
|
||||
}
|
||||
|
||||
/// Switches over a enum lambda set, which may dispatch to different functions, none of which
|
||||
/// capture.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn enum_lambda_set_to_switch<'a>(
|
||||
env: &mut Env<'a, '_>,
|
||||
lambda_set: impl ExactSizeIterator<Item = LambdaName<'a>>,
|
||||
closure_tag_id_symbol: Symbol,
|
||||
closure_tag_id_layout: Layout<'a>,
|
||||
closure_data_symbol: Symbol,
|
||||
argument_symbols: &'a [Symbol],
|
||||
argument_layouts: &'a [Layout<'a>],
|
||||
return_layout: &'a Layout<'a>,
|
||||
@ -9578,15 +9605,11 @@ fn enum_lambda_set_to_switch<'a>(
|
||||
|
||||
let mut branches = Vec::with_capacity_in(lambda_set.len(), env.arena);
|
||||
|
||||
let closure_layout = closure_tag_id_layout;
|
||||
|
||||
for (i, lambda_name) in lambda_set.into_iter().enumerate() {
|
||||
let stmt = enum_lambda_set_branch(
|
||||
env,
|
||||
join_point_id,
|
||||
lambda_name,
|
||||
closure_data_symbol,
|
||||
closure_layout,
|
||||
argument_symbols,
|
||||
argument_layouts,
|
||||
return_layout,
|
||||
@ -9622,15 +9645,14 @@ fn enum_lambda_set_to_switch<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
/// A branch for an enum lambda set branch dispatch, which never capture!
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn enum_lambda_set_branch<'a>(
|
||||
env: &mut Env<'a, '_>,
|
||||
join_point_id: JoinPointId,
|
||||
lambda_name: LambdaName<'a>,
|
||||
closure_data_symbol: Symbol,
|
||||
closure_data_layout: Layout<'a>,
|
||||
argument_symbols_slice: &'a [Symbol],
|
||||
argument_layouts_slice: &'a [Layout<'a>],
|
||||
argument_symbols: &'a [Symbol],
|
||||
argument_layouts: &'a [Layout<'a>],
|
||||
return_layout: &'a Layout<'a>,
|
||||
) -> Stmt<'a> {
|
||||
let result_symbol = env.unique_symbol();
|
||||
@ -9639,34 +9661,6 @@ fn enum_lambda_set_branch<'a>(
|
||||
|
||||
let assigned = result_symbol;
|
||||
|
||||
let (argument_layouts, argument_symbols) = match closure_data_layout {
|
||||
Layout::Struct {
|
||||
field_layouts: &[], ..
|
||||
}
|
||||
| Layout::Builtin(Builtin::Bool)
|
||||
| Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
|
||||
(argument_layouts_slice, argument_symbols_slice)
|
||||
}
|
||||
_ => {
|
||||
// extend layouts with the layout of the closure environment
|
||||
let mut argument_layouts =
|
||||
Vec::with_capacity_in(argument_layouts_slice.len() + 1, env.arena);
|
||||
argument_layouts.extend(argument_layouts_slice);
|
||||
argument_layouts.push(closure_data_layout);
|
||||
|
||||
// extend symbols with the symbol of the closure environment
|
||||
let mut argument_symbols =
|
||||
Vec::with_capacity_in(argument_symbols_slice.len() + 1, env.arena);
|
||||
argument_symbols.extend(argument_symbols_slice);
|
||||
argument_symbols.push(closure_data_symbol);
|
||||
|
||||
(
|
||||
argument_layouts.into_bump_slice(),
|
||||
argument_symbols.into_bump_slice(),
|
||||
)
|
||||
}
|
||||
};
|
||||
|
||||
let call = self::Call {
|
||||
call_type: CallType::ByName {
|
||||
name: lambda_name,
|
||||
|
@ -783,28 +783,56 @@ impl<'a> LambdaName<'a> {
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub struct LambdaSet<'a> {
|
||||
/// collection of function names and their closure arguments
|
||||
pub set: &'a [(Symbol, &'a [Layout<'a>])],
|
||||
set: &'a [(Symbol, &'a [Layout<'a>])],
|
||||
/// how the closure will be represented at runtime
|
||||
representation: &'a Layout<'a>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum EnumDispatch {
|
||||
Bool,
|
||||
U8,
|
||||
}
|
||||
|
||||
/// representation of the closure *for a particular function*
|
||||
#[derive(Debug)]
|
||||
pub enum ClosureRepresentation<'a> {
|
||||
/// the closure is represented as a union. Includes the tag ID!
|
||||
/// The closure is represented as a union. Includes the tag ID!
|
||||
/// Each variant is a different function, and its payloads are the captures.
|
||||
Union {
|
||||
alphabetic_order_fields: &'a [Layout<'a>],
|
||||
closure_name: Symbol,
|
||||
tag_id: TagIdIntType,
|
||||
union_layout: UnionLayout<'a>,
|
||||
},
|
||||
/// The closure is represented as a struct. The layouts are sorted
|
||||
/// alphabetically by the identifier that is captured.
|
||||
/// The closure is one function, whose captures are represented as a struct.
|
||||
/// The layouts are sorted alphabetically by the identifier that is captured.
|
||||
///
|
||||
/// We MUST sort these according to their stack size before code gen!
|
||||
AlphabeticOrderStruct(&'a [Layout<'a>]),
|
||||
/// the representation is anything but a union
|
||||
Other(Layout<'a>),
|
||||
/// The closure is one function that captures a single identifier, whose value is unwrapped.
|
||||
UnwrappedCapture(Layout<'a>),
|
||||
/// The closure dispatches to multiple functions, but none of them capture anything, so this is
|
||||
/// a boolean or integer flag.
|
||||
EnumDispatch(EnumDispatch),
|
||||
}
|
||||
|
||||
/// How the closure should be seen when determining a call-by-name.
|
||||
#[derive(Debug)]
|
||||
pub enum ClosureCallOptions<'a> {
|
||||
/// This is an empty lambda set, dispatching is an error
|
||||
Void,
|
||||
/// One of a few capturing functions can be called to
|
||||
Union(UnionLayout<'a>),
|
||||
/// The closure is one function, whose captures are represented as a struct.
|
||||
Struct {
|
||||
field_layouts: &'a [Layout<'a>],
|
||||
field_order_hash: FieldOrderHash,
|
||||
},
|
||||
/// The closure is one function that captures a single identifier, whose value is unwrapped.
|
||||
UnwrappedCapture(Layout<'a>),
|
||||
/// The closure dispatches to multiple possible functions, none of which capture.
|
||||
EnumDispatch(EnumDispatch),
|
||||
}
|
||||
|
||||
impl<'a> LambdaSet<'a> {
|
||||
@ -818,13 +846,17 @@ impl<'a> LambdaSet<'a> {
|
||||
}
|
||||
|
||||
pub fn is_represented(&self) -> Option<Layout<'a>> {
|
||||
match self.representation {
|
||||
Layout::Struct {
|
||||
field_layouts: &[], ..
|
||||
if self.has_unwrapped_capture_repr() {
|
||||
Some(*self.representation)
|
||||
} else if self.has_enum_dispatch_repr() {
|
||||
None
|
||||
} else {
|
||||
match self.representation {
|
||||
Layout::Struct {
|
||||
field_layouts: &[], ..
|
||||
} => None,
|
||||
repr => Some(*repr),
|
||||
}
|
||||
| Layout::Builtin(Builtin::Bool)
|
||||
| Layout::Builtin(Builtin::Int(..)) => None,
|
||||
repr => Some(*repr),
|
||||
}
|
||||
}
|
||||
|
||||
@ -835,6 +867,16 @@ impl<'a> LambdaSet<'a> {
|
||||
})
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn len(&self) -> usize {
|
||||
self.set.len()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.set.is_empty()
|
||||
}
|
||||
|
||||
pub fn layout_for_member_with_lambda_name(
|
||||
&self,
|
||||
lambda_name: LambdaName,
|
||||
@ -923,6 +965,11 @@ impl<'a> LambdaSet<'a> {
|
||||
where
|
||||
F: Fn(Symbol, &[Layout]) -> bool,
|
||||
{
|
||||
if self.has_unwrapped_capture_repr() {
|
||||
// Only one function, that captures one identifier.
|
||||
return ClosureRepresentation::UnwrappedCapture(*self.representation);
|
||||
}
|
||||
|
||||
match self.representation {
|
||||
Layout::Union(union) => {
|
||||
// here we rely on the fact that a union in a closure would be stored in a one-element record.
|
||||
@ -1004,7 +1051,58 @@ impl<'a> LambdaSet<'a> {
|
||||
|
||||
ClosureRepresentation::AlphabeticOrderStruct(fields)
|
||||
}
|
||||
_ => ClosureRepresentation::Other(*self.representation),
|
||||
layout => {
|
||||
debug_assert!(self.has_enum_dispatch_repr(),);
|
||||
let enum_repr = match layout {
|
||||
Layout::Builtin(Builtin::Bool) => EnumDispatch::Bool,
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)) => EnumDispatch::U8,
|
||||
other => internal_error!("Invalid layout for enum dispatch: {:?}", other),
|
||||
};
|
||||
ClosureRepresentation::EnumDispatch(enum_repr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn has_unwrapped_capture_repr(&self) -> bool {
|
||||
self.set.len() == 1 && self.set[0].1.len() == 1
|
||||
}
|
||||
|
||||
fn has_enum_dispatch_repr(&self) -> bool {
|
||||
self.set.len() > 1 && self.set.iter().all(|(_, captures)| captures.is_empty())
|
||||
}
|
||||
|
||||
pub fn call_by_name_options(&self) -> ClosureCallOptions<'a> {
|
||||
if self.has_unwrapped_capture_repr() {
|
||||
return ClosureCallOptions::UnwrappedCapture(*self.representation);
|
||||
}
|
||||
|
||||
match self.representation {
|
||||
Layout::Union(union_layout) => {
|
||||
if self.representation == &Layout::VOID {
|
||||
debug_assert!(self.set.is_empty());
|
||||
return ClosureCallOptions::Void;
|
||||
}
|
||||
ClosureCallOptions::Union(*union_layout)
|
||||
}
|
||||
Layout::Struct {
|
||||
field_layouts,
|
||||
field_order_hash,
|
||||
} => {
|
||||
debug_assert_eq!(self.set.len(), 1);
|
||||
ClosureCallOptions::Struct {
|
||||
field_layouts,
|
||||
field_order_hash: *field_order_hash,
|
||||
}
|
||||
}
|
||||
layout => {
|
||||
debug_assert!(self.has_enum_dispatch_repr());
|
||||
let enum_repr = match layout {
|
||||
Layout::Builtin(Builtin::Bool) => EnumDispatch::Bool,
|
||||
Layout::Builtin(Builtin::Int(IntWidth::U8)) => EnumDispatch::U8,
|
||||
other => internal_error!("Invalid layout for enum dispatch: {:?}", other),
|
||||
};
|
||||
ClosureCallOptions::EnumDispatch(enum_repr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1013,30 +1111,27 @@ impl<'a> LambdaSet<'a> {
|
||||
arena: &'a Bump,
|
||||
argument_layouts: &'a [Layout<'a>],
|
||||
) -> &'a [Layout<'a>] {
|
||||
if let [] = self.set {
|
||||
// TERRIBLE HACK for builting functions
|
||||
argument_layouts
|
||||
} else {
|
||||
match self.representation {
|
||||
Layout::Struct {
|
||||
field_layouts: &[], ..
|
||||
} => {
|
||||
// this function does not have anything in its closure, and the lambda set is a
|
||||
// singleton, so we pass no extra argument
|
||||
argument_layouts
|
||||
}
|
||||
Layout::Builtin(Builtin::Bool)
|
||||
| Layout::Builtin(Builtin::Int(IntWidth::I8 | IntWidth::U8)) => {
|
||||
// we don't pass this along either
|
||||
argument_layouts
|
||||
}
|
||||
_ => {
|
||||
let mut arguments = Vec::with_capacity_in(argument_layouts.len() + 1, arena);
|
||||
arguments.extend(argument_layouts);
|
||||
arguments.push(Layout::LambdaSet(*self));
|
||||
match self.call_by_name_options() {
|
||||
ClosureCallOptions::Void => argument_layouts,
|
||||
ClosureCallOptions::Struct {
|
||||
field_layouts: &[], ..
|
||||
} => {
|
||||
// this function does not have anything in its closure, and the lambda set is a
|
||||
// singleton, so we pass no extra argument
|
||||
argument_layouts
|
||||
}
|
||||
ClosureCallOptions::Struct { .. }
|
||||
| ClosureCallOptions::Union(_)
|
||||
| ClosureCallOptions::UnwrappedCapture(_) => {
|
||||
let mut arguments = Vec::with_capacity_in(argument_layouts.len() + 1, arena);
|
||||
arguments.extend(argument_layouts);
|
||||
arguments.push(Layout::LambdaSet(*self));
|
||||
|
||||
arguments.into_bump_slice()
|
||||
}
|
||||
arguments.into_bump_slice()
|
||||
}
|
||||
ClosureCallOptions::EnumDispatch(_) => {
|
||||
// No captures, don't pass this along
|
||||
argument_layouts
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1053,7 +1148,7 @@ impl<'a> LambdaSet<'a> {
|
||||
lambdas.sort_by_key(|(sym, _)| *sym);
|
||||
|
||||
let mut set: Vec<(Symbol, &[Layout])> = Vec::with_capacity_in(lambdas.len(), arena);
|
||||
let mut set_with_variables: std::vec::Vec<(Symbol, std::vec::Vec<Variable>)> =
|
||||
let mut set_with_variables: std::vec::Vec<(&Symbol, &[Variable])> =
|
||||
std::vec::Vec::with_capacity(lambdas.len());
|
||||
|
||||
let mut last_function_symbol = None;
|
||||
@ -1090,7 +1185,7 @@ impl<'a> LambdaSet<'a> {
|
||||
has_duplicate_lambda_names = has_duplicate_lambda_names || is_multimorphic;
|
||||
|
||||
set.push((*function_symbol, arguments));
|
||||
set_with_variables.push((*function_symbol, variables.to_vec()));
|
||||
set_with_variables.push((function_symbol, variables.as_slice()));
|
||||
|
||||
last_function_symbol = Some(function_symbol);
|
||||
}
|
||||
@ -1151,70 +1246,23 @@ impl<'a> LambdaSet<'a> {
|
||||
fn make_representation(
|
||||
arena: &'a Bump,
|
||||
subs: &Subs,
|
||||
tags: std::vec::Vec<(Symbol, std::vec::Vec<Variable>)>,
|
||||
tags: std::vec::Vec<(&Symbol, &[Variable])>,
|
||||
opt_rec_var: Option<Variable>,
|
||||
target_info: TargetInfo,
|
||||
) -> Layout<'a> {
|
||||
if let Some(rec_var) = opt_rec_var {
|
||||
let tags: std::vec::Vec<_> = tags
|
||||
.iter()
|
||||
.map(|(sym, vars)| (sym, vars.as_slice()))
|
||||
.collect();
|
||||
let tags = UnsortedUnionLabels { tags };
|
||||
let mut env = Env {
|
||||
seen: Vec::new_in(arena),
|
||||
target_info,
|
||||
arena,
|
||||
subs,
|
||||
};
|
||||
let union_labels = UnsortedUnionLabels { tags };
|
||||
let mut env = Env {
|
||||
seen: Vec::new_in(arena),
|
||||
target_info,
|
||||
arena,
|
||||
subs,
|
||||
};
|
||||
|
||||
return layout_from_recursive_union(&mut env, rec_var, &tags)
|
||||
.expect("unable to create lambda set representation");
|
||||
}
|
||||
match opt_rec_var {
|
||||
Some(rec_var) => layout_from_recursive_union(&mut env, rec_var, &union_labels)
|
||||
.expect("unable to create lambda set representation"),
|
||||
|
||||
// otherwise, this is a closure with a payload
|
||||
let variant = union_sorted_tags_help(arena, tags, opt_rec_var, subs, target_info);
|
||||
|
||||
use UnionVariant::*;
|
||||
match variant {
|
||||
Never => Layout::VOID,
|
||||
BoolUnion { .. } => Layout::bool(),
|
||||
ByteUnion { .. } => Layout::u8(),
|
||||
Unit | UnitWithArguments => {
|
||||
// no useful information to store
|
||||
Layout::UNIT
|
||||
}
|
||||
Newtype {
|
||||
arguments: layouts, ..
|
||||
} => Layout::struct_no_name_order(layouts.into_bump_slice()),
|
||||
Wrapped(variant) => {
|
||||
use WrappedVariant::*;
|
||||
|
||||
match variant {
|
||||
NonRecursive {
|
||||
sorted_tag_layouts: tags,
|
||||
} => {
|
||||
debug_assert!(tags.len() > 1);
|
||||
|
||||
// if the closed-over value is actually a layout, it should be wrapped in a 1-element record
|
||||
debug_assert!(matches!(tags[0].0, TagOrClosure::Closure(_)));
|
||||
|
||||
let mut tag_arguments = Vec::with_capacity_in(tags.len(), arena);
|
||||
|
||||
for (_, tag_args) in tags.iter() {
|
||||
tag_arguments.push(&tag_args[0..]);
|
||||
}
|
||||
Layout::Union(UnionLayout::NonRecursive(tag_arguments.into_bump_slice()))
|
||||
}
|
||||
|
||||
Recursive { .. }
|
||||
| NullableUnwrapped { .. }
|
||||
| NullableWrapped { .. }
|
||||
| NonNullableUnwrapped { .. } => {
|
||||
internal_error!("Recursive layouts should be produced in an earlier branch")
|
||||
}
|
||||
}
|
||||
}
|
||||
None => layout_from_union(&mut env, &union_labels),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1777,6 +1825,13 @@ impl<'a> Layout<'a> {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn runtime_representation(&self) -> Self {
|
||||
match self {
|
||||
Layout::LambdaSet(lambda_set) => lambda_set.runtime_representation(),
|
||||
other => *other,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Avoid recomputing Layout from Variable multiple times.
|
||||
|
@ -1234,8 +1234,8 @@ fn return_wrapped_closure() {
|
||||
main = foo
|
||||
"#
|
||||
),
|
||||
[5],
|
||||
[i64; 1]
|
||||
5,
|
||||
i64
|
||||
);
|
||||
}
|
||||
|
||||
|
@ -4,17 +4,15 @@ procedure List.6 (#Attr.2):
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.2 : I64 = 41i64;
|
||||
let Test.10 : {I64} = Struct {Test.2};
|
||||
let Test.9 : List {I64} = Array [Test.10];
|
||||
let Test.9 : List I64 = Array [Test.2];
|
||||
ret Test.9;
|
||||
|
||||
procedure Test.3 (Test.8, #Attr.12):
|
||||
let Test.2 : I64 = StructAtIndex 0 #Attr.12;
|
||||
procedure Test.3 (Test.8, Test.2):
|
||||
ret Test.2;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.7 : {} = Struct {};
|
||||
let Test.4 : List {I64} = CallByName Test.1 Test.7;
|
||||
let Test.4 : List I64 = CallByName Test.1 Test.7;
|
||||
let Test.6 : U64 = CallByName List.6 Test.4;
|
||||
dec Test.4;
|
||||
ret Test.6;
|
||||
|
@ -12,22 +12,20 @@ procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.388 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.388;
|
||||
|
||||
procedure Test.23 (Test.24, Test.35, #Attr.12):
|
||||
let Test.22 : U8 = StructAtIndex 0 #Attr.12;
|
||||
procedure Test.23 (Test.24, Test.35, Test.22):
|
||||
let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;
|
||||
ret Test.37;
|
||||
|
||||
procedure Test.8 (Test.22):
|
||||
let Test.34 : {U8} = Struct {Test.22};
|
||||
ret Test.34;
|
||||
ret Test.22;
|
||||
|
||||
procedure Test.9 (Test.27):
|
||||
let Test.33 : {U8} = CallByName Test.8 Test.27;
|
||||
let Test.33 : U8 = CallByName Test.8 Test.27;
|
||||
ret Test.33;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.32 : U8 = 15i64;
|
||||
let Test.28 : {U8} = CallByName Test.9 Test.32;
|
||||
let Test.28 : U8 = CallByName Test.9 Test.32;
|
||||
let Test.30 : List U8 = Array [];
|
||||
let Test.31 : {} = Struct {};
|
||||
let Test.29 : List U8 = CallByName Test.23 Test.30 Test.31 Test.28;
|
||||
|
@ -1,34 +1,26 @@
|
||||
procedure #Derived.0 (#Derived.1):
|
||||
let #Derived_gen.1 : {Str} = Struct {#Derived.1};
|
||||
let #Derived_gen.0 : {Str} = CallByName Encode.22 #Derived_gen.1;
|
||||
let #Derived_gen.0 : Str = CallByName Encode.22 #Derived.1;
|
||||
ret #Derived_gen.0;
|
||||
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12):
|
||||
let #Derived.1 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc #Derived.1;
|
||||
dec #Attr.12;
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
|
||||
let #Derived_gen.7 : Str = "a";
|
||||
let #Derived_gen.8 : {Str} = CallByName #Derived.5 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, {Str}} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, {Str}} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : {List {Str, {Str}}} = CallByName Json.20 #Derived_gen.5;
|
||||
let #Derived_gen.8 : Str = CallByName #Derived.5 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Json.20 #Derived_gen.5;
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.3 #Derived_gen.4 #Derived.4;
|
||||
ret #Derived_gen.3;
|
||||
|
||||
procedure #Derived.5 (#Derived.6):
|
||||
let #Derived_gen.15 : {Str} = Struct {#Derived.6};
|
||||
let #Derived_gen.14 : {Str} = CallByName Encode.22 #Derived_gen.15;
|
||||
let #Derived_gen.14 : Str = CallByName Encode.22 #Derived.6;
|
||||
ret #Derived_gen.14;
|
||||
|
||||
procedure #Derived.7 (#Derived.8, #Derived.9, #Attr.12):
|
||||
let #Derived.6 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc #Derived.6;
|
||||
dec #Attr.12;
|
||||
procedure #Derived.7 (#Derived.8, #Derived.9, #Derived.6):
|
||||
let #Derived_gen.21 : Str = "b";
|
||||
let #Derived_gen.22 : {Str} = CallByName Json.18 #Derived.6;
|
||||
let #Derived_gen.20 : {Str, {Str}} = Struct {#Derived_gen.21, #Derived_gen.22};
|
||||
let #Derived_gen.19 : List {Str, {Str}} = Array [#Derived_gen.20];
|
||||
let #Derived_gen.18 : {List {Str, {Str}}} = CallByName Json.20 #Derived_gen.19;
|
||||
let #Derived_gen.22 : Str = CallByName Json.18 #Derived.6;
|
||||
let #Derived_gen.20 : {Str, Str} = Struct {#Derived_gen.21, #Derived_gen.22};
|
||||
let #Derived_gen.19 : List {Str, Str} = Array [#Derived_gen.20];
|
||||
let #Derived_gen.18 : List {Str, Str} = CallByName Json.20 #Derived_gen.19;
|
||||
let #Derived_gen.17 : List U8 = CallByName Encode.23 #Derived.8 #Derived_gen.18 #Derived.9;
|
||||
ret #Derived_gen.17;
|
||||
|
||||
@ -69,7 +61,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
|
||||
|
||||
procedure Encode.25 (Encode.100, Encode.101):
|
||||
let Encode.104 : List U8 = Array [];
|
||||
let Encode.105 : {Str} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.105 : Str = CallByName #Derived.0 Encode.100;
|
||||
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
|
||||
ret Encode.103;
|
||||
|
||||
@ -77,10 +69,7 @@ procedure Json.1 ():
|
||||
let Json.318 : {} = Struct {};
|
||||
ret Json.318;
|
||||
|
||||
procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
let Json.102 : List {Str, {Str}} = StructAtIndex 0 #Attr.12;
|
||||
inc Json.102;
|
||||
dec #Attr.12;
|
||||
procedure Json.103 (Json.104, Json.321, Json.102):
|
||||
let Json.354 : I32 = 123i64;
|
||||
let Json.353 : U8 = CallByName Num.123 Json.354;
|
||||
let Json.106 : List U8 = CallByName List.4 Json.104 Json.353;
|
||||
@ -97,10 +86,7 @@ procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
let Json.325 : List U8 = CallByName List.4 Json.108 Json.326;
|
||||
ret Json.325;
|
||||
|
||||
procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
let Json.102 : List {Str, {Str}} = StructAtIndex 0 #Attr.12;
|
||||
inc Json.102;
|
||||
dec #Attr.12;
|
||||
procedure Json.103 (Json.104, Json.321, Json.102):
|
||||
let Json.397 : I32 = 123i64;
|
||||
let Json.396 : U8 = CallByName Num.123 Json.397;
|
||||
let Json.106 : List U8 = CallByName List.4 Json.104 Json.396;
|
||||
@ -120,7 +106,7 @@ procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
procedure Json.105 (Json.323, Json.324):
|
||||
let Json.111 : Str = StructAtIndex 0 Json.324;
|
||||
inc Json.111;
|
||||
let Json.112 : {Str} = StructAtIndex 1 Json.324;
|
||||
let Json.112 : Str = StructAtIndex 1 Json.324;
|
||||
inc Json.112;
|
||||
dec Json.324;
|
||||
let Json.109 : List U8 = StructAtIndex 0 Json.323;
|
||||
@ -159,7 +145,7 @@ procedure Json.105 (Json.323, Json.324):
|
||||
procedure Json.105 (Json.323, Json.324):
|
||||
let Json.111 : Str = StructAtIndex 0 Json.324;
|
||||
inc Json.111;
|
||||
let Json.112 : {Str} = StructAtIndex 1 Json.324;
|
||||
let Json.112 : Str = StructAtIndex 1 Json.324;
|
||||
inc Json.112;
|
||||
dec Json.324;
|
||||
let Json.109 : List U8 = StructAtIndex 0 Json.323;
|
||||
@ -196,24 +182,18 @@ procedure Json.105 (Json.323, Json.324):
|
||||
jump Json.378 Json.113;
|
||||
|
||||
procedure Json.18 (Json.86):
|
||||
let Json.365 : {Str} = Struct {Json.86};
|
||||
let Json.364 : {Str} = CallByName Encode.22 Json.365;
|
||||
let Json.364 : Str = CallByName Encode.22 Json.86;
|
||||
ret Json.364;
|
||||
|
||||
procedure Json.20 (Json.102):
|
||||
let Json.320 : {List {Str, {Str}}} = Struct {Json.102};
|
||||
let Json.319 : {List {Str, {Str}}} = CallByName Encode.22 Json.320;
|
||||
let Json.319 : List {Str, Str} = CallByName Encode.22 Json.102;
|
||||
ret Json.319;
|
||||
|
||||
procedure Json.20 (Json.102):
|
||||
let Json.362 : {List {Str, {Str}}} = Struct {Json.102};
|
||||
let Json.361 : {List {Str, {Str}}} = CallByName Encode.22 Json.362;
|
||||
let Json.361 : List {Str, Str} = CallByName Encode.22 Json.102;
|
||||
ret Json.361;
|
||||
|
||||
procedure Json.87 (Json.88, Json.366, #Attr.12):
|
||||
let Json.86 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.86;
|
||||
dec #Attr.12;
|
||||
procedure Json.87 (Json.88, Json.366, Json.86):
|
||||
let Json.406 : I32 = 34i64;
|
||||
let Json.405 : U8 = CallByName Num.123 Json.406;
|
||||
let Json.403 : List U8 = CallByName List.4 Json.88 Json.405;
|
||||
@ -224,21 +204,18 @@ procedure Json.87 (Json.88, Json.366, #Attr.12):
|
||||
let Json.399 : List U8 = CallByName List.4 Json.400 Json.401;
|
||||
ret Json.399;
|
||||
|
||||
procedure List.133 (List.134, List.135, #Attr.12):
|
||||
let List.132 : {} = StructAtIndex 0 #Attr.12;
|
||||
procedure List.133 (List.134, List.135, List.132):
|
||||
let List.434 : {List U8, U64} = CallByName Json.105 List.134 List.135;
|
||||
let List.433 : [C [], C {List U8, U64}] = TagId(1) List.434;
|
||||
ret List.433;
|
||||
|
||||
procedure List.133 (List.134, List.135, #Attr.12):
|
||||
let List.132 : {} = StructAtIndex 0 #Attr.12;
|
||||
procedure List.133 (List.134, List.135, List.132):
|
||||
let List.515 : {List U8, U64} = CallByName Json.105 List.134 List.135;
|
||||
let List.514 : [C [], C {List U8, U64}] = TagId(1) List.515;
|
||||
ret List.514;
|
||||
|
||||
procedure List.18 (List.130, List.131, List.132):
|
||||
let List.411 : {{}} = Struct {List.132};
|
||||
let List.405 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.411;
|
||||
let List.405 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.132;
|
||||
let List.408 : U8 = 1i64;
|
||||
let List.409 : U8 = GetTagId List.405;
|
||||
let List.410 : Int1 = lowlevel Eq List.408 List.409;
|
||||
@ -254,8 +231,7 @@ procedure List.18 (List.130, List.131, List.132):
|
||||
ret List.407;
|
||||
|
||||
procedure List.18 (List.130, List.131, List.132):
|
||||
let List.491 : {{}} = Struct {List.132};
|
||||
let List.485 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.491;
|
||||
let List.485 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.132;
|
||||
let List.488 : U8 = 1i64;
|
||||
let List.489 : U8 = GetTagId List.485;
|
||||
let List.490 : Int1 = lowlevel Eq List.488 List.489;
|
||||
@ -289,11 +265,11 @@ procedure List.6 (#Attr.2):
|
||||
ret List.494;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.432 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
let List.432 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.432;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.513 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
let List.513 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.513;
|
||||
|
||||
procedure List.69 (#Attr.2):
|
||||
@ -328,7 +304,7 @@ procedure List.86 (List.448, List.449, List.450, List.451, List.452):
|
||||
joinpoint List.420 List.364 List.365 List.366 List.367 List.368:
|
||||
let List.422 : Int1 = CallByName Num.22 List.367 List.368;
|
||||
if List.422 then
|
||||
let List.431 : {Str, {Str}} = CallByName List.66 List.364 List.367;
|
||||
let List.431 : {Str, Str} = CallByName List.66 List.364 List.367;
|
||||
let List.423 : [C [], C {List U8, U64}] = CallByName List.133 List.365 List.431 List.366;
|
||||
let List.428 : U8 = 1i64;
|
||||
let List.429 : U8 = GetTagId List.423;
|
||||
@ -355,7 +331,7 @@ procedure List.86 (List.529, List.530, List.531, List.532, List.533):
|
||||
joinpoint List.501 List.364 List.365 List.366 List.367 List.368:
|
||||
let List.503 : Int1 = CallByName Num.22 List.367 List.368;
|
||||
if List.503 then
|
||||
let List.512 : {Str, {Str}} = CallByName List.66 List.364 List.367;
|
||||
let List.512 : {Str, Str} = CallByName List.66 List.364 List.367;
|
||||
let List.504 : [C [], C {List U8, U64}] = CallByName List.133 List.365 List.512 List.366;
|
||||
let List.509 : U8 = 1i64;
|
||||
let List.510 : U8 = GetTagId List.504;
|
||||
|
@ -1,17 +1,13 @@
|
||||
procedure #Derived.0 (#Derived.1):
|
||||
let #Derived_gen.1 : {Str} = Struct {#Derived.1};
|
||||
let #Derived_gen.0 : {Str} = CallByName Encode.22 #Derived_gen.1;
|
||||
let #Derived_gen.0 : Str = CallByName Encode.22 #Derived.1;
|
||||
ret #Derived_gen.0;
|
||||
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12):
|
||||
let #Derived.1 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc #Derived.1;
|
||||
dec #Attr.12;
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
|
||||
let #Derived_gen.7 : Str = "a";
|
||||
let #Derived_gen.8 : {Str} = CallByName Json.18 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, {Str}} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, {Str}} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : {List {Str, {Str}}} = CallByName Json.20 #Derived_gen.5;
|
||||
let #Derived_gen.8 : Str = CallByName Json.18 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Json.20 #Derived_gen.5;
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.3 #Derived_gen.4 #Derived.4;
|
||||
ret #Derived_gen.3;
|
||||
|
||||
@ -38,7 +34,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
|
||||
|
||||
procedure Encode.25 (Encode.100, Encode.101):
|
||||
let Encode.104 : List U8 = Array [];
|
||||
let Encode.105 : {Str} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.105 : Str = CallByName #Derived.0 Encode.100;
|
||||
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
|
||||
ret Encode.103;
|
||||
|
||||
@ -46,10 +42,7 @@ procedure Json.1 ():
|
||||
let Json.318 : {} = Struct {};
|
||||
ret Json.318;
|
||||
|
||||
procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
let Json.102 : List {Str, {Str}} = StructAtIndex 0 #Attr.12;
|
||||
inc Json.102;
|
||||
dec #Attr.12;
|
||||
procedure Json.103 (Json.104, Json.321, Json.102):
|
||||
let Json.357 : I32 = 123i64;
|
||||
let Json.356 : U8 = CallByName Num.123 Json.357;
|
||||
let Json.106 : List U8 = CallByName List.4 Json.104 Json.356;
|
||||
@ -69,7 +62,7 @@ procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
procedure Json.105 (Json.326, Json.327):
|
||||
let Json.111 : Str = StructAtIndex 0 Json.327;
|
||||
inc Json.111;
|
||||
let Json.112 : {Str} = StructAtIndex 1 Json.327;
|
||||
let Json.112 : Str = StructAtIndex 1 Json.327;
|
||||
inc Json.112;
|
||||
dec Json.327;
|
||||
let Json.109 : List U8 = StructAtIndex 0 Json.326;
|
||||
@ -106,19 +99,14 @@ procedure Json.105 (Json.326, Json.327):
|
||||
jump Json.338 Json.113;
|
||||
|
||||
procedure Json.18 (Json.86):
|
||||
let Json.323 : {Str} = Struct {Json.86};
|
||||
let Json.322 : {Str} = CallByName Encode.22 Json.323;
|
||||
let Json.322 : Str = CallByName Encode.22 Json.86;
|
||||
ret Json.322;
|
||||
|
||||
procedure Json.20 (Json.102):
|
||||
let Json.320 : {List {Str, {Str}}} = Struct {Json.102};
|
||||
let Json.319 : {List {Str, {Str}}} = CallByName Encode.22 Json.320;
|
||||
let Json.319 : List {Str, Str} = CallByName Encode.22 Json.102;
|
||||
ret Json.319;
|
||||
|
||||
procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.86 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.86;
|
||||
dec #Attr.12;
|
||||
procedure Json.87 (Json.88, Json.324, Json.86):
|
||||
let Json.366 : I32 = 34i64;
|
||||
let Json.365 : U8 = CallByName Num.123 Json.366;
|
||||
let Json.363 : List U8 = CallByName List.4 Json.88 Json.365;
|
||||
@ -129,15 +117,13 @@ procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.359 : List U8 = CallByName List.4 Json.360 Json.361;
|
||||
ret Json.359;
|
||||
|
||||
procedure List.133 (List.134, List.135, #Attr.12):
|
||||
let List.132 : {} = StructAtIndex 0 #Attr.12;
|
||||
procedure List.133 (List.134, List.135, List.132):
|
||||
let List.441 : {List U8, U64} = CallByName Json.105 List.134 List.135;
|
||||
let List.440 : [C [], C {List U8, U64}] = TagId(1) List.441;
|
||||
ret List.440;
|
||||
|
||||
procedure List.18 (List.130, List.131, List.132):
|
||||
let List.417 : {{}} = Struct {List.132};
|
||||
let List.411 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.417;
|
||||
let List.411 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.132;
|
||||
let List.414 : U8 = 1i64;
|
||||
let List.415 : U8 = GetTagId List.411;
|
||||
let List.416 : Int1 = lowlevel Eq List.414 List.415;
|
||||
@ -167,7 +153,7 @@ procedure List.6 (#Attr.2):
|
||||
ret List.420;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.439 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
let List.439 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.439;
|
||||
|
||||
procedure List.69 (#Attr.2):
|
||||
@ -196,7 +182,7 @@ procedure List.86 (List.455, List.456, List.457, List.458, List.459):
|
||||
joinpoint List.427 List.364 List.365 List.366 List.367 List.368:
|
||||
let List.429 : Int1 = CallByName Num.22 List.367 List.368;
|
||||
if List.429 then
|
||||
let List.438 : {Str, {Str}} = CallByName List.66 List.364 List.367;
|
||||
let List.438 : {Str, Str} = CallByName List.66 List.364 List.367;
|
||||
let List.430 : [C [], C {List U8, U64}] = CallByName List.133 List.365 List.438 List.366;
|
||||
let List.435 : U8 = 1i64;
|
||||
let List.436 : U8 = GetTagId List.430;
|
||||
|
@ -1,25 +1,21 @@
|
||||
procedure #Derived.0 (#Derived.1):
|
||||
let #Derived_gen.1 : {{Str, Str}} = Struct {#Derived.1};
|
||||
let #Derived_gen.0 : {{Str, Str}} = CallByName Encode.22 #Derived_gen.1;
|
||||
let #Derived_gen.0 : {Str, Str} = CallByName Encode.22 #Derived.1;
|
||||
ret #Derived_gen.0;
|
||||
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12):
|
||||
let #Derived.1 : {Str, Str} = StructAtIndex 0 #Attr.12;
|
||||
inc #Derived.1;
|
||||
dec #Attr.12;
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
|
||||
let #Derived_gen.11 : Str = "a";
|
||||
let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1;
|
||||
inc #Derived_gen.13;
|
||||
let #Derived_gen.12 : {Str} = CallByName Json.18 #Derived_gen.13;
|
||||
let #Derived_gen.6 : {Str, {Str}} = Struct {#Derived_gen.11, #Derived_gen.12};
|
||||
let #Derived_gen.12 : Str = CallByName Json.18 #Derived_gen.13;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12};
|
||||
let #Derived_gen.8 : Str = "b";
|
||||
let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1;
|
||||
inc #Derived_gen.10;
|
||||
dec #Derived.1;
|
||||
let #Derived_gen.9 : {Str} = CallByName Json.18 #Derived_gen.10;
|
||||
let #Derived_gen.7 : {Str, {Str}} = Struct {#Derived_gen.8, #Derived_gen.9};
|
||||
let #Derived_gen.5 : List {Str, {Str}} = Array [#Derived_gen.6, #Derived_gen.7];
|
||||
let #Derived_gen.4 : {List {Str, {Str}}} = CallByName Json.20 #Derived_gen.5;
|
||||
let #Derived_gen.9 : Str = CallByName Json.18 #Derived_gen.10;
|
||||
let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Json.20 #Derived_gen.5;
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.3 #Derived_gen.4 #Derived.4;
|
||||
ret #Derived_gen.3;
|
||||
|
||||
@ -46,7 +42,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
|
||||
|
||||
procedure Encode.25 (Encode.100, Encode.101):
|
||||
let Encode.104 : List U8 = Array [];
|
||||
let Encode.105 : {{Str, Str}} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.105 : {Str, Str} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
|
||||
ret Encode.103;
|
||||
|
||||
@ -54,10 +50,7 @@ procedure Json.1 ():
|
||||
let Json.318 : {} = Struct {};
|
||||
ret Json.318;
|
||||
|
||||
procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
let Json.102 : List {Str, {Str}} = StructAtIndex 0 #Attr.12;
|
||||
inc Json.102;
|
||||
dec #Attr.12;
|
||||
procedure Json.103 (Json.104, Json.321, Json.102):
|
||||
let Json.360 : I32 = 123i64;
|
||||
let Json.359 : U8 = CallByName Num.123 Json.360;
|
||||
let Json.106 : List U8 = CallByName List.4 Json.104 Json.359;
|
||||
@ -77,7 +70,7 @@ procedure Json.103 (Json.104, Json.321, #Attr.12):
|
||||
procedure Json.105 (Json.329, Json.330):
|
||||
let Json.111 : Str = StructAtIndex 0 Json.330;
|
||||
inc Json.111;
|
||||
let Json.112 : {Str} = StructAtIndex 1 Json.330;
|
||||
let Json.112 : Str = StructAtIndex 1 Json.330;
|
||||
inc Json.112;
|
||||
dec Json.330;
|
||||
let Json.109 : List U8 = StructAtIndex 0 Json.329;
|
||||
@ -114,19 +107,14 @@ procedure Json.105 (Json.329, Json.330):
|
||||
jump Json.341 Json.113;
|
||||
|
||||
procedure Json.18 (Json.86):
|
||||
let Json.326 : {Str} = Struct {Json.86};
|
||||
let Json.325 : {Str} = CallByName Encode.22 Json.326;
|
||||
let Json.325 : Str = CallByName Encode.22 Json.86;
|
||||
ret Json.325;
|
||||
|
||||
procedure Json.20 (Json.102):
|
||||
let Json.320 : {List {Str, {Str}}} = Struct {Json.102};
|
||||
let Json.319 : {List {Str, {Str}}} = CallByName Encode.22 Json.320;
|
||||
let Json.319 : List {Str, Str} = CallByName Encode.22 Json.102;
|
||||
ret Json.319;
|
||||
|
||||
procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.86 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.86;
|
||||
dec #Attr.12;
|
||||
procedure Json.87 (Json.88, Json.324, Json.86):
|
||||
let Json.369 : I32 = 34i64;
|
||||
let Json.368 : U8 = CallByName Num.123 Json.369;
|
||||
let Json.366 : List U8 = CallByName List.4 Json.88 Json.368;
|
||||
@ -137,15 +125,13 @@ procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.362 : List U8 = CallByName List.4 Json.363 Json.364;
|
||||
ret Json.362;
|
||||
|
||||
procedure List.133 (List.134, List.135, #Attr.12):
|
||||
let List.132 : {} = StructAtIndex 0 #Attr.12;
|
||||
procedure List.133 (List.134, List.135, List.132):
|
||||
let List.441 : {List U8, U64} = CallByName Json.105 List.134 List.135;
|
||||
let List.440 : [C [], C {List U8, U64}] = TagId(1) List.441;
|
||||
ret List.440;
|
||||
|
||||
procedure List.18 (List.130, List.131, List.132):
|
||||
let List.417 : {{}} = Struct {List.132};
|
||||
let List.411 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.417;
|
||||
let List.411 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.132;
|
||||
let List.414 : U8 = 1i64;
|
||||
let List.415 : U8 = GetTagId List.411;
|
||||
let List.416 : Int1 = lowlevel Eq List.414 List.415;
|
||||
@ -175,7 +161,7 @@ procedure List.6 (#Attr.2):
|
||||
ret List.420;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.439 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
let List.439 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.439;
|
||||
|
||||
procedure List.69 (#Attr.2):
|
||||
@ -204,7 +190,7 @@ procedure List.86 (List.455, List.456, List.457, List.458, List.459):
|
||||
joinpoint List.427 List.364 List.365 List.366 List.367 List.368:
|
||||
let List.429 : Int1 = CallByName Num.22 List.367 List.368;
|
||||
if List.429 then
|
||||
let List.438 : {Str, {Str}} = CallByName List.66 List.364 List.367;
|
||||
let List.438 : {Str, Str} = CallByName List.66 List.364 List.367;
|
||||
let List.430 : [C [], C {List U8, U64}] = CallByName List.133 List.365 List.438 List.366;
|
||||
let List.435 : U8 = 1i64;
|
||||
let List.436 : U8 = GetTagId List.430;
|
||||
|
@ -7,7 +7,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
|
||||
|
||||
procedure Encode.25 (Encode.100, Encode.101):
|
||||
let Encode.104 : List U8 = Array [];
|
||||
let Encode.105 : {Str} = CallByName Json.18 Encode.100;
|
||||
let Encode.105 : Str = CallByName Json.18 Encode.100;
|
||||
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
|
||||
ret Encode.103;
|
||||
|
||||
@ -16,14 +16,10 @@ procedure Json.1 ():
|
||||
ret Json.318;
|
||||
|
||||
procedure Json.18 (Json.86):
|
||||
let Json.320 : {Str} = Struct {Json.86};
|
||||
let Json.319 : {Str} = CallByName Encode.22 Json.320;
|
||||
let Json.319 : Str = CallByName Encode.22 Json.86;
|
||||
ret Json.319;
|
||||
|
||||
procedure Json.87 (Json.88, Json.321, #Attr.12):
|
||||
let Json.86 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.86;
|
||||
dec #Attr.12;
|
||||
procedure Json.87 (Json.88, Json.321, Json.86):
|
||||
let Json.330 : I32 = 34i64;
|
||||
let Json.329 : U8 = CallByName Num.123 Json.330;
|
||||
let Json.327 : List U8 = CallByName List.4 Json.88 Json.329;
|
||||
|
@ -1,20 +1,16 @@
|
||||
procedure #Derived.0 (#Derived.1):
|
||||
let #Derived_gen.1 : {Str} = Struct {#Derived.1};
|
||||
let #Derived_gen.0 : {Str} = CallByName Encode.22 #Derived_gen.1;
|
||||
let #Derived_gen.0 : Str = CallByName Encode.22 #Derived.1;
|
||||
ret #Derived_gen.0;
|
||||
|
||||
procedure #Derived.3 (#Derived.4, #Derived.5, #Attr.12):
|
||||
let #Derived.1 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc #Derived.1;
|
||||
dec #Attr.12;
|
||||
procedure #Derived.3 (#Derived.4, #Derived.5, #Derived.1):
|
||||
joinpoint #Derived_gen.5 #Derived_gen.4:
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.4 #Derived_gen.4 #Derived.5;
|
||||
ret #Derived_gen.3;
|
||||
in
|
||||
let #Derived_gen.7 : Str = "A";
|
||||
let #Derived_gen.9 : {Str} = CallByName Json.18 #Derived.1;
|
||||
let #Derived_gen.8 : List {Str} = Array [#Derived_gen.9];
|
||||
let #Derived_gen.6 : {Str, List {Str}} = CallByName Json.21 #Derived_gen.7 #Derived_gen.8;
|
||||
let #Derived_gen.9 : Str = CallByName Json.18 #Derived.1;
|
||||
let #Derived_gen.8 : List Str = Array [#Derived_gen.9];
|
||||
let #Derived_gen.6 : {Str, List Str} = CallByName Json.21 #Derived_gen.7 #Derived_gen.8;
|
||||
jump #Derived_gen.5 #Derived_gen.6;
|
||||
|
||||
procedure Encode.22 (Encode.93):
|
||||
@ -40,7 +36,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
|
||||
|
||||
procedure Encode.25 (Encode.100, Encode.101):
|
||||
let Encode.104 : List U8 = Array [];
|
||||
let Encode.105 : {Str} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.105 : Str = CallByName #Derived.0 Encode.100;
|
||||
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
|
||||
ret Encode.103;
|
||||
|
||||
@ -49,7 +45,7 @@ procedure Json.1 ():
|
||||
ret Json.318;
|
||||
|
||||
procedure Json.117 (Json.118, Json.321, #Attr.12):
|
||||
let Json.116 : List {Str} = StructAtIndex 1 #Attr.12;
|
||||
let Json.116 : List Str = StructAtIndex 1 #Attr.12;
|
||||
inc Json.116;
|
||||
let Json.115 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.115;
|
||||
@ -111,19 +107,15 @@ procedure Json.119 (Json.326, Json.125):
|
||||
jump Json.340 Json.126;
|
||||
|
||||
procedure Json.18 (Json.86):
|
||||
let Json.323 : {Str} = Struct {Json.86};
|
||||
let Json.322 : {Str} = CallByName Encode.22 Json.323;
|
||||
let Json.322 : Str = CallByName Encode.22 Json.86;
|
||||
ret Json.322;
|
||||
|
||||
procedure Json.21 (Json.115, Json.116):
|
||||
let Json.320 : {Str, List {Str}} = Struct {Json.115, Json.116};
|
||||
let Json.319 : {Str, List {Str}} = CallByName Encode.22 Json.320;
|
||||
let Json.320 : {Str, List Str} = Struct {Json.115, Json.116};
|
||||
let Json.319 : {Str, List Str} = CallByName Encode.22 Json.320;
|
||||
ret Json.319;
|
||||
|
||||
procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.86 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.86;
|
||||
dec #Attr.12;
|
||||
procedure Json.87 (Json.88, Json.324, Json.86):
|
||||
let Json.371 : I32 = 34i64;
|
||||
let Json.370 : U8 = CallByName Num.123 Json.371;
|
||||
let Json.368 : List U8 = CallByName List.4 Json.88 Json.370;
|
||||
@ -134,15 +126,13 @@ procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.364 : List U8 = CallByName List.4 Json.365 Json.366;
|
||||
ret Json.364;
|
||||
|
||||
procedure List.133 (List.134, List.135, #Attr.12):
|
||||
let List.132 : {} = StructAtIndex 0 #Attr.12;
|
||||
procedure List.133 (List.134, List.135, List.132):
|
||||
let List.447 : {List U8, U64} = CallByName Json.119 List.134 List.135;
|
||||
let List.446 : [C [], C {List U8, U64}] = TagId(1) List.447;
|
||||
ret List.446;
|
||||
|
||||
procedure List.18 (List.130, List.131, List.132):
|
||||
let List.423 : {{}} = Struct {List.132};
|
||||
let List.417 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.423;
|
||||
let List.417 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.132;
|
||||
let List.420 : U8 = 1i64;
|
||||
let List.421 : U8 = GetTagId List.417;
|
||||
let List.422 : Int1 = lowlevel Eq List.420 List.421;
|
||||
@ -172,7 +162,7 @@ procedure List.6 (#Attr.2):
|
||||
ret List.424;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.445 : {Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
let List.445 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.445;
|
||||
|
||||
procedure List.69 (#Attr.2):
|
||||
@ -201,7 +191,7 @@ procedure List.86 (List.461, List.462, List.463, List.464, List.465):
|
||||
joinpoint List.433 List.364 List.365 List.366 List.367 List.368:
|
||||
let List.435 : Int1 = CallByName Num.22 List.367 List.368;
|
||||
if List.435 then
|
||||
let List.444 : {Str} = CallByName List.66 List.364 List.367;
|
||||
let List.444 : Str = CallByName List.66 List.364 List.367;
|
||||
let List.436 : [C [], C {List U8, U64}] = CallByName List.133 List.365 List.444 List.366;
|
||||
let List.441 : U8 = 1i64;
|
||||
let List.442 : U8 = GetTagId List.436;
|
||||
|
@ -1,12 +1,8 @@
|
||||
procedure #Derived.0 (#Derived.1):
|
||||
let #Derived_gen.1 : {{Str, Str}} = Struct {#Derived.1};
|
||||
let #Derived_gen.0 : {{Str, Str}} = CallByName Encode.22 #Derived_gen.1;
|
||||
let #Derived_gen.0 : {Str, Str} = CallByName Encode.22 #Derived.1;
|
||||
ret #Derived_gen.0;
|
||||
|
||||
procedure #Derived.4 (#Derived.5, #Derived.6, #Attr.12):
|
||||
let #Derived.1 : {Str, Str} = StructAtIndex 0 #Attr.12;
|
||||
inc #Derived.1;
|
||||
dec #Attr.12;
|
||||
procedure #Derived.4 (#Derived.5, #Derived.6, #Derived.1):
|
||||
joinpoint #Derived_gen.5 #Derived_gen.4:
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.5 #Derived_gen.4 #Derived.6;
|
||||
ret #Derived_gen.3;
|
||||
@ -17,10 +13,10 @@ procedure #Derived.4 (#Derived.5, #Derived.6, #Attr.12):
|
||||
inc #Derived.3;
|
||||
dec #Derived.1;
|
||||
let #Derived_gen.7 : Str = "A";
|
||||
let #Derived_gen.9 : {Str} = CallByName Json.18 #Derived.2;
|
||||
let #Derived_gen.10 : {Str} = CallByName Json.18 #Derived.3;
|
||||
let #Derived_gen.8 : List {Str} = Array [#Derived_gen.9, #Derived_gen.10];
|
||||
let #Derived_gen.6 : {Str, List {Str}} = CallByName Json.21 #Derived_gen.7 #Derived_gen.8;
|
||||
let #Derived_gen.9 : Str = CallByName Json.18 #Derived.2;
|
||||
let #Derived_gen.10 : Str = CallByName Json.18 #Derived.3;
|
||||
let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10];
|
||||
let #Derived_gen.6 : {Str, List Str} = CallByName Json.21 #Derived_gen.7 #Derived_gen.8;
|
||||
jump #Derived_gen.5 #Derived_gen.6;
|
||||
|
||||
procedure Encode.22 (Encode.93):
|
||||
@ -46,7 +42,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
|
||||
|
||||
procedure Encode.25 (Encode.100, Encode.101):
|
||||
let Encode.104 : List U8 = Array [];
|
||||
let Encode.105 : {{Str, Str}} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.105 : {Str, Str} = CallByName #Derived.0 Encode.100;
|
||||
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
|
||||
ret Encode.103;
|
||||
|
||||
@ -55,7 +51,7 @@ procedure Json.1 ():
|
||||
ret Json.318;
|
||||
|
||||
procedure Json.117 (Json.118, Json.321, #Attr.12):
|
||||
let Json.116 : List {Str} = StructAtIndex 1 #Attr.12;
|
||||
let Json.116 : List Str = StructAtIndex 1 #Attr.12;
|
||||
inc Json.116;
|
||||
let Json.115 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.115;
|
||||
@ -117,19 +113,15 @@ procedure Json.119 (Json.329, Json.125):
|
||||
jump Json.343 Json.126;
|
||||
|
||||
procedure Json.18 (Json.86):
|
||||
let Json.326 : {Str} = Struct {Json.86};
|
||||
let Json.325 : {Str} = CallByName Encode.22 Json.326;
|
||||
let Json.325 : Str = CallByName Encode.22 Json.86;
|
||||
ret Json.325;
|
||||
|
||||
procedure Json.21 (Json.115, Json.116):
|
||||
let Json.320 : {Str, List {Str}} = Struct {Json.115, Json.116};
|
||||
let Json.319 : {Str, List {Str}} = CallByName Encode.22 Json.320;
|
||||
let Json.320 : {Str, List Str} = Struct {Json.115, Json.116};
|
||||
let Json.319 : {Str, List Str} = CallByName Encode.22 Json.320;
|
||||
ret Json.319;
|
||||
|
||||
procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.86 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Json.86;
|
||||
dec #Attr.12;
|
||||
procedure Json.87 (Json.88, Json.324, Json.86):
|
||||
let Json.374 : I32 = 34i64;
|
||||
let Json.373 : U8 = CallByName Num.123 Json.374;
|
||||
let Json.371 : List U8 = CallByName List.4 Json.88 Json.373;
|
||||
@ -140,15 +132,13 @@ procedure Json.87 (Json.88, Json.324, #Attr.12):
|
||||
let Json.367 : List U8 = CallByName List.4 Json.368 Json.369;
|
||||
ret Json.367;
|
||||
|
||||
procedure List.133 (List.134, List.135, #Attr.12):
|
||||
let List.132 : {} = StructAtIndex 0 #Attr.12;
|
||||
procedure List.133 (List.134, List.135, List.132):
|
||||
let List.447 : {List U8, U64} = CallByName Json.119 List.134 List.135;
|
||||
let List.446 : [C [], C {List U8, U64}] = TagId(1) List.447;
|
||||
ret List.446;
|
||||
|
||||
procedure List.18 (List.130, List.131, List.132):
|
||||
let List.423 : {{}} = Struct {List.132};
|
||||
let List.417 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.423;
|
||||
let List.417 : [C [], C {List U8, U64}] = CallByName List.75 List.130 List.131 List.132;
|
||||
let List.420 : U8 = 1i64;
|
||||
let List.421 : U8 = GetTagId List.417;
|
||||
let List.422 : Int1 = lowlevel Eq List.420 List.421;
|
||||
@ -178,7 +168,7 @@ procedure List.6 (#Attr.2):
|
||||
ret List.424;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.445 : {Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
let List.445 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.445;
|
||||
|
||||
procedure List.69 (#Attr.2):
|
||||
@ -207,7 +197,7 @@ procedure List.86 (List.461, List.462, List.463, List.464, List.465):
|
||||
joinpoint List.433 List.364 List.365 List.366 List.367 List.368:
|
||||
let List.435 : Int1 = CallByName Num.22 List.367 List.368;
|
||||
if List.435 then
|
||||
let List.444 : {Str} = CallByName List.66 List.364 List.367;
|
||||
let List.444 : Str = CallByName List.66 List.364 List.367;
|
||||
let List.436 : [C [], C {List U8, U64}] = CallByName List.133 List.365 List.444 List.366;
|
||||
let List.441 : U8 = 1i64;
|
||||
let List.442 : U8 = GetTagId List.436;
|
||||
|
@ -2,10 +2,7 @@ procedure Test.11 (Test.37):
|
||||
let Test.38 : Str = "";
|
||||
ret Test.38;
|
||||
|
||||
procedure Test.13 (Test.51, #Attr.12):
|
||||
let Test.12 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Test.12;
|
||||
dec #Attr.12;
|
||||
procedure Test.13 (Test.51, Test.12):
|
||||
ret Test.12;
|
||||
|
||||
procedure Test.15 (Test.39):
|
||||
@ -29,8 +26,8 @@ procedure Test.3 (Test.17):
|
||||
ret Test.36;
|
||||
|
||||
procedure Test.4 (Test.18):
|
||||
let Test.50 : {Str} = Struct {Test.18};
|
||||
ret Test.50;
|
||||
inc Test.18;
|
||||
ret Test.18;
|
||||
|
||||
procedure Test.9 (Test.29, #Attr.12):
|
||||
let Test.8 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
|
||||
@ -48,7 +45,8 @@ procedure Test.9 (Test.29, #Attr.12):
|
||||
let Test.7 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Test.49 : {} = Struct {};
|
||||
let Test.48 : Str = CallByName Test.16 Test.49;
|
||||
let Test.45 : {Str} = CallByName Test.4 Test.48;
|
||||
let Test.45 : Str = CallByName Test.4 Test.48;
|
||||
dec Test.48;
|
||||
let Test.47 : {} = Struct {};
|
||||
let Test.46 : Str = CallByName Test.13 Test.47 Test.45;
|
||||
ret Test.46;
|
||||
|
@ -1,11 +1,9 @@
|
||||
procedure Test.1 (Test.4):
|
||||
let Test.5 : {Str} = Struct {Test.4};
|
||||
ret Test.5;
|
||||
|
||||
procedure Test.5 (Test.12, #Attr.12):
|
||||
let Test.4 : Str = StructAtIndex 0 #Attr.12;
|
||||
inc Test.4;
|
||||
dec #Attr.12;
|
||||
ret Test.4;
|
||||
|
||||
procedure Test.5 (Test.12, Test.4):
|
||||
dec Test.4;
|
||||
let Test.14 : Str = "";
|
||||
ret Test.14;
|
||||
|
||||
@ -18,9 +16,11 @@ procedure Test.0 ():
|
||||
let Test.20 : Int1 = lowlevel Eq Test.19 Test.2;
|
||||
if Test.20 then
|
||||
let Test.15 : Str = "";
|
||||
let Test.10 : {Str} = CallByName Test.1 Test.15;
|
||||
let Test.10 : Str = CallByName Test.1 Test.15;
|
||||
dec Test.15;
|
||||
jump Test.9 Test.10;
|
||||
else
|
||||
let Test.18 : Str = "";
|
||||
let Test.16 : {Str} = CallByName Test.1 Test.18;
|
||||
let Test.16 : Str = CallByName Test.1 Test.18;
|
||||
dec Test.18;
|
||||
jump Test.9 Test.16;
|
||||
|
@ -1,15 +1,13 @@
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.2 : I64 = 42i64;
|
||||
let Test.3 : {I64} = Struct {Test.2};
|
||||
ret Test.3;
|
||||
ret Test.2;
|
||||
|
||||
procedure Test.3 (Test.9, #Attr.12):
|
||||
let Test.2 : I64 = StructAtIndex 0 #Attr.12;
|
||||
procedure Test.3 (Test.9, Test.2):
|
||||
ret Test.2;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.8 : {} = Struct {};
|
||||
let Test.4 : {I64} = CallByName Test.1 Test.8;
|
||||
let Test.4 : I64 = CallByName Test.1 Test.8;
|
||||
let Test.7 : {} = Struct {};
|
||||
let Test.6 : I64 = CallByName Test.3 Test.7 Test.4;
|
||||
ret Test.6;
|
||||
|
@ -4,20 +4,17 @@ procedure Num.19 (#Attr.2, #Attr.3):
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.9 : U32 = 0i64;
|
||||
let Test.16 : {U32} = Struct {Test.2};
|
||||
let Test.8 : U32 = CallByName Test.3 Test.9 Test.16;
|
||||
let Test.8 : U32 = CallByName Test.3 Test.9 Test.2;
|
||||
ret Test.8;
|
||||
|
||||
procedure Test.3 (Test.18, Test.19):
|
||||
joinpoint Test.10 Test.4 #Attr.12:
|
||||
let Test.2 : U32 = StructAtIndex 0 #Attr.12;
|
||||
joinpoint Test.10 Test.4 Test.2:
|
||||
let Test.14 : Int1 = true;
|
||||
if Test.14 then
|
||||
ret Test.4;
|
||||
else
|
||||
let Test.12 : U32 = CallByName Num.19 Test.4 Test.2;
|
||||
let Test.13 : {U32} = Struct {Test.2};
|
||||
jump Test.10 Test.12 Test.13;
|
||||
jump Test.10 Test.12 Test.2;
|
||||
in
|
||||
jump Test.10 Test.18 Test.19;
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user