language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-03 03:42:17 +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

3
.gitignore vendored
View file

@ -119,3 +119,6 @@ crates/glue/tests/fixtures/*/build.rs
crates/glue/tests/fixtures/*/host.c
crates/glue/tests/fixtures/*/src/main.rs
crates/glue/tests/fixtures/*/test_glue/
# ignore the zig glue files copied into test platforms
**/*platform/glue/*

2
crates/cli/src/lib.rs
View file

@ -564,7 +564,7 @@ pub fn test(matches: &ArgMatches, target: Target) -> io::Result<i32> {
arena,
path.to_path_buf(),
opt_main_path.cloned(),
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
load_config,
);

12
crates/cli/src/main.rs
View file

@ -49,7 +49,7 @@ fn main() -> io::Result<()> {
BuildConfig::BuildAndRunIfNoErrors,
Triple::host().into(),
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
LinkType::Executable,
)
} else {
@ -64,7 +64,7 @@ fn main() -> io::Result<()> {
BuildConfig::BuildAndRun,
Triple::host().into(),
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
LinkType::Executable,
)
} else {
@ -90,7 +90,7 @@ fn main() -> io::Result<()> {
BuildConfig::BuildAndRunIfNoErrors,
Triple::host().into(),
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
LinkType::Executable,
)
} else {
@ -127,7 +127,7 @@ fn main() -> io::Result<()> {
let function_kind = FunctionKind::from_env();
roc_linker::generate_stub_lib(
input_path,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
target,
function_kind,
);
@ -199,7 +199,7 @@ fn main() -> io::Result<()> {
BuildConfig::BuildOnly,
target,
out_path,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
link_type,
)?)
}
@ -222,7 +222,7 @@ fn main() -> io::Result<()> {
roc_file_path.to_owned(),
opt_main_path.cloned(),
emit_timings,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
threading,
) {
Ok((problems, total_time)) => {

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;

2
crates/docs/src/lib.rs
View file

@ -483,7 +483,7 @@ pub fn load_module_for_docs(filename: PathBuf) -> LoadedModule {
&arena,
filename,
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
load_config,
) {
Ok(loaded) => loaded,

4
crates/glue/src/load.rs
View file

@ -88,7 +88,7 @@ pub fn generate(
linking_strategy,
true,
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
load_config,
Some(dylib_dir.path()),
),
@ -414,7 +414,7 @@ pub fn load_types(
arena,
full_file_path,
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
LoadConfig {
target,
function_kind,

2
crates/language_server/src/analysis.rs
View file

@ -114,7 +114,7 @@ pub(crate) fn global_analysis(doc_info: DocInfo) -> Vec<AnalyzedDocument> {
roc_target::Target::LinuxX64,
roc_load::FunctionKind::LambdaSet,
roc_reporting::report::RenderTarget::LanguageServer,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
roc_reporting::report::DEFAULT_PALETTE,
);

2
crates/language_server/src/convert.rs
View file

@ -160,7 +160,7 @@ pub(crate) mod diag {
LoadingProblem::CouldNotFindCacheDir => {
format!(
"Could not find Roc cache directory {}",
roc_packaging::cache::roc_cache_dir().display()
roc_packaging::cache::roc_cache_packages_dir().display()
)
}
LoadingProblem::UnrecognizedPackageShorthand { shorthand, .. } => {

23
crates/packaging/src/cache.rs
View file

@ -207,7 +207,7 @@ const ROC_CACHE_DIR_NAME: &str = "roc";
/// This looks up environment variables, so it should ideally be called once and then cached!
///
/// Returns a path of the form cache_dir_path.join(ROC_CACHE_DIR_NAME).join("packages")
/// Returns a path of the form cache_dir_path.join(ROC_CACHE_DIR_NAME)
/// where cache_dir_path is:
/// - The XDG_CACHE_HOME environment varaible, if it's set.
/// - Otherwise, ~/.cache on UNIX and %APPDATA% on Windows.
@ -222,14 +222,10 @@ const ROC_CACHE_DIR_NAME: &str = "roc";
pub fn roc_cache_dir() -> PathBuf {
use std::{env, process};
const PACKAGES_DIR_NAME: &str = "packages";
// Respect XDG, if the system appears to be using it.
// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
match env::var_os("XDG_CACHE_HOME") {
Some(xdg_cache_home) => Path::new(&xdg_cache_home)
.join(ROC_CACHE_DIR_NAME)
.join(PACKAGES_DIR_NAME),
Some(xdg_cache_home) => Path::new(&xdg_cache_home).join(ROC_CACHE_DIR_NAME),
None => {
#[cfg(windows)]
{
@ -239,9 +235,7 @@ pub fn roc_cache_dir() -> PathBuf {
// https://learn.microsoft.com/en-us/windows/deployment/usmt/usmt-recognized-environment-variables
env::var_os("APPDATA").or_else(|| env::var_os("CSIDL_APPDATA"))
{
Path::new(&appdata)
.join(ROC_CACHE_DIR_NAME)
.join(PACKAGES_DIR_NAME)
Path::new(&appdata).join(ROC_CACHE_DIR_NAME)
} else {
eprintln!("roc needs either the %APPDATA% or else the %XDG_CACHE_HOME% environment variables set. Please set one of these environment variables and re-run roc!");
process::exit(1);
@ -252,10 +246,7 @@ pub fn roc_cache_dir() -> PathBuf {
{
// e.g. $HOME/.cache/roc
if let Some(home) = env::var_os("HOME") {
Path::new(&home)
.join(".cache")
.join(ROC_CACHE_DIR_NAME)
.join(PACKAGES_DIR_NAME)
Path::new(&home).join(".cache").join(ROC_CACHE_DIR_NAME)
} else {
eprintln!("roc needs either the $HOME or else the $XDG_CACHE_HOME environment variables set. Please set one of these environment variables and re-run roc!");
process::exit(1);
@ -271,3 +262,9 @@ pub fn roc_cache_dir() -> PathBuf {
pub fn roc_cache_dir() -> PathBuf {
PathBuf::from(".cache").join(ROC_CACHE_DIR_NAME)
}
/// Returns a path of the form roc_cache_dir().join("packages")
pub fn roc_cache_packages_dir() -> PathBuf {
const PACKAGES_DIR_NAME: &str = "packages";
roc_cache_dir().join(PACKAGES_DIR_NAME)
}

2
crates/repl_cli/src/cli_gen.rs
View file

@ -66,7 +66,7 @@ pub fn eval_llvm(
))]
let (lib, main_fn_name, subs, layout_interner) =
mono_module_to_dylib_asm(&arena, target, loaded, opt_level)
.expect("we produce a valid Dylib");
.expect("We failed to produce a valid Dylib.\nTIP: if you're on macos, try this:\n\t<https://github.com/roc-lang/roc/issues/5797#issuecomment-1786105269>");
let mut app = CliApp { lib };

2
crates/repl_eval/src/gen.rs
View file

@ -61,7 +61,7 @@ pub fn compile_to_mono<'a, 'i, I: Iterator<Item = &'i str>>(
module_src,
src_dir,
None,
RocCacheDir::Persistent(cache::roc_cache_dir().as_path()),
RocCacheDir::Persistent(cache::roc_cache_packages_dir().as_path()),
LoadConfig {
target,
function_kind: FunctionKind::LambdaSet,

36
docker/README.md Normal file
View file

@ -0,0 +1,36 @@
# Official Docker Images
The latest [official Docker images](https://hub.docker.com/u/roclang) are available on the Docker Hub.
For example, to pull the latest `nightly-ubuntu-2204` image from the Docker Hub, run the following command in a terminal (assuming you have already installed [Docker](https://docs.docker.com/engine/install/)):
```bash
docker pull roclang/nightly-ubuntu-2204
```
To start an interactive container based on this image, run:
```bash
docker run -it --rm roclang/nightly-ubuntu-2204
```
Note: the `--rm` option will delete the container when you exit. Remove this option is you want to keep the container instead.
Inside the container, you can use the `roc` command directly, for example:
```bash
roc version
roc repl
```
Alternatively, you can start a container and run a Roc REPL in one shot:
```bash
docker run -it --rm roclang/nightly-ubuntu-2204 /usr/lib/roc/roc repl
```
If you want to create you own Docker image based on this image, add the following in your `Dockerfile`:
```Dockerfile
FROM roclang/nightly-ubuntu-2204:latest
```

2
www/content/install/index.md
View file

@ -1,6 +1,6 @@
# Install
Roc is a very young language with many incomplete features and known bugs. It doesn't even have a numbered release yet, but it does have [nightly builds](https://github.com/roc-lang/roc/releases) that you can download if you'd like to try it out without [building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md)!
Roc is a very young language with many incomplete features and known bugs. It doesn't even have a numbered release yet, but it does have [nightly builds](https://github.com/roc-lang/roc/releases) that you can download, if you'd like to try it out without [building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md)! There are also [official Docker images](https://hub.docker.com/u/roclang) if you prefer to run Roc within a container.
<div class="banner">
Roc is a <b>Work in Progress!</b> See the <a href="/plans">plans</a> page for more information.