language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-07-24 15:03:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge branch 'main' into link-to-operators-tutorial

Browse source
This commit is contained in:
Anton-4 2024-10-07 14:03:58 +02:00 • committed by GitHub
commit d35da49330
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
54 changed files with 492 additions and 530 deletions
Download patch file Download diff file Expand all files Collapse all files

36
crates/compiler/builtins/roc/Str.roc
View file

@ -367,6 +367,8 @@ module [
withCapacity,
withPrefix,
contains,
dropPrefix,
dropSuffix,
]
import Bool exposing [Bool]
@ -1052,3 +1054,37 @@ contains = \haystack, needle ->
when firstMatch haystack needle is
Some _index -> Bool.true
None -> Bool.false
## Drops the given prefix [Str] from the start of a [Str]
## If the prefix is not found, returns the original string.
##
## ```roc
## expect Str.dropPrefix "bar" "foo" == "bar"
## expect Str.dropPrefix "foobar" "foo" == "bar"
## ```
dropPrefix : Str, Str -> Str
dropPrefix = \haystack, prefix ->
if Str.startsWith haystack prefix then
start = Str.countUtf8Bytes prefix
len = Num.subWrap (Str.countUtf8Bytes haystack) start
substringUnsafe haystack start len
else
haystack
## Drops the given suffix [Str] from the end of a [Str]
## If the suffix is not found, returns the original string.
##
## ```roc
## expect Str.dropSuffix "bar" "foo" == "bar"
## expect Str.dropSuffix "barfoo" "foo" == "bar"
## ```
dropSuffix : Str, Str -> Str
dropSuffix = \haystack, suffix ->
if Str.endsWith haystack suffix then
start = 0
len = Num.subWrap (Str.countUtf8Bytes haystack) (Str.countUtf8Bytes suffix)
substringUnsafe haystack start len
else
haystack

16
crates/compiler/can/src/desugar.rs
View file

