nandi.uk / gleam
Fork of daniellemaywood.uk/gleam — Wasm codegen work
2
Fork 0

Configure Feed

Select the types of activity you want to include in your feed.

change how bit array size works because of binary representation

author
Giacomo Cavalieri committer
Louis Pilfold date (Jul 22, 2026, 8:34 AM +0100) commit 2231dfb7 parent f83d1798 change-id qwzrotzm
+1145 -44
+7 -7
compiler-core/src/erlang.rs
··· 2356 2356 builder.int(BigInt::ZERO); 2357 2357 } 2358 2358 Some(size) => self.inlined_constant(builder, size), 2359 - None => builder.atom("default"), 2359 + None => builder.bit_array_segment_default_size(), 2360 2360 } 2361 2361 self.bit_array_segment_specifiers(builder, segment); 2362 2362 } ··· 2450 2450 2451 2451 builder.bit_array_segment(); 2452 2452 self.inlined_constant(builder, segment); 2453 - builder.atom("default"); 2453 + builder.bit_array_segment_default_size(); 2454 2454 builder.bit_array_segment_specifiers([BitArraySegmentSpecifier::Utf8]); 2455 2455 } 2456 2456 builder.end_bit_array(bit_array); ··· 2481 2481 // `default` atom. 2482 2482 builder.bit_array_segment(); 2483 2483 self.maybe_block_expr(builder, value); 2484 - builder.atom("default"); 2484 + builder.bit_array_segment_default_size(); 2485 2485 builder.bit_array_segment_specifiers(if produces_literal_string(value) { 2486 2486 [BitArraySegmentSpecifier::Utf8] 2487 2487 } else { ··· 2752 2752 // to add the binary option and we can call it a day. 2753 2753 builder.bit_array_segment(); 2754 2754 self.maybe_block_expr(builder, &segment.value); 2755 - builder.atom("default"); 2755 + builder.bit_array_segment_default_size(); 2756 2756 builder.bit_array_segment_specifiers([BitArraySegmentSpecifier::Binary]); 2757 2757 return; 2758 2758 } ··· 2781 2781 } 2782 2782 builder.end_call(call); 2783 2783 2784 - builder.atom("default"); 2784 + builder.bit_array_segment_default_size(); 2785 2785 builder.bit_array_segment_specifiers([BitArraySegmentSpecifier::Binary]); 2786 2786 } else { 2787 2787 // If the bit array segment doesn't need any special handling we use the ··· 2804 2804 segment: &'a TypedExprBitArraySegment, 2805 2805 ) { 2806 2806 let Some(size) = segment.size() else { 2807 - builder.atom("default"); 2807 + builder.bit_array_segment_default_size(); 2808 2808 return; 2809 2809 }; 2810 2810 ··· 2953 2953 // `default` atom. 2954 2954 builder.bit_array_segment(); 2955 2955 self.clause_guard(builder, guard, assignments); 2956 - builder.atom("default"); 2956 + builder.bit_array_segment_default_size(); 2957 2957 builder.bit_array_segment_specifiers(if guard_produces_literal_string(guard) { 2958 2958 [BitArraySegmentSpecifier::Utf8] 2959 2959 } else {
+3 -3
compiler-core/src/erlang/pattern.rs
··· 217 217 // We first generate a segment matching on the literal prefix. 218 218 builder.bit_array_segment(); 219 219 builder.string_pattern(left_side_string); 220 - builder.atom("deafult"); 220 + builder.bit_array_segment_default_size(); 221 221 builder.bit_array_segment_specifiers([BitArraySegmentSpecifier::Utf8]); 222 222 223 223 // We then add a segment matching on the rest of the string. ··· 228 228 ), 229 229 AssignName::Discard(_) => builder.discard_pattern(), 230 230 } 231 - builder.atom("default"); 231 + builder.bit_array_segment_default_size(); 232 232 builder.bit_array_segment_specifiers([BitArraySegmentSpecifier::Binary]); 233 233 234 234 builder.end_bit_array_pattern(bit_array); ··· 383 383 segment: &'a TypedPatternBitArraySegment, 384 384 ) { 385 385 let Some(size) = segment.size() else { 386 - builder.atom("default"); 386 + builder.bit_array_segment_default_size(); 387 387 return; 388 388 }; 389 389 let TypedPattern::BitArraySize(size) = size else {
+31
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__aliased_string_prefix_pattern_referenced_in_guard.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 197 4 + expression: "\npub fn main(x) {\n case x {\n \"a\" as letter <> _ if letter == x -> letter\n _ -> \"wibble\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn main(x) { 9 + case x { 10 + "a" as letter <> _ if letter == x -> letter 11 + _ -> "wibble" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([main/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec main(binary()) -> binary(). 23 + main(X) -> 24 + case X of 25 + <<"a":(deafult)/utf8, _/binary>> when ~"a" =:= X -> 26 + Letter = ~"a", 27 + Letter; 28 + 29 + _ -> 30 + ~"wibble" 31 + end.
+35
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__alternative_patter_with_string_alias.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 182 4 + expression: "\npub fn main(x) {\n case x {\n \"a\" as letter <> _ | \"b\" as letter <> _ -> letter\n _ -> \"wibble\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn main(x) { 9 + case x { 10 + "a" as letter <> _ | "b" as letter <> _ -> letter 11 + _ -> "wibble" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([main/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec main(binary()) -> binary(). 23 + main(X) -> 24 + case X of 25 + <<"a":(deafult)/utf8, _/binary>> -> 26 + Letter = ~"a", 27 + Letter; 28 + 29 + <<"b":(deafult)/utf8, _/binary>> -> 30 + Letter = ~"b", 31 + Letter; 32 + 33 + _ -> 34 + ~"wibble" 35 + end.
+36
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__nested_string_prefix_pattern_assigns_variable.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 239 4 + expression: "\npub fn go(x) {\n case x {\n [\"a\" as letter <> rest, ..]\n | [\"b\" as letter <> rest, ..] -> letter <> rest\n _ -> \"\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + ["a" as letter <> rest, ..] 11 + | ["b" as letter <> rest, ..] -> letter <> rest 12 + _ -> "" 13 + } 14 + } 15 + 16 + 17 + ----- COMPILED ERLANG 18 + -module(my@mod). 19 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 20 + -export([go/1]). 21 + 22 + -file("project/test/my/mod.gleam", 2). 23 + -spec go(list(binary())) -> binary(). 24 + go(X) -> 25 + case X of 26 + [<<"a":(deafult)/utf8, Rest/binary>> | _] -> 27 + Letter = ~"a", 28 + <<Letter/binary, Rest/binary>>; 29 + 30 + [<<"b":(deafult)/utf8, Rest/binary>> | _] -> 31 + Letter = ~"b", 32 + <<Letter/binary, Rest/binary>>; 33 + 34 + _ -> 35 + ~"" 36 + end.
+36
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__string_prefix_pattern_assigns_variable.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 224 4 + expression: "\npub fn go(x) {\n case x {\n \"a\" as letter <> rest\n | \"b\" as letter <> rest -> letter <> rest\n _ -> \"\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "a" as letter <> rest 11 + | "b" as letter <> rest -> letter <> rest 12 + _ -> "" 13 + } 14 + } 15 + 16 + 17 + ----- COMPILED ERLANG 18 + -module(my@mod). 19 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 20 + -export([go/1]). 21 + 22 + -file("project/test/my/mod.gleam", 2). 23 + -spec go(binary()) -> binary(). 24 + go(X) -> 25 + case X of 26 + <<"a":(deafult)/utf8, Rest/binary>> -> 27 + Letter = ~"a", 28 + <<Letter/binary, Rest/binary>>; 29 + 30 + <<"b":(deafult)/utf8, Rest/binary>> -> 31 + Letter = ~"b", 32 + <<Letter/binary, Rest/binary>>; 33 + 34 + _ -> 35 + ~"" 36 + end.
+36
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__string_prefix_pattern_used_in_guard_assigns_variable.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 254 4 + expression: "\npub fn go(x) {\n case x {\n \"a\" as letter <> rest\n | \"b\" as letter <> rest if letter == \"c\" -> letter <> rest\n _ -> \"\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "a" as letter <> rest 11 + | "b" as letter <> rest if letter == "c" -> letter <> rest 12 + _ -> "" 13 + } 14 + } 15 + 16 + 17 + ----- COMPILED ERLANG 18 + -module(my@mod). 19 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 20 + -export([go/1]). 21 + 22 + -file("project/test/my/mod.gleam", 2). 23 + -spec go(binary()) -> binary(). 24 + go(X) -> 25 + case X of 26 + <<"a":(deafult)/utf8, Rest/binary>> when ~"a" =:= ~"c" -> 27 + Letter = ~"a", 28 + <<Letter/binary, Rest/binary>>; 29 + 30 + <<"b":(deafult)/utf8, Rest/binary>> when ~"b" =:= ~"c" -> 31 + Letter = ~"b", 32 + <<Letter/binary, Rest/binary>>; 33 + 34 + _ -> 35 + ~"" 36 + end.
+36
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__string_prefix_pattern_used_in_guard_assigns_variable_2.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 269 4 + expression: "\npub fn go(x) {\n case x {\n \"a\" as letter <> rest\n | \"b\" as rest <> letter if letter == \"c\" && rest == \"b\" -> letter <> rest\n _ -> \"\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "a" as letter <> rest 11 + | "b" as rest <> letter if letter == "c" && rest == "b" -> letter <> rest 12 + _ -> "" 13 + } 14 + } 15 + 16 + 17 + ----- COMPILED ERLANG 18 + -module(my@mod). 19 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 20 + -export([go/1]). 21 + 22 + -file("project/test/my/mod.gleam", 2). 23 + -spec go(binary()) -> binary(). 24 + go(X) -> 25 + case X of 26 + <<"a":(deafult)/utf8, Rest/binary>> when (~"a" =:= ~"c") andalso (Rest =:= ~"b") -> 27 + Letter = ~"a", 28 + <<Letter/binary, Rest/binary>>; 29 + 30 + <<"b":(deafult)/utf8, Letter/binary>> when (Letter =:= ~"c") andalso (~"b" =:= ~"b") -> 31 + Rest = ~"b", 32 + <<Letter/binary, Rest/binary>>; 33 + 34 + _ -> 35 + ~"" 36 + end.
+35
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__case__string_prefix_pattern_used_in_guard_assigns_variable_3.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/case.rs 3 + assertion_line: 284 4 + expression: "\npub fn go(x) {\n case x {\n \"a\" as rest <> _\n | \"b\" <> rest if rest == \"c\" -> Nil\n _ -> Nil\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "a" as rest <> _ 11 + | "b" <> rest if rest == "c" -> Nil 12 + _ -> Nil 13 + } 14 + } 15 + 16 + 17 + ----- COMPILED ERLANG 18 + -module(my@mod). 19 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 20 + -export([go/1]). 21 + 22 + -file("project/test/my/mod.gleam", 2). 23 + -spec go(binary()) -> nil. 24 + go(X) -> 25 + case X of 26 + <<"a":(deafult)/utf8, _/binary>> when ~"a" =:= ~"c" -> 27 + Rest = ~"a", 28 + nil; 29 + 30 + <<"b":(deafult)/utf8, Rest/binary>> when Rest =:= ~"c" -> 31 + nil; 32 + 33 + _ -> 34 + nil 35 + end.
+38
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__let_assert__string_prefix_pattern.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/let_assert.rs 3 + assertion_line: 198 4 + expression: "pub fn go() {\n let assert \"Hello \" <> name = \"Hello John\"\n name\n}" 5 + --- 6 + ----- SOURCE CODE 7 + pub fn go() { 8 + let assert "Hello " <> name = "Hello John" 9 + name 10 + } 11 + 12 + ----- COMPILED ERLANG 13 + -module(my@mod). 14 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 15 + -export([go/0]). 16 + 17 + -file("project/test/my/mod.gleam", 1). 18 + -spec go() -> binary(). 19 + go() -> 20 + case ~"Hello John" of 21 + <<"Hello ":(deafult)/utf8, Name/binary>> -> 22 + Name; 23 + 24 + _value -> 25 + erlang:error(#{ 26 + gleam_error => let_assert, 27 + message => ~"Pattern match failed, no pattern matched the value.", 28 + file => ~"project/test/my/mod.gleam", 29 + module => ~"my/mod", 30 + function => ~"go", 31 + line => 2, 32 + value => _value, 33 + start => 16, 34 + 'end' => 58, 35 + pattern_start => 27, 36 + pattern_end => 43 37 + }) 38 + end.
+39
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__let_assert__string_prefix_pattern_with_prefix_binding.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/let_assert.rs 3 + assertion_line: 208 4 + expression: "pub fn go() {\n let assert \"Hello \" as greeting <> name = \"Hello John\"\n #(greeting, name)\n}" 5 + --- 6 + ----- SOURCE CODE 7 + pub fn go() { 8 + let assert "Hello " as greeting <> name = "Hello John" 9 + #(greeting, name) 10 + } 11 + 12 + ----- COMPILED ERLANG 13 + -module(my@mod). 14 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 15 + -export([go/0]). 16 + 17 + -file("project/test/my/mod.gleam", 1). 18 + -spec go() -> {binary(), binary()}. 19 + go() -> 20 + case ~"Hello John" of 21 + <<"Hello ":(deafult)/utf8, Name/binary>> -> 22 + Greeting = ~"Hello ", 23 + {Greeting, Name}; 24 + 25 + _value -> 26 + erlang:error(#{ 27 + gleam_error => let_assert, 28 + message => ~"Pattern match failed, no pattern matched the value.", 29 + file => ~"project/test/my/mod.gleam", 30 + module => ~"my/mod", 31 + function => ~"go", 32 + line => 2, 33 + value => _value, 34 + start => 16, 35 + 'end' => 70, 36 + pattern_start => 27, 37 + pattern_end => 55 38 + }) 39 + end.
+39
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__patterns__string_prefix_as_pattern_with_assertion.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/patterns.rs 3 + assertion_line: 121 4 + expression: "pub fn a(x) {\n let assert \"a\" as a <> rest = \"wibble\"\n a\n}" 5 + --- 6 + ----- SOURCE CODE 7 + pub fn a(x) { 8 + let assert "a" as a <> rest = "wibble" 9 + a 10 + } 11 + 12 + ----- COMPILED ERLANG 13 + -module(my@mod). 14 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 15 + -export([a/1]). 16 + 17 + -file("project/test/my/mod.gleam", 1). 18 + -spec a(any()) -> binary(). 19 + a(X) -> 20 + case ~"wibble" of 21 + <<"a":(deafult)/utf8, Rest/binary>> -> 22 + A = ~"a", 23 + A; 24 + 25 + _value -> 26 + erlang:error(#{ 27 + gleam_error => let_assert, 28 + message => ~"Pattern match failed, no pattern matched the value.", 29 + file => ~"project/test/my/mod.gleam", 30 + module => ~"my/mod", 31 + function => ~"a", 32 + line => 2, 33 + value => _value, 34 + start => 16, 35 + 'end' => 54, 36 + pattern_start => 27, 37 + pattern_end => 43 38 + }) 39 + end.
+30
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__patterns__string_prefix_as_pattern_with_list.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/patterns.rs 3 + assertion_line: 109 4 + expression: "pub fn a(x) {\n case x {\n [\"a\" as a <> _, \"b\" as b <> _] -> a <> b\n _ -> \"\"\n }\n}" 5 + --- 6 + ----- SOURCE CODE 7 + pub fn a(x) { 8 + case x { 9 + ["a" as a <> _, "b" as b <> _] -> a <> b 10 + _ -> "" 11 + } 12 + } 13 + 14 + ----- COMPILED ERLANG 15 + -module(my@mod). 16 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 17 + -export([a/1]). 18 + 19 + -file("project/test/my/mod.gleam", 1). 20 + -spec a(list(binary())) -> binary(). 21 + a(X) -> 22 + case X of 23 + [<<"a":(deafult)/utf8, _/binary>>, <<"b":(deafult)/utf8, _/binary>>] -> 24 + A = ~"a", 25 + B = ~"b", 26 + <<A/binary, B/binary>>; 27 + 28 + _ -> 29 + ~"" 30 + end.
+29
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__patterns__string_prefix_as_pattern_with_multiple_subjects.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/patterns.rs 3 + assertion_line: 85 4 + expression: "pub fn a(x) {\n case x, x {\n _, \"a\" as a <> _ -> a\n _, _ -> \"a\"\n }\n}" 5 + --- 6 + ----- SOURCE CODE 7 + pub fn a(x) { 8 + case x, x { 9 + _, "a" as a <> _ -> a 10 + _, _ -> "a" 11 + } 12 + } 13 + 14 + ----- COMPILED ERLANG 15 + -module(my@mod). 16 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 17 + -export([a/1]). 18 + 19 + -file("project/test/my/mod.gleam", 1). 20 + -spec a(binary()) -> binary(). 21 + a(X) -> 22 + case {X, X} of 23 + {_, <<"a":(deafult)/utf8, _/binary>>} -> 24 + A = ~"a", 25 + A; 26 + 27 + {_, _} -> 28 + ~"a" 29 + end.
+29
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__patterns__string_prefix_as_pattern_with_multiple_subjects_and_guard.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/patterns.rs 3 + assertion_line: 97 4 + expression: "pub fn a(x) {\n case x, x {\n _, \"a\" as a <> rest if rest == \"a\" -> a\n _, _ -> \"a\"\n }\n}" 5 + --- 6 + ----- SOURCE CODE 7 + pub fn a(x) { 8 + case x, x { 9 + _, "a" as a <> rest if rest == "a" -> a 10 + _, _ -> "a" 11 + } 12 + } 13 + 14 + ----- COMPILED ERLANG 15 + -module(my@mod). 16 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 17 + -export([a/1]). 18 + 19 + -file("project/test/my/mod.gleam", 1). 20 + -spec a(binary()) -> binary(). 21 + a(X) -> 22 + case {X, X} of 23 + {_, <<"a":(deafult)/utf8, Rest/binary>>} when Rest =:= ~"a" -> 24 + A = ~"a", 25 + A; 26 + 27 + {_, _} -> 28 + ~"a" 29 + end.
+40
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__assert_string_prefix.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 424 4 + expression: "\npub fn main(x) {\n let assert \"m-\" <> rest = x\n rest\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn main(x) { 9 + let assert "m-" <> rest = x 10 + rest 11 + } 12 + 13 + 14 + ----- COMPILED ERLANG 15 + -module(my@mod). 16 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 17 + -export([main/1]). 18 + 19 + -file("project/test/my/mod.gleam", 2). 20 + -spec main(binary()) -> binary(). 21 + main(X) -> 22 + case X of 23 + <<"m-":(deafult)/utf8, Rest/binary>> -> 24 + Rest; 25 + 26 + _value -> 27 + erlang:error(#{ 28 + gleam_error => let_assert, 29 + message => ~"Pattern match failed, no pattern matched the value.", 30 + file => ~"project/test/my/mod.gleam", 31 + module => ~"my/mod", 32 + function => ~"main", 33 + line => 3, 34 + value => _value, 35 + start => 20, 36 + 'end' => 47, 37 + pattern_start => 31, 38 + pattern_end => 43 39 + }) 40 + end.
+39
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__assert_string_prefix_discar.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 436 4 + expression: "\npub fn main(x) {\n let assert \"m-\" <> _ = x\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn main(x) { 9 + let assert "m-" <> _ = x 10 + } 11 + 12 + 13 + ----- COMPILED ERLANG 14 + -module(my@mod). 15 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 16 + -export([main/1]). 17 + 18 + -file("project/test/my/mod.gleam", 2). 19 + -spec main(binary()) -> binary(). 20 + main(X) -> 21 + case X of 22 + <<"m-":(deafult)/utf8, _/binary>> = _value -> 23 + _value; 24 + 25 + _value@1 -> 26 + erlang:error(#{ 27 + gleam_error => let_assert, 28 + message => ~"Pattern match failed, no pattern matched the value.", 29 + file => ~"project/test/my/mod.gleam", 30 + module => ~"my/mod", 31 + function => ~"main", 32 + line => 3, 33 + value => _value@1, 34 + start => 20, 35 + 'end' => 44, 36 + pattern_start => 31, 37 + pattern_end => 40 38 + }) 39 + end.
+30
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__discard_concat_rest_pattern.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 338 4 + expression: "\npub fn go(x) {\n case x {\n \"Hello, \" <> _ -> Nil\n _ -> Nil\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "Hello, " <> _ -> Nil 11 + _ -> Nil 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([go/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec go(binary()) -> nil. 23 + go(X) -> 24 + case X of 25 + <<"Hello, ":(deafult)/utf8, _/binary>> -> 26 + nil; 27 + 28 + _ -> 29 + nil 30 + end.
+30
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__rest_variable_rewriting.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 323 4 + expression: "\npub fn go(x) {\n case x {\n \"Hello, \" <> x -> x\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "Hello, " <> x -> x 11 + _ -> "Unknown" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([go/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec go(binary()) -> binary(). 23 + go(X) -> 24 + case X of 25 + <<"Hello, ":(deafult)/utf8, X@1/binary>> -> 26 + X@1; 27 + 28 + _ -> 29 + ~"Unknown" 30 + end.
+30
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 142 4 + expression: "\npub fn go(x) {\n case x {\n \"Hello, \" <> name -> name\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "Hello, " <> name -> name 11 + _ -> "Unknown" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([go/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec go(binary()) -> binary(). 23 + go(X) -> 24 + case X of 25 + <<"Hello, ":(deafult)/utf8, Name/binary>> -> 26 + Name; 27 + 28 + _ -> 29 + ~"Unknown" 30 + end.
+31
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_assignment.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 156 4 + expression: "\npub fn go(x) {\n case x {\n \"Hello, \" as greeting <> name -> greeting\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "Hello, " as greeting <> name -> greeting 11 + _ -> "Unknown" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([go/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec go(binary()) -> binary(). 23 + go(X) -> 24 + case X of 25 + <<"Hello, ":(deafult)/utf8, Name/binary>> -> 26 + Greeting = ~"Hello, ", 27 + Greeting; 28 + 29 + _ -> 30 + ~"Unknown" 31 + end.
+76
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_assignment_not_unicode_escape_sequence.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 246 4 + expression: "\npub fn go(x) {\n let _ = case x {\n \"\\\\u{9}\" as start <> rest -> \"test\"\n \"\\\\u{000009}\" as start <> rest -> \"test\"\n \"\\\\u{21}\" as start <> rest -> \"test\"\n \"\\\\u{100}\" as start <> rest -> \"test\"\n \"\\\\u{1000}\" as start <> rest -> \"test\"\n \"\\\\u{1F600}\" as start <> rest -> \"test\"\n \"\\\\u{1f600}\" as start <> rest -> \"test\"\n \"\\\\u{01F600}\" as start <> rest -> \"test\"\n \"\\\\u{01f600}\" as start <> rest -> \"test\"\n \"\\\\u{9} \\\\u{000009} \\\\u{21} \\\\u{100} \\\\u{1000} \\\\u{1F600} \\\\u{01F600}\" as start <> rest -> \"test\"\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + let _ = case x { 10 + "\\u{9}" as start <> rest -> "test" 11 + "\\u{000009}" as start <> rest -> "test" 12 + "\\u{21}" as start <> rest -> "test" 13 + "\\u{100}" as start <> rest -> "test" 14 + "\\u{1000}" as start <> rest -> "test" 15 + "\\u{1F600}" as start <> rest -> "test" 16 + "\\u{1f600}" as start <> rest -> "test" 17 + "\\u{01F600}" as start <> rest -> "test" 18 + "\\u{01f600}" as start <> rest -> "test" 19 + "\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}" as start <> rest -> "test" 20 + _ -> "Unknown" 21 + } 22 + } 23 + 24 + 25 + ----- COMPILED ERLANG 26 + -module(my@mod). 27 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 28 + -export([go/1]). 29 + 30 + -file("project/test/my/mod.gleam", 2). 31 + -spec go(binary()) -> binary(). 32 + go(X) -> 33 + _ = case X of 34 + <<"\\u{9}":(deafult)/utf8, Rest/binary>> -> 35 + Start = ~"\\u{9}", 36 + ~"test"; 37 + 38 + <<"\\u{000009}":(deafult)/utf8, Rest@1/binary>> -> 39 + Start@1 = ~"\\u{000009}", 40 + ~"test"; 41 + 42 + <<"\\u{21}":(deafult)/utf8, Rest@2/binary>> -> 43 + Start@2 = ~"\\u{21}", 44 + ~"test"; 45 + 46 + <<"\\u{100}":(deafult)/utf8, Rest@3/binary>> -> 47 + Start@3 = ~"\\u{100}", 48 + ~"test"; 49 + 50 + <<"\\u{1000}":(deafult)/utf8, Rest@4/binary>> -> 51 + Start@4 = ~"\\u{1000}", 52 + ~"test"; 53 + 54 + <<"\\u{1F600}":(deafult)/utf8, Rest@5/binary>> -> 55 + Start@5 = ~"\\u{1F600}", 56 + ~"test"; 57 + 58 + <<"\\u{1f600}":(deafult)/utf8, Rest@6/binary>> -> 59 + Start@6 = ~"\\u{1f600}", 60 + ~"test"; 61 + 62 + <<"\\u{01F600}":(deafult)/utf8, Rest@7/binary>> -> 63 + Start@7 = ~"\\u{01F600}", 64 + ~"test"; 65 + 66 + <<"\\u{01f600}":(deafult)/utf8, Rest@8/binary>> -> 67 + Start@8 = ~"\\u{01f600}", 68 + ~"test"; 69 + 70 + <<"\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}":(deafult)/utf8, Rest@9/binary>> -> 71 + Start@9 = ~"\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}", 72 + ~"test"; 73 + 74 + _ -> 75 + ~"Unknown" 76 + end.
+111
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_assignment_with_escape_sequences.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 186 4 + expression: "\npub fn go(x) {\n let _ = case x {\n \"\\f\" as start <> rest -> \"test\"\n \"\\n\" as start <> rest -> \"test\"\n \"\\r\" as start <> rest -> \"test\"\n \"\\t\" as start <> rest -> \"test\"\n \"\\\"\" as start <> rest -> \"test\"\n \"\\\\\" as start <> rest -> \"test\"\n \"\\f \\n \\r \\t \\\" \\\\\" as start <> rest -> \"control chars with prefix assignment\"\n \"\\u{9}\" as start <> rest -> \"test\"\n \"\\u{000009}\" as start <> rest -> \"test\"\n \"\\u{21}\" as start <> rest -> \"test\"\n \"\\u{100}\" as start <> rest -> \"test\"\n \"\\u{1000}\" as start <> rest -> \"test\"\n \"\\u{1F600}\" as start <> rest -> \"test\"\n \"\\u{1f600}\" as start <> rest -> \"test\"\n \"\\u{01F600}\" as start <> rest -> \"test\"\n \"\\u{01f600}\" as start <> rest -> \"test\"\n \"\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}\" as start <> rest -> \"test\"\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + let _ = case x { 10 + "\f" as start <> rest -> "test" 11 + "\n" as start <> rest -> "test" 12 + "\r" as start <> rest -> "test" 13 + "\t" as start <> rest -> "test" 14 + "\"" as start <> rest -> "test" 15 + "\\" as start <> rest -> "test" 16 + "\f \n \r \t \" \\" as start <> rest -> "control chars with prefix assignment" 17 + "\u{9}" as start <> rest -> "test" 18 + "\u{000009}" as start <> rest -> "test" 19 + "\u{21}" as start <> rest -> "test" 20 + "\u{100}" as start <> rest -> "test" 21 + "\u{1000}" as start <> rest -> "test" 22 + "\u{1F600}" as start <> rest -> "test" 23 + "\u{1f600}" as start <> rest -> "test" 24 + "\u{01F600}" as start <> rest -> "test" 25 + "\u{01f600}" as start <> rest -> "test" 26 + "\u{9} \u{000009} \u{21} \u{100} \u{1000} \u{1F600} \u{01F600}" as start <> rest -> "test" 27 + _ -> "Unknown" 28 + } 29 + } 30 + 31 + 32 + ----- COMPILED ERLANG 33 + -module(my@mod). 34 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 35 + -export([go/1]). 36 + 37 + -file("project/test/my/mod.gleam", 2). 38 + -spec go(binary()) -> binary(). 39 + go(X) -> 40 + _ = case X of 41 + <<"\f":(deafult)/utf8, Rest/binary>> -> 42 + Start = ~"\f", 43 + ~"test"; 44 + 45 + <<"\n":(deafult)/utf8, Rest@1/binary>> -> 46 + Start@1 = ~"\n", 47 + ~"test"; 48 + 49 + <<"\r":(deafult)/utf8, Rest@2/binary>> -> 50 + Start@2 = ~"\r", 51 + ~"test"; 52 + 53 + <<"\t":(deafult)/utf8, Rest@3/binary>> -> 54 + Start@3 = ~"\t", 55 + ~"test"; 56 + 57 + <<"\"":(deafult)/utf8, Rest@4/binary>> -> 58 + Start@4 = ~"\"", 59 + ~"test"; 60 + 61 + <<"\\":(deafult)/utf8, Rest@5/binary>> -> 62 + Start@5 = ~"\\", 63 + ~"test"; 64 + 65 + <<"\f \n \r \t \" \\":(deafult)/utf8, Rest@6/binary>> -> 66 + Start@6 = ~"\f \n \r \t \" \\", 67 + ~"control chars with prefix assignment"; 68 + 69 + <<"\x{9}":(deafult)/utf8, Rest@7/binary>> -> 70 + Start@7 = ~"\x{9}", 71 + ~"test"; 72 + 73 + <<"\x{000009}":(deafult)/utf8, Rest@8/binary>> -> 74 + Start@8 = ~"\x{000009}", 75 + ~"test"; 76 + 77 + <<"\x{21}":(deafult)/utf8, Rest@9/binary>> -> 78 + Start@9 = ~"\x{21}", 79 + ~"test"; 80 + 81 + <<"\x{100}":(deafult)/utf8, Rest@10/binary>> -> 82 + Start@10 = ~"\x{100}", 83 + ~"test"; 84 + 85 + <<"\x{1000}":(deafult)/utf8, Rest@11/binary>> -> 86 + Start@11 = ~"\x{1000}", 87 + ~"test"; 88 + 89 + <<"\x{1F600}":(deafult)/utf8, Rest@12/binary>> -> 90 + Start@12 = ~"\x{1F600}", 91 + ~"test"; 92 + 93 + <<"\x{1f600}":(deafult)/utf8, Rest@13/binary>> -> 94 + Start@13 = ~"\x{1f600}", 95 + ~"test"; 96 + 97 + <<"\x{01F600}":(deafult)/utf8, Rest@14/binary>> -> 98 + Start@14 = ~"\x{01F600}", 99 + ~"test"; 100 + 101 + <<"\x{01f600}":(deafult)/utf8, Rest@15/binary>> -> 102 + Start@15 = ~"\x{01f600}", 103 + ~"test"; 104 + 105 + <<"\x{9} \x{000009} \x{21} \x{100} \x{1000} \x{1F600} \x{01F600}":(deafult)/utf8, Rest@16/binary>> -> 106 + Start@16 = ~"\x{9} \x{000009} \x{21} \x{100} \x{1000} \x{1F600} \x{01F600}", 107 + ~"test"; 108 + 109 + _ -> 110 + ~"Unknown" 111 + end.
+36
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_assignment_with_guard.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 170 4 + expression: "\npub fn go(x) {\n case x {\n \"Hello, \" as greeting <> name if name == \"Dude\" -> greeting <> \"Mate\"\n \"Hello, \" as greeting <> name -> greeting\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "Hello, " as greeting <> name if name == "Dude" -> greeting <> "Mate" 11 + "Hello, " as greeting <> name -> greeting 12 + _ -> "Unknown" 13 + } 14 + } 15 + 16 + 17 + ----- COMPILED ERLANG 18 + -module(my@mod). 19 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 20 + -export([go/1]). 21 + 22 + -file("project/test/my/mod.gleam", 2). 23 + -spec go(binary()) -> binary(). 24 + go(X) -> 25 + case X of 26 + <<"Hello, ":(deafult)/utf8, Name/binary>> when Name =:= ~"Dude" -> 27 + Greeting = ~"Hello, ", 28 + <<Greeting/binary, "Mate"/utf8>>; 29 + 30 + <<"Hello, ":(deafult)/utf8, Name@1/binary>> -> 31 + Greeting@1 = ~"Hello, ", 32 + Greeting@1; 33 + 34 + _ -> 35 + ~"Unknown" 36 + end.
+35
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_assignment_with_multiple_subjects.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 293 4 + expression: "\npub fn go(x) {\n case x {\n \"1\" as digit <> _ | \"2\" as digit <> _ -> digit\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "1" as digit <> _ | "2" as digit <> _ -> digit 11 + _ -> "Unknown" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([go/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec go(binary()) -> binary(). 23 + go(X) -> 24 + case X of 25 + <<"1":(deafult)/utf8, _/binary>> -> 26 + Digit = ~"1", 27 + Digit; 28 + 29 + <<"2":(deafult)/utf8, _/binary>> -> 30 + Digit = ~"2", 31 + Digit; 32 + 33 + _ -> 34 + ~"Unknown" 35 + end.
+66
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_not_unicode_escape_sequence.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 269 4 + expression: "\npub fn go(x) {\n let _ = case x {\n \"\\\\u{9}\" <> rest -> \"test\"\n \"\\\\u{000009}\" <> rest -> \"test\"\n \"\\\\u{21}\" <> rest -> \"test\"\n \"\\\\u{100}\" <> rest -> \"test\"\n \"\\\\u{1000}\" <> rest -> \"test\"\n \"\\\\u{1F600}\" <> rest -> \"test\"\n \"\\\\u{1f600}\" <> rest -> \"test\"\n \"\\\\u{01F600}\" <> rest -> \"test\"\n \"\\\\u{01f600}\" <> rest -> \"test\"\n \"\\\\u{9} \\\\u{000009} \\\\u{21} \\\\u{100} \\\\u{1000} \\\\u{1F600} \\\\u{01F600}\" <> rest -> \"test\"\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + let _ = case x { 10 + "\\u{9}" <> rest -> "test" 11 + "\\u{000009}" <> rest -> "test" 12 + "\\u{21}" <> rest -> "test" 13 + "\\u{100}" <> rest -> "test" 14 + "\\u{1000}" <> rest -> "test" 15 + "\\u{1F600}" <> rest -> "test" 16 + "\\u{1f600}" <> rest -> "test" 17 + "\\u{01F600}" <> rest -> "test" 18 + "\\u{01f600}" <> rest -> "test" 19 + "\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}" <> rest -> "test" 20 + _ -> "Unknown" 21 + } 22 + } 23 + 24 + 25 + ----- COMPILED ERLANG 26 + -module(my@mod). 27 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 28 + -export([go/1]). 29 + 30 + -file("project/test/my/mod.gleam", 2). 31 + -spec go(binary()) -> binary(). 32 + go(X) -> 33 + _ = case X of 34 + <<"\\u{9}":(deafult)/utf8, Rest/binary>> -> 35 + ~"test"; 36 + 37 + <<"\\u{000009}":(deafult)/utf8, Rest@1/binary>> -> 38 + ~"test"; 39 + 40 + <<"\\u{21}":(deafult)/utf8, Rest@2/binary>> -> 41 + ~"test"; 42 + 43 + <<"\\u{100}":(deafult)/utf8, Rest@3/binary>> -> 44 + ~"test"; 45 + 46 + <<"\\u{1000}":(deafult)/utf8, Rest@4/binary>> -> 47 + ~"test"; 48 + 49 + <<"\\u{1F600}":(deafult)/utf8, Rest@5/binary>> -> 50 + ~"test"; 51 + 52 + <<"\\u{1f600}":(deafult)/utf8, Rest@6/binary>> -> 53 + ~"test"; 54 + 55 + <<"\\u{01F600}":(deafult)/utf8, Rest@7/binary>> -> 56 + ~"test"; 57 + 58 + <<"\\u{01f600}":(deafult)/utf8, Rest@8/binary>> -> 59 + ~"test"; 60 + 61 + <<"\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}":(deafult)/utf8, Rest@9/binary>> -> 62 + ~"test"; 63 + 64 + _ -> 65 + ~"Unknown" 66 + end.
+31
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_shadowing.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 307 4 + expression: "\npub fn go(x) {\n case x {\n \"Hello, \" as x <> name -> x\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + case x { 10 + "Hello, " as x <> name -> x 11 + _ -> "Unknown" 12 + } 13 + } 14 + 15 + 16 + ----- COMPILED ERLANG 17 + -module(my@mod). 18 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 19 + -export([go/1]). 20 + 21 + -file("project/test/my/mod.gleam", 2). 22 + -spec go(binary()) -> binary(). 23 + go(X) -> 24 + case X of 25 + <<"Hello, ":(deafult)/utf8, Name/binary>> -> 26 + X@1 = ~"Hello, ", 27 + X@1; 28 + 29 + _ -> 30 + ~"Unknown" 31 + end.
+94
compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__strings__string_prefix_with_escape_sequences.snap.new
··· 1 + --- 2 + source: compiler-core/src/erlang/tests/strings.rs 3 + assertion_line: 216 4 + expression: "\npub fn go(x) {\n let _ = case x {\n \"\\f\" <> rest -> \"test\"\n \"\\n\" <> rest -> \"test\"\n \"\\r\" <> rest -> \"test\"\n \"\\t\" <> rest -> \"test\"\n \"\\\"\" <> rest -> \"test\"\n \"\\\\\" <> rest -> \"test\"\n \"\\f \\n \\r \\t \\\" \\\\\" <> rest -> \"control chars with prefix assignment\"\n \"\\u{9}\" <> rest -> \"test\"\n \"\\u{000009}\" <> rest -> \"test\"\n \"\\u{21}\" <> rest -> \"test\"\n \"\\u{100}\" <> rest -> \"test\"\n \"\\u{1000}\" <> rest -> \"test\"\n \"\\u{1F600}\" <> rest -> \"test\"\n \"\\u{1f600}\" <> rest -> \"test\"\n \"\\u{01F600}\" <> rest -> \"test\"\n \"\\u{01f600}\" <> rest -> \"test\"\n \"\\u{9} \\u{000009} \\u{21} \\u{100} \\u{1000} \\u{1F600} \\u{01F600}\" <> rest -> \"test\"\n _ -> \"Unknown\"\n }\n}\n" 5 + --- 6 + ----- SOURCE CODE 7 + 8 + pub fn go(x) { 9 + let _ = case x { 10 + "\f" <> rest -> "test" 11 + "\n" <> rest -> "test" 12 + "\r" <> rest -> "test" 13 + "\t" <> rest -> "test" 14 + "\"" <> rest -> "test" 15 + "\\" <> rest -> "test" 16 + "\f \n \r \t \" \\" <> rest -> "control chars with prefix assignment" 17 + "\u{9}" <> rest -> "test" 18 + "\u{000009}" <> rest -> "test" 19 + "\u{21}" <> rest -> "test" 20 + "\u{100}" <> rest -> "test" 21 + "\u{1000}" <> rest -> "test" 22 + "\u{1F600}" <> rest -> "test" 23 + "\u{1f600}" <> rest -> "test" 24 + "\u{01F600}" <> rest -> "test" 25 + "\u{01f600}" <> rest -> "test" 26 + "\u{9} \u{000009} \u{21} \u{100} \u{1000} \u{1F600} \u{01F600}" <> rest -> "test" 27 + _ -> "Unknown" 28 + } 29 + } 30 + 31 + 32 + ----- COMPILED ERLANG 33 + -module(my@mod). 34 + -compile([no_auto_import, nowarn_ignored, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). 35 + -export([go/1]). 36 + 37 + -file("project/test/my/mod.gleam", 2). 38 + -spec go(binary()) -> binary(). 39 + go(X) -> 40 + _ = case X of 41 + <<"\f":(deafult)/utf8, Rest/binary>> -> 42 + ~"test"; 43 + 44 + <<"\n":(deafult)/utf8, Rest@1/binary>> -> 45 + ~"test"; 46 + 47 + <<"\r":(deafult)/utf8, Rest@2/binary>> -> 48 + ~"test"; 49 + 50 + <<"\t":(deafult)/utf8, Rest@3/binary>> -> 51 + ~"test"; 52 + 53 + <<"\"":(deafult)/utf8, Rest@4/binary>> -> 54 + ~"test"; 55 + 56 + <<"\\":(deafult)/utf8, Rest@5/binary>> -> 57 + ~"test"; 58 + 59 + <<"\f \n \r \t \" \\":(deafult)/utf8, Rest@6/binary>> -> 60 + ~"control chars with prefix assignment"; 61 + 62 + <<"\x{9}":(deafult)/utf8, Rest@7/binary>> -> 63 + ~"test"; 64 + 65 + <<"\x{000009}":(deafult)/utf8, Rest@8/binary>> -> 66 + ~"test"; 67 + 68 + <<"\x{21}":(deafult)/utf8, Rest@9/binary>> -> 69 + ~"test"; 70 + 71 + <<"\x{100}":(deafult)/utf8, Rest@10/binary>> -> 72 + ~"test"; 73 + 74 + <<"\x{1000}":(deafult)/utf8, Rest@11/binary>> -> 75 + ~"test"; 76 + 77 + <<"\x{1F600}":(deafult)/utf8, Rest@12/binary>> -> 78 + ~"test"; 79 + 80 + <<"\x{1f600}":(deafult)/utf8, Rest@13/binary>> -> 81 + ~"test"; 82 + 83 + <<"\x{01F600}":(deafult)/utf8, Rest@14/binary>> -> 84 + ~"test"; 85 + 86 + <<"\x{01f600}":(deafult)/utf8, Rest@15/binary>> -> 87 + ~"test"; 88 + 89 + <<"\x{9} \x{000009} \x{21} \x{100} \x{1000} \x{1F600} \x{01F600}":(deafult)/utf8, Rest@16/binary>> -> 90 + ~"test"; 91 + 92 + _ -> 93 + ~"Unknown" 94 + end.
+37 -34
erlang-generation/src/lib.rs
··· 790 790 /// 791 791 /// builder.bit_array_segment(); 792 792 /// builder.int(1); 793 - /// builder.atom("default"); 794 - /// builder.atom("default"); 793 + /// builder.bit_array_segment_default_size(); 794 + /// builder.bit_array_segment_specifiers([]); 795 795 /// 796 796 /// builder.bit_array_segment(); 797 797 /// builder.string("hello"); 798 - /// builder.atom("deafult"); 799 - /// builder.atom("default"); 798 + /// builder.bit_array_segment_default_size(); 799 + /// builder.bit_array_segment_specifiers([]); 800 800 /// 801 801 /// builder.end_bit_array(bit_array); 802 802 /// ``` ··· 836 836 /// If you wanna check an example of how this is used you can have a read at 837 837 /// the ones in `start_bit_array`. 838 838 fn bit_array_segment(&mut self); 839 + 840 + /// You can call this when a bit array segment has no explicit size, and the 841 + /// default Erlang behaviour is fine. 842 + /// 843 + fn bit_array_segment_default_size(&mut self); 839 844 840 845 /// This generates a specifiers list for the currently open bit array 841 846 /// segment. ··· 1189 1194 /// 1190 1195 /// builder.bit_array_pattern_segment(); 1191 1196 /// builder.int_pattern(1); 1192 - /// builder.atom("default"); 1193 - /// builder.atom("default"); 1197 + /// builder.bit_array_segment_default_size(); 1198 + /// builder.bit_array_segment_specifiers([]); 1194 1199 /// 1195 1200 /// builder.bit_array_pattern_segment(); 1196 1201 /// builder.discard_pattern(); 1197 - /// builder.atom("deafult"); 1198 - /// builder.atom("default"); 1202 + /// builder.bit_array_segment_default_size(); 1203 + /// builder.bit_array_segment_specifiers([]); 1199 1204 /// 1200 1205 /// builder.end_bit_array_pattern(bit_array); 1201 1206 /// ``` ··· 2230 2235 }) 2231 2236 } 2232 2237 2238 + fn bit_array_segment_default_size(&mut self) { 2239 + if let Some(ErlangSourceBuilderPosition::BitArraySegment { 2240 + expected: expected @ BitArraySegmentExpectedItem::Size, 2241 + segment_value_needs_wrapping, 2242 + segment_size_needs_wrapping, 2243 + }) = self.position.last_mut() 2244 + { 2245 + // We are now expecting to see the specifiers list 2246 + *expected = BitArraySegmentExpectedItem::Specifiers; 2247 + if *segment_value_needs_wrapping { 2248 + self.code.push(')'); 2249 + *segment_value_needs_wrapping = false; 2250 + } 2251 + // We have the default atom as a size, that means we don't have to 2252 + // print anything at all! The size doesn't need any wrapping because 2253 + // there's no size at all. 2254 + *segment_size_needs_wrapping = false; 2255 + } else { 2256 + invalid_code_for_position!(self, "segment default size"); 2257 + } 2258 + } 2259 + 2233 2260 fn bit_array_segment_specifiers( 2234 2261 &mut self, 2235 2262 specifiers: impl IntoIterator<Item = BitArraySegmentSpecifier>, ··· 2516 2543 } 2517 2544 2518 2545 fn atom(&mut self, name: &str) { 2519 - // There's one special case where we actually don't want to push the 2520 - // atom's text at all. That's when we're generating the `default` atom 2521 - // as the size of a bit array segment. 2522 - // That's how we can tell in the Erlang Abstract Format that the size 2523 - // should be the default value, but it's not actually spelled out in 2524 - // textual Erlang code. 2525 - if let Some(ErlangSourceBuilderPosition::BitArraySegment { 2526 - expected: expected @ BitArraySegmentExpectedItem::Size, 2527 - segment_value_needs_wrapping, 2528 - segment_size_needs_wrapping, 2529 - }) = self.position.last_mut() 2530 - { 2531 - // We are new expecting to see the specifiers list 2532 - *expected = BitArraySegmentExpectedItem::Specifiers; 2533 - if *segment_value_needs_wrapping { 2534 - self.code.push(')'); 2535 - *segment_value_needs_wrapping = false; 2536 - } 2537 - // We have the default atom as a size, that means we don't have to 2538 - // print anything at all! The size doesn't need any wrapping because 2539 - // there's no size at all. 2540 - *segment_size_needs_wrapping = false; 2541 - } else { 2542 - self.new_expression(); 2543 - self.code.push_str(&quote_atom_name(name)); 2544 - } 2546 + self.new_expression(); 2547 + self.code.push_str(&quote_atom_name(name)); 2545 2548 } 2546 2549 } 2547 2550