language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-02 16:21:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Fix compile errors

Browse source
This commit is contained in:
Ayaz Hafiz 2022-07-14 09:02:37 -04:00
parent 02526b6dc2
commit 94ab904b6f
No known key found for this signature in database
GPG key ID: 0E2A37416A25EF58
9 changed files with 254 additions and 302 deletions
Download patch file Download diff file Expand all files Collapse all files

65
crates/compiler/can/src/copy.rs
View file

@ -1,6 +1,7 @@
use crate::{
def::Def,
expr::{AccessorData, ClosureData, Expr, Field, OpaqueWrapFunctionData, WhenBranch},
expr::{AccessorData, ClosureData, Expr, Field, OpaqueWrapFunctionData},
pattern::{DestructType, Pattern, RecordDestruct},
};
use roc_module::{
ident::{Lowercase, TagName},
@ -570,6 +571,29 @@ fn deep_copy_expr_help<C: CopyEnv>(env: &mut C, copied: &mut Vec<Variable>, expr
lambda_set_variables: lambda_set_variables.clone(),
},
OpaqueWrapFunction(OpaqueWrapFunctionData {
opaque_name,
opaque_var,
specialized_def_type,
type_arguments,
lambda_set_variables,
function_name,
function_var,
argument_var,
closure_var,
}) => OpaqueWrapFunction(OpaqueWrapFunctionData {
opaque_name: *opaque_name,
opaque_var: sub!(*opaque_var),
function_name: *function_name,
function_var: sub!(*function_var),
argument_var: sub!(*argument_var),
closure_var: sub!(*closure_var),
// The following three are only used for constraining
specialized_def_type: specialized_def_type.clone(),
type_arguments: type_arguments.clone(),
lambda_set_variables: lambda_set_variables.clone(),
}),
Expect {
loc_condition,
loc_continuation,
@ -639,44 +663,7 @@ fn deep_copy_pattern_help<C: CopyEnv>(
specialized_def_type: specialized_def_type.clone(),
type_arguments: type_arguments.clone(),
lambda_set_variables: lambda_set_variables.clone(),
},
OpaqueWrapFunction(OpaqueWrapFunctionData {
opaque_name,
opaque_var,
specialized_def_type,
type_arguments,
lambda_set_variables,
function_name,
function_var,
argument_var,
closure_var,
}) => OpaqueWrapFunction(OpaqueWrapFunctionData {
opaque_name: *opaque_name,
opaque_var: sub!(*opaque_var),
function_name: *function_name,
function_var: sub!(*function_var),
argument_var: sub!(*argument_var),
closure_var: sub!(*closure_var),
// The following three are only used for constraining
specialized_def_type: specialized_def_type.clone(),
type_arguments: type_arguments.clone(),
lambda_set_variables: lambda_set_variables.clone(),
}),
Expect {
loc_condition,
loc_continuation,
lookups_in_cond,
} => Expect {
loc_condition: Box::new(loc_condition.map(|e| go_help!(e))),
loc_continuation: Box::new(loc_continuation.map(|e| go_help!(e))),
lookups_in_cond: lookups_in_cond.to_vec(),
},
TypedHole(v) => TypedHole(sub!(*v)),
RuntimeError(err) => RuntimeError(err.clone()),
}
}
RecordDestructure {
whole_var,

28
crates/compiler/derive/src/lib.rs
View file

@ -19,10 +19,6 @@ mod encoding;
pub(crate) const DERIVED_SYNTH: ModuleId = ModuleId::DERIVED_SYNTH;
mod encoding;
pub(crate) const DERIVED_MODULE: ModuleId = ModuleId::DERIVED;
pub fn synth_var(subs: &mut Subs, content: Content) -> Variable {
let descriptor = Descriptor {
content,
@ -211,30 +207,6 @@ impl DerivedModule {
pub fn decompose(self) -> (Subs, IdentIds) {
(self.subs, self.derived_ident_ids)
}
pub fn copy_lambda_set_var_to_subs(&self, var: Variable, target: &mut Subs) -> Variable {
#[cfg(debug_assertions)]
{
debug_assert!(!self.stolen);
}
let copied_import = copy_import_to(
&self.subs,
target,
// bookkeep unspecialized lambda sets of var - I think we want this here
true,
var,
// TODO: I think this is okay because the only use of `copy_lambda_set_var_to_subs`
// (at least right now) is for lambda set compaction, which will automatically unify
// and lower ranks, and never generalize.
//
// However this is a bad coupling and maybe not a good assumption, we should revisit
// this when possible.
Rank::toplevel(),
);
copied_import.variable
}
}
/// Thread-sharable [`DerivedModule`].

1
crates/compiler/mono/src/ir.rs
View file

@ -2789,7 +2789,6 @@ fn specialize_external_help<'a>(
variable: Variable,
host_exposed_aliases: &[(Symbol, Variable)],
) {
dbg!(env.home);
let partial_proc_id = match procs.partial_procs.symbol_to_id(name.name()) {
Some(v) => v,
None => {

105
crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
View file

@ -244,56 +244,56 @@ procedure Json.79 (Json.107, Json.108):
else
jump Json.159 Json.87;
procedure List.121 (List.122, List.123, #Attr.12):
let List.120 : {} = StructAtIndex 0 #Attr.12;
let List.344 : {List U8, U64} = CallByName Json.79 List.122 List.123;
procedure List.122 (List.123, List.124, #Attr.12):
let List.121 : {} = StructAtIndex 0 #Attr.12;
let List.344 : {List U8, U64} = CallByName Json.79 List.123 List.124;
let List.343 : [C [], C {List U8, U64}] = TagId(1) List.344;
ret List.343;
procedure List.121 (List.122, List.123, #Attr.12):
let List.120 : {} = StructAtIndex 0 #Attr.12;
let List.418 : {List U8, U64} = CallByName Json.79 List.122 List.123;
procedure List.122 (List.123, List.124, #Attr.12):
let List.121 : {} = StructAtIndex 0 #Attr.12;
let List.418 : {List U8, U64} = CallByName Json.79 List.123 List.124;
let List.417 : [C [], C {List U8, U64}] = TagId(1) List.418;
ret List.417;
procedure List.18 (List.118, List.119, List.120):
let List.321 : {{}} = Struct {List.120};
let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.118 List.119 List.321;
procedure List.18 (List.119, List.120, List.121):
let List.321 : {{}} = Struct {List.121};
let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.321;
let List.318 : U8 = 1i64;
let List.319 : U8 = GetTagId List.315;
let List.320 : Int1 = lowlevel Eq List.318 List.319;
if List.320 then
let List.125 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315;
inc List.125;
let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315;
inc List.126;
dec List.315;
ret List.125;
ret List.126;
else
let List.126 : [] = UnionAtIndex (Id 0) (Index 0) List.315;
let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.315;
dec List.315;
let List.317 : {List U8, U64} = CallByName List.64 List.126;
let List.317 : {List U8, U64} = CallByName List.64 List.127;
ret List.317;
procedure List.18 (List.118, List.119, List.120):
let List.395 : {{}} = Struct {List.120};
let List.389 : [C [], C {List U8, U64}] = CallByName List.63 List.118 List.119 List.395;
procedure List.18 (List.119, List.120, List.121):
let List.395 : {{}} = Struct {List.121};
let List.389 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.395;
let List.392 : U8 = 1i64;
let List.393 : U8 = GetTagId List.389;
let List.394 : Int1 = lowlevel Eq List.392 List.393;
if List.394 then
let List.125 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.389;
inc List.125;
let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.389;
inc List.126;
dec List.389;
ret List.125;
ret List.126;
else
let List.126 : [] = UnionAtIndex (Id 0) (Index 0) List.389;
let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.389;
dec List.389;
let List.391 : {List U8, U64} = CallByName List.64 List.126;
let List.391 : {List U8, U64} = CallByName List.64 List.127;
ret List.391;
procedure List.4 (List.89, List.90):
procedure List.4 (List.90, List.91):
let List.450 : U64 = 1i64;
let List.449 : List U8 = CallByName List.65 List.89 List.450;
let List.448 : List U8 = CallByName List.66 List.449 List.90;
let List.449 : List U8 = CallByName List.65 List.90 List.450;
let List.448 : List U8 = CallByName List.66 List.449 List.91;
ret List.448;
procedure List.6 (#Attr.2):
@ -319,13 +319,13 @@ procedure List.60 (#Attr.2, #Attr.3):
procedure List.63 (List.283, List.284, List.285):
let List.328 : U64 = 0i64;
let List.329 : U64 = CallByName List.6 List.283;
let List.327 : [C [], C {List U8, U64}] = CallByName List.76 List.283 List.284 List.285 List.328 List.329;
let List.327 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.328 List.329;
ret List.327;
procedure List.63 (List.283, List.284, List.285):
let List.402 : U64 = 0i64;
let List.403 : U64 = CallByName List.6 List.283;
let List.401 : [C [], C {List U8, U64}] = CallByName List.76 List.283 List.284 List.285 List.402 List.403;
let List.401 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.402 List.403;
ret List.401;
procedure List.64 (#Attr.2):
@ -340,12 +340,12 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.452 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.452;
procedure List.76 (List.361, List.362, List.363, List.364, List.365):
procedure List.77 (List.361, List.362, List.363, List.364, List.365):
joinpoint List.330 List.286 List.287 List.288 List.289 List.290:
let List.332 : Int1 = CallByName Num.22 List.289 List.290;
if List.332 then
let List.341 : {Str, {Str}} = CallByName List.60 List.286 List.289;
let List.333 : [C [], C {List U8, U64}] = CallByName List.121 List.287 List.341 List.288;
let List.333 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.341 List.288;
let List.338 : U8 = 1i64;
let List.339 : U8 = GetTagId List.333;
let List.340 : Int1 = lowlevel Eq List.338 List.339;
@ -367,12 +367,12 @@ procedure List.76 (List.361, List.362, List.363, List.364, List.365):
in
jump List.330 List.361 List.362 List.363 List.364 List.365;
procedure List.76 (List.435, List.436, List.437, List.438, List.439):
procedure List.77 (List.435, List.436, List.437, List.438, List.439):
joinpoint List.404 List.286 List.287 List.288 List.289 List.290:
let List.406 : Int1 = CallByName Num.22 List.289 List.290;
if List.406 then
let List.415 : {Str, {Str}} = CallByName List.60 List.286 List.289;
let List.407 : [C [], C {List U8, U64}] = CallByName List.121 List.287 List.415 List.288;
let List.407 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.415 List.288;
let List.412 : U8 = 1i64;
let List.413 : U8 = GetTagId List.407;
let List.414 : Int1 = lowlevel Eq List.412 List.413;
@ -419,38 +419,37 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.212 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.212;
let Str.213 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.213;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.203 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.203;
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
procedure Str.9 (Str.68):
let Str.201 : U64 = 0i64;
let Str.202 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.48 Str.68 Str.201 Str.202;
let Str.198 : Int1 = StructAtIndex 2 Str.69;
if Str.198 then
let Str.200 : Str = StructAtIndex 1 Str.69;
inc Str.200;
dec Str.69;
let Str.199 : [C {U64, U8}, C Str] = TagId(1) Str.200;
ret Str.199;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
else
let Str.196 : U8 = StructAtIndex 3 Str.69;
let Str.197 : U64 = StructAtIndex 0 Str.69;
dec Str.69;
let Str.195 : {U64, U8} = Struct {Str.197, Str.196};
let Str.194 : [C {U64, U8}, C Str] = TagId(0) Str.195;
ret Str.194;
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
procedure Test.0 ():
let Test.12 : Str = "bar";
let Test.10 : {} = CallByName Json.1;
let Test.8 : List U8 = CallByName Encode.25 Test.12 Test.10;
let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
dec Test.8;
let Test.5 : U8 = 1i64;
let Test.6 : U8 = GetTagId Test.1;
let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;

77
crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
View file

@ -149,33 +149,33 @@ procedure Json.79 (Json.107, Json.108):
else
jump Json.119 Json.87;
procedure List.121 (List.122, List.123, #Attr.12):
let List.120 : {} = StructAtIndex 0 #Attr.12;
let List.344 : {List U8, U64} = CallByName Json.79 List.122 List.123;
procedure List.122 (List.123, List.124, #Attr.12):
let List.121 : {} = StructAtIndex 0 #Attr.12;
let List.344 : {List U8, U64} = CallByName Json.79 List.123 List.124;
let List.343 : [C [], C {List U8, U64}] = TagId(1) List.344;
ret List.343;
procedure List.18 (List.118, List.119, List.120):
let List.321 : {{}} = Struct {List.120};
let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.118 List.119 List.321;
procedure List.18 (List.119, List.120, List.121):
let List.321 : {{}} = Struct {List.121};
let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.321;
let List.318 : U8 = 1i64;
let List.319 : U8 = GetTagId List.315;
let List.320 : Int1 = lowlevel Eq List.318 List.319;
if List.320 then
let List.125 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315;
inc List.125;
let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315;
inc List.126;
dec List.315;
ret List.125;
ret List.126;
else
let List.126 : [] = UnionAtIndex (Id 0) (Index 0) List.315;
let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.315;
dec List.315;
let List.317 : {List U8, U64} = CallByName List.64 List.126;
let List.317 : {List U8, U64} = CallByName List.64 List.127;
ret List.317;
procedure List.4 (List.89, List.90):
procedure List.4 (List.90, List.91):
let List.376 : U64 = 1i64;
let List.375 : List U8 = CallByName List.65 List.89 List.376;
let List.374 : List U8 = CallByName List.66 List.375 List.90;
let List.375 : List U8 = CallByName List.65 List.90 List.376;
let List.374 : List U8 = CallByName List.66 List.375 List.91;
ret List.374;
procedure List.6 (#Attr.2):
@ -193,7 +193,7 @@ procedure List.60 (#Attr.2, #Attr.3):
procedure List.63 (List.283, List.284, List.285):
let List.328 : U64 = 0i64;
let List.329 : U64 = CallByName List.6 List.283;
let List.327 : [C [], C {List U8, U64}] = CallByName List.76 List.283 List.284 List.285 List.328 List.329;
let List.327 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.328 List.329;
ret List.327;
procedure List.64 (#Attr.2):
@ -208,12 +208,12 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.378 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.378;
procedure List.76 (List.361, List.362, List.363, List.364, List.365):
procedure List.77 (List.361, List.362, List.363, List.364, List.365):
joinpoint List.330 List.286 List.287 List.288 List.289 List.290:
let List.332 : Int1 = CallByName Num.22 List.289 List.290;
if List.332 then
let List.341 : {Str, {Str}} = CallByName List.60 List.286 List.289;
let List.333 : [C [], C {List U8, U64}] = CallByName List.121 List.287 List.341 List.288;
let List.333 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.341 List.288;
let List.338 : U8 = 1i64;
let List.339 : U8 = GetTagId List.333;
let List.340 : Int1 = lowlevel Eq List.338 List.339;
@ -260,38 +260,37 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.264;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.211;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.203 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.203;
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
procedure Str.9 (Str.68):
let Str.201 : U64 = 0i64;
let Str.202 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.48 Str.68 Str.201 Str.202;
let Str.198 : Int1 = StructAtIndex 2 Str.69;
if Str.198 then
let Str.200 : Str = StructAtIndex 1 Str.69;
inc Str.200;
dec Str.69;
let Str.199 : [C {U64, U8}, C Str] = TagId(1) Str.200;
ret Str.199;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
else
let Str.196 : U8 = StructAtIndex 3 Str.69;
let Str.197 : U64 = StructAtIndex 0 Str.69;
dec Str.69;
let Str.195 : {U64, U8} = Struct {Str.197, Str.196};
let Str.194 : [C {U64, U8}, C Str] = TagId(0) Str.195;
ret Str.194;
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
procedure Test.0 ():
let Test.11 : Str = "foo";
let Test.10 : {} = CallByName Json.1;
let Test.8 : List U8 = CallByName Encode.25 Test.11 Test.10;
let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
dec Test.8;
let Test.5 : U8 = 1i64;
let Test.6 : U8 = GetTagId Test.1;
let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;

77
crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
View file

@ -157,33 +157,33 @@ procedure Json.79 (Json.107, Json.108):
else
jump Json.119 Json.87;
procedure List.121 (List.122, List.123, #Attr.12):
let List.120 : {} = StructAtIndex 0 #Attr.12;
let List.344 : {List U8, U64} = CallByName Json.79 List.122 List.123;
procedure List.122 (List.123, List.124, #Attr.12):
let List.121 : {} = StructAtIndex 0 #Attr.12;
let List.344 : {List U8, U64} = CallByName Json.79 List.123 List.124;
let List.343 : [C [], C {List U8, U64}] = TagId(1) List.344;
ret List.343;
procedure List.18 (List.118, List.119, List.120):
let List.321 : {{}} = Struct {List.120};
let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.118 List.119 List.321;
procedure List.18 (List.119, List.120, List.121):
let List.321 : {{}} = Struct {List.121};
let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.321;
let List.318 : U8 = 1i64;
let List.319 : U8 = GetTagId List.315;
let List.320 : Int1 = lowlevel Eq List.318 List.319;
if List.320 then
let List.125 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315;
inc List.125;
let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315;
inc List.126;
dec List.315;
ret List.125;
ret List.126;
else
let List.126 : [] = UnionAtIndex (Id 0) (Index 0) List.315;
let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.315;
dec List.315;
let List.317 : {List U8, U64} = CallByName List.64 List.126;
let List.317 : {List U8, U64} = CallByName List.64 List.127;
ret List.317;
procedure List.4 (List.89, List.90):
procedure List.4 (List.90, List.91):
let List.376 : U64 = 1i64;
let List.375 : List U8 = CallByName List.65 List.89 List.376;
let List.374 : List U8 = CallByName List.66 List.375 List.90;
let List.375 : List U8 = CallByName List.65 List.90 List.376;
let List.374 : List U8 = CallByName List.66 List.375 List.91;
ret List.374;
procedure List.6 (#Attr.2):
@ -201,7 +201,7 @@ procedure List.60 (#Attr.2, #Attr.3):
procedure List.63 (List.283, List.284, List.285):
let List.328 : U64 = 0i64;
let List.329 : U64 = CallByName List.6 List.283;
let List.327 : [C [], C {List U8, U64}] = CallByName List.76 List.283 List.284 List.285 List.328 List.329;
let List.327 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.328 List.329;
ret List.327;
procedure List.64 (#Attr.2):
@ -216,12 +216,12 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.378 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.378;
procedure List.76 (List.361, List.362, List.363, List.364, List.365):
procedure List.77 (List.361, List.362, List.363, List.364, List.365):
joinpoint List.330 List.286 List.287 List.288 List.289 List.290:
let List.332 : Int1 = CallByName Num.22 List.289 List.290;
if List.332 then
let List.341 : {Str, {Str}} = CallByName List.60 List.286 List.289;
let List.333 : [C [], C {List U8, U64}] = CallByName List.121 List.287 List.341 List.288;
let List.333 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.341 List.288;
let List.338 : U8 = 1i64;
let List.339 : U8 = GetTagId List.333;
let List.340 : Int1 = lowlevel Eq List.338 List.339;
@ -268,31 +268,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.264;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.211;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.203 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.203;
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
procedure Str.9 (Str.68):
let Str.201 : U64 = 0i64;
let Str.202 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.48 Str.68 Str.201 Str.202;
let Str.198 : Int1 = StructAtIndex 2 Str.69;
if Str.198 then
let Str.200 : Str = StructAtIndex 1 Str.69;
inc Str.200;
dec Str.69;
let Str.199 : [C {U64, U8}, C Str] = TagId(1) Str.200;
ret Str.199;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
else
let Str.196 : U8 = StructAtIndex 3 Str.69;
let Str.197 : U64 = StructAtIndex 0 Str.69;
dec Str.69;
let Str.195 : {U64, U8} = Struct {Str.197, Str.196};
let Str.194 : [C {U64, U8}, C Str] = TagId(0) Str.195;
ret Str.194;
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
procedure Test.0 ():
let Test.11 : Str = "foo";
@ -301,7 +301,6 @@ procedure Test.0 ():
let Test.10 : {} = CallByName Json.1;
let Test.8 : List U8 = CallByName Encode.25 Test.9 Test.10;
let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
dec Test.8;
let Test.5 : U8 = 1i64;
let Test.6 : U8 = GetTagId Test.1;
let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;

49
crates/compiler/test_mono/generated/encode_derived_string.txt
View file

@ -54,10 +54,10 @@ procedure Json.65 (Json.66, Json.105, #Attr.12):
let Json.107 : List U8 = CallByName List.4 Json.108 Json.109;
ret Json.107;
procedure List.4 (List.89, List.90):
procedure List.4 (List.90, List.91):
let List.302 : U64 = 1i64;
let List.301 : List U8 = CallByName List.65 List.89 List.302;
let List.300 : List U8 = CallByName List.66 List.301 List.90;
let List.301 : List U8 = CallByName List.65 List.90 List.302;
let List.300 : List U8 = CallByName List.66 List.301 List.91;
ret List.300;
procedure List.6 (#Attr.2):
@ -81,38 +81,37 @@ procedure Num.123 (#Attr.2):
ret Num.258;
procedure Str.12 (#Attr.2):
let Str.208 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.208;
let Str.209 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.209;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.203 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.203;
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
procedure Str.9 (Str.68):
let Str.201 : U64 = 0i64;
let Str.202 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.48 Str.68 Str.201 Str.202;
let Str.198 : Int1 = StructAtIndex 2 Str.69;
if Str.198 then
let Str.200 : Str = StructAtIndex 1 Str.69;
inc Str.200;
dec Str.69;
let Str.199 : [C {U64, U8}, C Str] = TagId(1) Str.200;
ret Str.199;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
else
let Str.196 : U8 = StructAtIndex 3 Str.69;
let Str.197 : U64 = StructAtIndex 0 Str.69;
dec Str.69;
let Str.195 : {U64, U8} = Struct {Str.197, Str.196};
let Str.194 : [C {U64, U8}, C Str] = TagId(0) Str.195;
ret Str.194;
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
procedure Test.0 ():
let Test.9 : Str = "abc";
let Test.10 : {} = CallByName Json.1;
let Test.8 : List U8 = CallByName Encode.25 Test.9 Test.10;
let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
dec Test.8;
let Test.5 : U8 = 1i64;
let Test.6 : U8 = GetTagId Test.1;
let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;

77
crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
View file

@ -154,33 +154,33 @@ procedure Json.93 (Json.107, Json.99):
else
jump Json.121 Json.100;
procedure List.121 (List.122, List.123, #Attr.12):
let List.120 : {} = StructAtIndex 0 #Attr.12;
let List.350 : {List U8, U64} = CallByName Json.93 List.122 List.123;
procedure List.122 (List.123, List.124, #Attr.12):
let List.121 : {} = StructAtIndex 0 #Attr.12;
let List.350 : {List U8, U64} = CallByName Json.93 List.123 List.124;
let List.349 : [C [], C {List U8, U64}] = TagId(1) List.350;
ret List.349;
procedure List.18 (List.118, List.119, List.120):
let List.327 : {{}} = Struct {List.120};
let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.118 List.119 List.327;
procedure List.18 (List.119, List.120, List.121):
let List.327 : {{}} = Struct {List.121};
let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.327;
let List.324 : U8 = 1i64;
let List.325 : U8 = GetTagId List.321;
let List.326 : Int1 = lowlevel Eq List.324 List.325;
if List.326 then
let List.125 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321;
inc List.125;
let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321;
inc List.126;
dec List.321;
ret List.125;
ret List.126;
else
let List.126 : [] = UnionAtIndex (Id 0) (Index 0) List.321;
let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.321;
dec List.321;
let List.323 : {List U8, U64} = CallByName List.64 List.126;
let List.323 : {List U8, U64} = CallByName List.64 List.127;
ret List.323;
procedure List.4 (List.89, List.90):
procedure List.4 (List.90, List.91):
let List.382 : U64 = 1i64;
let List.381 : List U8 = CallByName List.65 List.89 List.382;
let List.380 : List U8 = CallByName List.66 List.381 List.90;
let List.381 : List U8 = CallByName List.65 List.90 List.382;
let List.380 : List U8 = CallByName List.66 List.381 List.91;
ret List.380;
procedure List.6 (#Attr.2):
@ -198,7 +198,7 @@ procedure List.60 (#Attr.2, #Attr.3):
procedure List.63 (List.283, List.284, List.285):
let List.334 : U64 = 0i64;
let List.335 : U64 = CallByName List.6 List.283;
let List.333 : [C [], C {List U8, U64}] = CallByName List.76 List.283 List.284 List.285 List.334 List.335;
let List.333 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.334 List.335;
ret List.333;
procedure List.64 (#Attr.2):
@ -213,12 +213,12 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.384 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.384;
procedure List.76 (List.367, List.368, List.369, List.370, List.371):
procedure List.77 (List.367, List.368, List.369, List.370, List.371):
joinpoint List.336 List.286 List.287 List.288 List.289 List.290:
let List.338 : Int1 = CallByName Num.22 List.289 List.290;
if List.338 then
let List.347 : {Str} = CallByName List.60 List.286 List.289;
let List.339 : [C [], C {List U8, U64}] = CallByName List.121 List.287 List.347 List.288;
let List.339 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.347 List.288;
let List.344 : U8 = 1i64;
let List.345 : U8 = GetTagId List.339;
let List.346 : Int1 = lowlevel Eq List.344 List.345;
@ -265,38 +265,37 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.266;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.211;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.203 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.203;
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
procedure Str.9 (Str.68):
let Str.201 : U64 = 0i64;
let Str.202 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.48 Str.68 Str.201 Str.202;
let Str.198 : Int1 = StructAtIndex 2 Str.69;
if Str.198 then
let Str.200 : Str = StructAtIndex 1 Str.69;
inc Str.200;
dec Str.69;
let Str.199 : [C {U64, U8}, C Str] = TagId(1) Str.200;
ret Str.199;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
else
let Str.196 : U8 = StructAtIndex 3 Str.69;
let Str.197 : U64 = StructAtIndex 0 Str.69;
dec Str.69;
let Str.195 : {U64, U8} = Struct {Str.197, Str.196};
let Str.194 : [C {U64, U8}, C Str] = TagId(0) Str.195;
ret Str.194;
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
procedure Test.0 ():
let Test.12 : Str = "foo";
let Test.11 : {} = CallByName Json.1;
let Test.10 : List U8 = CallByName Encode.25 Test.12 Test.11;
let Test.2 : [C {U64, U8}, C Str] = CallByName Str.9 Test.10;
dec Test.10;
let Test.7 : U8 = 1i64;
let Test.8 : U8 = GetTagId Test.2;
let Test.9 : Int1 = lowlevel Eq Test.7 Test.8;

77
crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
View file

@ -160,33 +160,33 @@ procedure Json.93 (Json.107, Json.99):
else
jump Json.121 Json.100;
procedure List.121 (List.122, List.123, #Attr.12):
let List.120 : {} = StructAtIndex 0 #Attr.12;
let List.350 : {List U8, U64} = CallByName Json.93 List.122 List.123;
procedure List.122 (List.123, List.124, #Attr.12):
let List.121 : {} = StructAtIndex 0 #Attr.12;
let List.350 : {List U8, U64} = CallByName Json.93 List.123 List.124;
let List.349 : [C [], C {List U8, U64}] = TagId(1) List.350;
ret List.349;
procedure List.18 (List.118, List.119, List.120):
let List.327 : {{}} = Struct {List.120};
let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.118 List.119 List.327;
procedure List.18 (List.119, List.120, List.121):
let List.327 : {{}} = Struct {List.121};
let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.327;
let List.324 : U8 = 1i64;
let List.325 : U8 = GetTagId List.321;
let List.326 : Int1 = lowlevel Eq List.324 List.325;
if List.326 then
let List.125 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321;
inc List.125;
let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321;
inc List.126;
dec List.321;
ret List.125;
ret List.126;
else
let List.126 : [] = UnionAtIndex (Id 0) (Index 0) List.321;
let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.321;
dec List.321;
let List.323 : {List U8, U64} = CallByName List.64 List.126;
let List.323 : {List U8, U64} = CallByName List.64 List.127;
ret List.323;
procedure List.4 (List.89, List.90):
procedure List.4 (List.90, List.91):
let List.382 : U64 = 1i64;
let List.381 : List U8 = CallByName List.65 List.89 List.382;
let List.380 : List U8 = CallByName List.66 List.381 List.90;
let List.381 : List U8 = CallByName List.65 List.90 List.382;
let List.380 : List U8 = CallByName List.66 List.381 List.91;
ret List.380;
procedure List.6 (#Attr.2):
@ -204,7 +204,7 @@ procedure List.60 (#Attr.2, #Attr.3):
procedure List.63 (List.283, List.284, List.285):
let List.334 : U64 = 0i64;
let List.335 : U64 = CallByName List.6 List.283;
let List.333 : [C [], C {List U8, U64}] = CallByName List.76 List.283 List.284 List.285 List.334 List.335;
let List.333 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.334 List.335;
ret List.333;
procedure List.64 (#Attr.2):
@ -219,12 +219,12 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.384 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.384;
procedure List.76 (List.367, List.368, List.369, List.370, List.371):
procedure List.77 (List.367, List.368, List.369, List.370, List.371):
joinpoint List.336 List.286 List.287 List.288 List.289 List.290:
let List.338 : Int1 = CallByName Num.22 List.289 List.290;
if List.338 then
let List.347 : {Str} = CallByName List.60 List.286 List.289;
let List.339 : [C [], C {List U8, U64}] = CallByName List.121 List.287 List.347 List.288;
let List.339 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.347 List.288;
let List.344 : U8 = 1i64;
let List.345 : U8 = GetTagId List.339;
let List.346 : Int1 = lowlevel Eq List.344 List.345;
@ -271,31 +271,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.266;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.211;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.203 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.203;
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
procedure Str.9 (Str.68):
let Str.201 : U64 = 0i64;
let Str.202 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.48 Str.68 Str.201 Str.202;
let Str.198 : Int1 = StructAtIndex 2 Str.69;
if Str.198 then
let Str.200 : Str = StructAtIndex 1 Str.69;
inc Str.200;
dec Str.69;
let Str.199 : [C {U64, U8}, C Str] = TagId(1) Str.200;
ret Str.199;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
else
let Str.196 : U8 = StructAtIndex 3 Str.69;
let Str.197 : U64 = StructAtIndex 0 Str.69;
dec Str.69;
let Str.195 : {U64, U8} = Struct {Str.197, Str.196};
let Str.194 : [C {U64, U8}, C Str] = TagId(0) Str.195;
ret Str.194;
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
procedure Test.0 ():
let Test.13 : Str = "foo";
@ -304,7 +304,6 @@ procedure Test.0 ():
let Test.11 : {} = CallByName Json.1;
let Test.10 : List U8 = CallByName Encode.25 Test.1 Test.11;
let Test.2 : [C {U64, U8}, C Str] = CallByName Str.9 Test.10;
dec Test.10;
let Test.7 : U8 = 1i64;
let Test.8 : U8 = GetTagId Test.2;
let Test.9 : Int1 = lowlevel Eq Test.7 Test.8;