@ -248,8 +248,7 @@ pub fn desugar_value_def_suffixed<'a>(arena: &'a Bump, value_def: ValueDef<'a>)
body_pattern,
body_expr,
} => {
// note called_from_def is passed as `false` as this is a top_level_def
match unwrap_suffixed_expression(arena, body_expr, None) {
match unwrap_suffixed_expression(arena, body_expr, Some(ann_pattern)) {
Ok(new_expr) => AnnotatedBody {
ann_pattern,
ann_type,
@ -280,6 +279,19 @@ pub fn desugar_value_def_suffixed<'a>(arena: &'a Bump, value_def: ValueDef<'a>)
),
},
),
// When the last expression is suffixed, it will try to unwrap the def, but because we
// have an annotated def we can simply ignore the try and return it as is without
// creating an intermediate identifier
Err(EUnwrapped::UnwrappedDefExpr { loc_expr, .. }) => desugar_value_def_suffixed(
arena,
AnnotatedBody {
ann_pattern,
ann_type,
lines_between,
body_pattern,
body_expr: loc_expr,
},
),
Err(..) => AnnotatedBody {
ann_pattern,
ann_type,

9
crates/compiler/can/src/suffixed.rs
View file

@ -325,7 +325,14 @@ pub fn unwrap_suffixed_expression_apply_help<'a>(
let new_apply = arena.alloc(Loc::at(loc_expr.region, Expr::Apply(unwrapped_function, local_args, called_via)));
return init_unwrapped_err(arena, new_apply, maybe_def_pat, target);
match maybe_def_pat {
Some(..) => {
return Err(EUnwrapped::UnwrappedDefExpr { loc_expr: new_apply, target });
}
None => {
return init_unwrapped_err(arena, new_apply, maybe_def_pat, target);
}
}
}
// function is another expression

290
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__issue_7081.snap.new
View file

@ -1,290 +0,0 @@
---
source: crates/compiler/can/tests/test_suffixed.rs
assertion_line: 612
expression: snapshot
---
Defs {
tags: [
Index(2147483648),
Index(2147483649),
Index(2147483650),
],
regions: [
@0-80,
@82-227,
@229-266,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 2),
Slice(start = 2, length = 2),
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 2, length = 0),
Slice(start = 4, length = 1),
],
spaces: [
Newline,
Newline,
Newline,
Newline,
Newline,
],
type_defs: [],
value_defs: [
Body(
@0-3 Identifier {
ident: "inc",
},
@6-80 Closure(
[
@7-8 Identifier {
ident: "i",
},
],
@16-80 If {
if_thens: [
(
@19-24 Apply(
@21-22 Var {
module_name: "Num",
ident: "isGt",
},
[
@19-20 Var {
module_name: "",
ident: "i",
},
@23-24 Num(
"2",
),
],
BinOp(
GreaterThan,
),
),
@38-52 Apply(
@38-41 Tag(
"Err",
),
[
@42-52 Tag(
"MaxReached",
),
],
Space,
),
),
],
final_else: @70-80 Apply(
@70-72 Tag(
"Ok",
),
[
@74-79 ParensAround(
Apply(
@76-77 Var {
module_name: "Num",
ident: "add",
},
[
@74-75 Var {
module_name: "",
ident: "i",
},
@78-79 Num(
"1",
),
],
BinOp(
Plus,
),
),
),
],
Space,
),
indented_else: false,
},
),
),
Expect {
condition: @93-227 Defs(
Defs {
tags: [
Index(2147483648),
Index(2147483649),
],
regions: [
@99-189,
@203-208,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 1),
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 1, length = 0),
],
spaces: [
Newline,
],
type_defs: [],
value_defs: [
Body(
@93-96 Identifier {
ident: "run",
},
@99-189 Closure(
[
@100-101 Identifier {
ident: "i",
},
],
@132-172 Apply(
@132-172 Var {
module_name: "Result",
ident: "try",
},
[
@132-152 Apply(
@132-152 Var {
module_name: "",
ident: "inc",
},
[
@132-133 Var {
module_name: "",
ident: "i",
},
],
BinOp(
Pizza,
),
),
@132-172 Closure(
[
@132-152 Identifier {
ident: "#!0_arg",
},
],
@132-172 Apply(
@132-172 Var {
module_name: "Result",
ident: "try",
},
[
@132-172 Apply(
@132-172 Var {
module_name: "",
ident: "inc",
},
[
@132-152 Var {
module_name: "",
ident: "#!0_arg",
},
],
BinOp(
Pizza,
),
),
@132-172 Closure(
[
@113-117 Identifier {
ident: "newi",
},
],
@182-189 Apply(
@182-184 Tag(
"Ok",
),
[
@185-189 Var {
module_name: "",
ident: "newi",
},
],
Space,
),
),
],
QuestionSuffix,
),
),
],
QuestionSuffix,
),
),
),
Body(
@194-200 Identifier {
ident: "result",
},
@203-208 Apply(
@203-206 Var {
module_name: "",
ident: "run",
},
[
@207-208 Num(
"0",
),
],
Space,
),
),
],
},
@213-227 Apply(
@220-222 Var {
module_name: "Bool",
ident: "isEq",
},
[
@213-219 Var {
module_name: "",
ident: "result",
},
@223-227 Apply(
@223-225 Tag(
"Ok",
),
[
@226-227 Num(
"2",
),
],
Space,
),
],
BinOp(
Equals,
),
),
),
preceding_comment: @82-82,
},
Body(
@229-233 Identifier {
ident: "main",
},
@240-266 Apply(
@240-266 Var {
module_name: "Stdout",
ident: "line",
},
[
@253-266 Str(
PlainLine(
"Hello world",
),
),
],
Space,
),
),
],
}

75
crates/compiler/can/tests/snapshots/test_suffixed__suffixed_tests__issue_7103.snap Normal file
View file

@ -0,0 +1,75 @@
---
source: crates/compiler/can/tests/test_suffixed.rs
expression: snapshot
---
Defs {
tags: [
Index(2147483648),
Index(2147483649),
],
regions: [
@0-33,
@35-45,
],
space_before: [
Slice(start = 0, length = 0),
Slice(start = 0, length = 2),
],
space_after: [
Slice(start = 0, length = 0),
Slice(start = 2, length = 1),
],
spaces: [
Newline,
Newline,
Newline,
],
type_defs: [],
value_defs: [
AnnotatedBody {
ann_pattern: @0-3 Identifier {
ident: "run",
},
ann_type: @6-15 Apply(
"",
"Task",
[
@11-13 Record {
fields: [],
ext: None,
},
@14-15 Inferred,
],
),
lines_between: [
Newline,
],
body_pattern: @16-19 Identifier {
ident: "run",
},
body_expr: @22-33 Apply(
@22-33 Var {
module_name: "",
ident: "line",
},
[
@28-33 Str(
PlainLine(
"foo",
),
),
],
Space,
),
},
Body(
@35-39 Identifier {
ident: "main",
},
@42-45 Var {
module_name: "",
ident: "run",
},
),
],
}

12
crates/compiler/can/tests/test_suffixed.rs
View file

@ -632,6 +632,18 @@ mod suffixed_tests {
"##
);
}
#[test]
fn issue_7103() {
run_test!(
r##"
run : Task {} _
run = line! "foo"
main = run
"##
);
}
}
#[cfg(test)]

2
crates/compiler/load_internal/src/file.rs
View file

