Deriving string encoders works

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -0,0 +1,106 @@
+procedure #Derived.0 (#Derived.1):
+    let #Derived.6 : {Str} = Struct {#Derived.1};
+    let #Derived.5 : {Str} = CallByName Encode.22 #Derived.6;
+    ret #Derived.5;
+
+procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12):
+    let #Derived.1 : Str = StructAtIndex 0 #Attr.12;
+    inc #Derived.1;
+    dec #Attr.12;
+    let #Derived.9 : {Str} = CallByName Json.17 #Derived.1;
+    let #Derived.8 : List U8 = CallByName Encode.23 #Derived.3 #Derived.9 #Derived.4;
+    ret #Derived.8;
+
+procedure Encode.22 (Encode.93):
+    ret Encode.93;
+
+procedure Encode.22 (Encode.93):
+    ret Encode.93;
+
+procedure Encode.23 (Encode.94, Encode.102, Encode.96):
+    let Encode.107 : List U8 = CallByName #Derived.2 Encode.94 Encode.96 Encode.102;
+    ret Encode.107;
+
+procedure Encode.23 (Encode.94, Encode.102, Encode.96):
+    let Encode.114 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102;
+    ret Encode.114;
+
+procedure Encode.25 (Encode.100, Encode.101):
+    let Encode.104 : List U8 = Array [];
+    let Encode.105 : {Str} = CallByName #Derived.0 Encode.100;
+    let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
+    ret Encode.103;
+
+procedure Json.1 ():
+    let Json.102 : {} = Struct {};
+    ret Json.102;
+
+procedure Json.17 (Json.64):
+    let Json.104 : {Str} = Struct {Json.64};
+    let Json.103 : {Str} = CallByName Encode.22 Json.104;
+    ret Json.103;
+
+procedure Json.65 (Json.66, Json.105, #Attr.12):
+    let Json.64 : Str = StructAtIndex 0 #Attr.12;
+    inc Json.64;
+    dec #Attr.12;
+    let Json.114 : I32 = 34i64;
+    let Json.113 : U8 = CallByName Num.122 Json.114;
+    let Json.111 : List U8 = CallByName List.4 Json.66 Json.113;
+    let Json.112 : List U8 = CallByName Str.12 Json.64;
+    let Json.108 : List U8 = CallByName List.8 Json.111 Json.112;
+    let Json.110 : I32 = 34i64;
+    let Json.109 : U8 = CallByName Num.122 Json.110;
+    let Json.107 : List U8 = CallByName List.4 Json.108 Json.109;
+    ret Json.107;
+
+procedure List.4 (#Attr.2, #Attr.3):
+    let List.141 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
+    ret List.141;
+
+procedure List.8 (#Attr.2, #Attr.3):
+    let List.142 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.142;
+
+procedure Num.122 (#Attr.2):
+    let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.272;
+
+procedure Str.12 (#Attr.2):
+    let Str.73 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.73;
+
+procedure Str.9 (#Attr.2):
+    let #Attr.3 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    let Str.69 : Int1 = StructAtIndex 2 #Attr.3;
+    if Str.69 then
+        let Str.71 : Str = StructAtIndex 1 #Attr.3;
+        inc Str.71;
+        dec #Attr.3;
+        let Str.70 : [C {U64, U8}, C Str] = Ok Str.71;
+        ret Str.70;
+    else
+        let Str.67 : U8 = StructAtIndex 3 #Attr.3;
+        let Str.68 : U64 = StructAtIndex 0 #Attr.3;
+        dec #Attr.3;
+        let Str.66 : {U64, U8} = Struct {Str.68, Str.67};
+        let Str.65 : [C {U64, U8}, C Str] = Err Str.66;
+        ret Str.65;
+
+procedure Test.0 ():
+    let Test.9 : Str = "abc";
+    let Test.10 : {} = CallByName Json.1;
+    let Test.8 : List U8 = CallByName Encode.25 Test.9 Test.10;
+    let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
+    let Test.5 : U8 = 1i64;
+    let Test.6 : U8 = GetTagId Test.1;
+    let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;
+    if Test.7 then
+        let Test.2 : Str = UnionAtIndex (Id 1) (Index 0) Test.1;
+        inc Test.2;
+        dec Test.1;
+        ret Test.2;
+    else
+        dec Test.1;
+        let Test.4 : Str = "<bad>";
+        ret Test.4;

crates/compiler/test_mono/src/tests.rs

@@ -1467,6 +1467,24 @@ fn encode_custom_type() {
 }
 
 #[mono_test]
+fn encode_derived_string() {
+    indoc!(
+        r#"
+        app "test"
+            imports [Encode.{ toEncoder }, Json]
+            provides [main] to "./platform"
+
+        main =
+            result = Str.fromUtf8 (Encode.toBytes "abc" Json.format)
+            when result is
+                Ok s -> s
+                _ -> "<bad>"
+        "#
+    )
+}
+
+#[mono_test]
+#[ignore = "TODO"]
 fn encode_derived_record() {
     indoc!(
         r#"
@@ -1475,7 +1493,7 @@ fn encode_derived_record() {
             provides [main] to "./platform"
 
         main =
-            result = Str.fromUtf8 (Encode.toBytes {a: "fieldA", b: "fieldB"} Json.format)
+            result = Str.fromUtf8 (Encode.toBytes {a: "a"} Json.format)
             when result is
                 Ok s -> s
                 _ -> "<bad>"