@ -784,7 +784,7 @@ impl<'a> State<'a> {
number_of_workers: usize,
exec_mode: ExecutionMode,
) -> Self {
let cache_dir = roc_packaging::cache::roc_cache_dir();
let cache_dir = roc_packaging::cache::roc_cache_packages_dir();
let dependencies = Dependencies::new(exec_mode.goal_phase());
Self {

2
crates/compiler/module/src/symbol.rs
View file

@ -1380,6 +1380,8 @@ define_builtins! {
46 STR_REPLACE_FIRST: "replaceFirst"
47 STR_REPLACE_LAST: "replaceLast"
48 STR_RELEASE_EXCESS_CAPACITY: "releaseExcessCapacity"
49 STR_DROP_PREFIX: "dropPrefix"
50 STR_DROP_SUFFIX: "dropSuffix"
}
6 LIST: "List" => {
0 LIST_LIST: "List" exposed_apply_type=true // the List.List type alias

72
crates/compiler/test_gen/src/gen_str.rs
View file

@ -1988,3 +1988,75 @@ fn str_contains_self() {
bool
);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn str_drop_prefix() {
assert_evals_to!(
r#"
Str.dropPrefix "" "foo"
"#,
RocStr::from(""),
RocStr
);
assert_evals_to!(
r#"
Str.dropPrefix "bar" "foo"
"#,
RocStr::from("bar"),
RocStr
);
assert_evals_to!(
r#"
Str.dropPrefix "foobar" "foo"
"#,
RocStr::from("bar"),
RocStr
);
assert_evals_to!(
r#"
Str.dropPrefix "fooBarThisIsDefinitelyAReallyLongAndNotaShortString" "foo"
"#,
RocStr::from("BarThisIsDefinitelyAReallyLongAndNotaShortString"),
RocStr
);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn str_drop_suffix() {
assert_evals_to!(
r#"
Str.dropSuffix "" "foo"
"#,
RocStr::from(""),
RocStr
);
assert_evals_to!(
r#"
Str.dropSuffix "bar" "foo"
"#,
RocStr::from("bar"),
RocStr
);
assert_evals_to!(
r#"
Str.dropSuffix "barfoo" "foo"
"#,
RocStr::from("bar"),
RocStr
);
assert_evals_to!(
r#"
Str.dropSuffix "BarThisIsDefinitelyAReallyLongAndNotaShortStringfoo" "foo"
"#,
RocStr::from("BarThisIsDefinitelyAReallyLongAndNotaShortString"),
RocStr
);
}

4
crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt generated
View file

@ -41,8 +41,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.238;
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
procedure Test.1 (Test.5):
ret Test.5;

4
crates/compiler/test_mono/generated/dbg_expr.txt generated
View file

@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2):
ret Num.282;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.5 : I64 = 1i64;

4
crates/compiler/test_mono/generated/dbg_in_expect.txt generated
View file

@ -44,8 +44,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.1 ():
let Test.4 : Str = "";

4
crates/compiler/test_mono/generated/dbg_inside_string.txt generated
View file

@ -40,8 +40,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.238;
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
procedure Test.0 ():
let Test.5 : Str = "Hello ";

4
crates/compiler/test_mono/generated/dbg_nested_expr.txt generated
View file

@ -39,8 +39,8 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.6 : I64 = 1i64;

4
crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt generated
View file

@ -40,8 +40,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Str = "";

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

@ -164,32 +164,32 @@ procedure Num.96 (#Attr.2):
ret Num.285;
procedure Str.12 (#Attr.2):
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.248;
let Str.258 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.258;
procedure Str.36 (#Attr.2):
let Str.249 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.249;
let Str.259 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.259;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.45;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.325 : Str = CallByName Encode.23 Test.56;

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

@ -105,32 +105,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.24;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.292 : Str = CallByName Encode.23 Test.56;

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

@ -112,32 +112,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.28;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.296 : Str = CallByName Encode.23 Test.56;

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

@ -38,32 +38,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.3;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.259 : Str = CallByName Encode.23 Test.56;

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

@ -110,32 +110,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.27;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.297 : Str = CallByName Encode.23 Test.56;

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

@ -113,32 +113,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.28;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.301 : Str = CallByName Encode.23 Test.56;

8
crates/compiler/test_mono/generated/inspect_derived_dict.txt generated
View file

@ -1184,12 +1184,12 @@ procedure Num.96 (#Attr.2):
ret Num.438;
procedure Str.12 (#Attr.2):
let Str.238 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.238;
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.248;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.239 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.239;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.8 : Str = "a";

4
crates/compiler/test_mono/generated/inspect_derived_list.txt generated
View file

@ -178,8 +178,8 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64, 2i64, 3i64];

4
crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt generated
View file

@ -292,8 +292,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.0 ():
let Test.4 : Str = "bar";

4
crates/compiler/test_mono/generated/inspect_derived_record.txt generated
View file

@ -209,8 +209,8 @@ procedure Num.96 (#Attr.2):
ret Num.282;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Decimal = 3dec;

4
crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt generated
View file

@ -179,8 +179,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Str = "foo";

4
crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt generated
View file

@ -186,8 +186,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Str = "foo";

4
crates/compiler/test_mono/generated/inspect_derived_string.txt generated
View file

@ -40,8 +40,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.2 : Str = "abc";

4
crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt generated
View file

@ -179,8 +179,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.4 : Str = "foo";

4
crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt generated
View file

@ -182,8 +182,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.5 : Str = "foo";

34
crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt generated
View file

@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.281;
procedure Str.27 (Str.82):
let Str.236 : [C Int1, C I64] = CallByName Str.64 Str.82;
ret Str.236;
procedure Str.27 (Str.84):
let Str.246 : [C Int1, C I64] = CallByName Str.66 Str.84;
ret Str.246;
procedure Str.42 (#Attr.2):
let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.244;
let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
procedure Str.64 (Str.189):
let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
let Str.242 : U8 = StructAtIndex 1 Str.190;
let Str.243 : U8 = 0i64;
let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
if Str.239 then
let Str.241 : I64 = StructAtIndex 0 Str.190;
let Str.240 : [C Int1, C I64] = TagId(1) Str.241;
ret Str.240;
procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C Int1, C I64] = TagId(1) Str.251;
ret Str.250;
else
let Str.238 : Int1 = false;
let Str.237 : [C Int1, C I64] = TagId(0) Str.238;
ret Str.237;
let Str.248 : Int1 = false;
let Str.247 : [C Int1, C I64] = TagId(0) Str.248;
ret Str.247;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

38
crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt generated
View file

@ -19,30 +19,30 @@ procedure Decode.26 (Decode.109, Decode.110):
ret Decode.126;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.27 (Str.82):
let Str.236 : [C {}, C I64] = CallByName Str.64 Str.82;
ret Str.236;
procedure Str.27 (Str.84):
let Str.246 : [C {}, C I64] = CallByName Str.66 Str.84;
ret Str.246;
procedure Str.42 (#Attr.2):
let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.244;
let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
procedure Str.64 (Str.189):
let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
let Str.242 : U8 = StructAtIndex 1 Str.190;
let Str.243 : U8 = 0i64;
let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
if Str.239 then
let Str.241 : I64 = StructAtIndex 0 Str.190;
let Str.240 : [C {}, C I64] = TagId(1) Str.241;
ret Str.240;
procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C {}, C I64] = TagId(1) Str.251;
ret Str.250;
else
let Str.238 : {} = Struct {};
let Str.237 : [C {}, C I64] = TagId(0) Str.238;
ret Str.237;
let Str.248 : {} = Struct {};
let Str.247 : [C {}, C I64] = TagId(0) Str.248;
ret Str.247;
procedure Test.103 ():
let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;

4
crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt generated
View file

@ -1,6 +1,6 @@
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.1 (Test.5):
let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;

8
crates/compiler/test_mono/generated/list_map_closure_borrows.txt generated
View file

@ -71,12 +71,12 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

4
crates/compiler/test_mono/generated/list_map_closure_owns.txt generated
View file

@ -70,8 +70,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

4
crates/compiler/test_mono/generated/pizza_dbg.txt generated
View file

@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2):
ret Num.282;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.4 : I64 = 1i64;

4
crates/compiler/test_mono/generated/polymorphic_expression_unification.txt generated
View file

@ -3,8 +3,8 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.23;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\"";

4
crates/compiler/test_mono/generated/recursively_build_effect.txt generated
View file

@ -3,8 +3,8 @@ procedure Num.20 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.238;
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
procedure Test.11 (Test.29, #Attr.12):
let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

8
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt generated
View file

@ -99,12 +99,12 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.237 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.237;
let Str.247 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.247;
procedure Str.36 (#Attr.2):
let Str.238 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.238;
let Str.248 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.248;
procedure Test.20 (Test.58):
let Test.295 : Str = CallByName Encode.23 Test.58;

8
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt generated
View file

@ -192,12 +192,12 @@ procedure Num.96 (#Attr.2):
ret Num.285;
procedure Str.12 (#Attr.2):
let Str.240 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.240;
let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.250;
procedure Str.36 (#Attr.2):
let Str.241 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.241;
let Str.251 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.251;
procedure Test.20 (Test.58):
inc Test.58;

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
View file

@ -46,8 +46,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.4 : {} = Struct {};

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
View file

@ -49,8 +49,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.2 (Test.3):
let Test.4 : Str = CallByName Inspect.33 Test.3;