test_gen: replace stdlib Json with inline implementation

Towards the goal of removing Json from stdlib, this change replaces
usage of TotallyNotJson in test_gen/gen_abilities with a simple usable
inline implementation of Encoder/DecoderFormatting.

Similarly, the use of TotallyNotJson in test_reporting is not necessary
at all and is replaced with a Decoder that wouldn't actually work, but
which does compile.

crates/compiler/load/tests/test_reporting.rs

@@ -11401,10 +11401,50 @@ In roc, functions are always written as a lambda, like{}
             r#"
             app "test" imports [] provides [main] to "./platform"
 
-            import TotallyNotJson
+            ErrDecoder := {} implements [DecoderFormatting {
+                u8: decodeU8,
+                u16: decodeU16,
+                u32: decodeU32,
+                u64: decodeU64,
+                u128: decodeU128,
+                i8: decodeI8,
+                i16: decodeI16,
+                i32: decodeI32,
+                i64: decodeI64,
+                i128: decodeI128,
+                f32: decodeF32,
+                f64: decodeF64,
+                dec: decodeDec,
+                bool: decodeBool,
+                string: decodeString,
+                list: decodeList,
+                record: decodeRecord,
+                tuple: decodeTuple,
+            }]
+            decodeU8 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeU16 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeU32 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeU64 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeU128 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeI8 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeI16 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeI32 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeI64 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeI128 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeF32 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeF64 = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeDec = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeBool = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeString = Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeList : Decoder elem (ErrDecoder) -> Decoder (List elem) (ErrDecoder)
+            decodeList = \_ -> Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeRecord : state, (state, Str -> [Keep (Decoder state (ErrDecoder)), Skip]), (state, (ErrDecoder) -> Result val DecodeError) -> Decoder val (ErrDecoder)
+            decodeRecord =\_, _, _ ->  Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
+            decodeTuple : state, (state, U64 -> [Next (Decoder state (ErrDecoder)), TooLong]), (state -> Result val DecodeError) -> Decoder val (ErrDecoder)
+            decodeTuple = \_, _, _ -> Decode.custom \rest, @ErrDecoder {} -> {result: Err TooShort, rest}
 
             main =
-                decoded = Str.toUtf8 "{\"first\":\"ab\",\"second\":\"cd\"}" |> Decode.fromBytes TotallyNotJson.json
+                decoded = Str.toUtf8 "{\"first\":\"ab\",\"second\":\"cd\"}" |> Decode.fromBytes (@ErrDecoder {})
                 when decoded is
                     Ok rcd -> rcd.first rcd.second
                     _ -> "something went wrong"
@@ -11415,8 +11455,8 @@ In roc, functions are always written as a lambda, like{}
 
     This expression has a type that does not implement the abilities it's expected to:
 
-    8│          Ok rcd -> rcd.first rcd.second
-                          ^^^^^^^^^
+    48│          Ok rcd -> rcd.first rcd.second
+                           ^^^^^^^^^
 
     I can't generate an implementation of the `Decoding` ability for
 

crates/compiler/test_gen/Cargo.toml

@@ -45,6 +45,7 @@ roc_reporting = { path = "../../reporting" }
 roc_solve = { path = "../solve" }
 roc_std = { path = "../../roc_std" }
 roc_target = { path = "../roc_target" }
+roc_test_utils = { path = "../../test_utils"}
 roc_types = { path = "../types" }
 roc_unify = { path = "../unify" }
 roc_wasm_interp = { path = "../../wasm_interp" }

crates/compiler/uitest/tests/solve/stdlib_encode_json.txt

@@ -1,18 +0,0 @@
-app "test"
-    imports [TotallyNotJson]
-    provides [main] to "./platform"
-
-HelloWorld := {} implements [Encoding {toEncoder}]
-
-toEncoder = \@HelloWorld {} ->
-    Encode.custom \bytes, fmt ->
-        bytes
-        |> Encode.appendWith (Encode.string "Hello, World!\n") fmt
-
-f =
-    when Str.fromUtf8 (Encode.toBytes (@HelloWorld {}) TotallyNotJson.json) is
-        Ok s -> s
-        _ -> "<bad>"
-
-main = f
-#      ^ Str

crates/compiler/uitest/tests/solve/stdlib_encode_something.txt

@@ -0,0 +1,66 @@
+app "test"
+    imports []
+    provides [main] to "./platform"
+
+OnlyStrEncoder := {} implements [Encode.EncoderFormatting {
+            u8: encodeU8,
+            u16: encodeU16,
+            u32: encodeU32,
+            u64: encodeU64,
+            u128: encodeU128,
+            i8: encodeI8,
+            i16: encodeI16,
+            i32: encodeI32,
+            i64: encodeI64,
+            i128: encodeI128,
+            f32: encodeF32,
+            f64: encodeF64,
+            dec: encodeDec,
+            bool: encodeBool,
+            string: encodeString,
+            list: encodeList,
+            record: encodeRecord,
+            tuple: encodeTuple,
+            tag: encodeTag,
+}]
+
+encodeNothing = Encode.custom \bytes, @OnlyStrEncoder {} -> bytes
+encodeU8 = \_n -> encodeNothing
+encodeU16 = \_n -> encodeNothing
+encodeU32 = \_n -> encodeNothing
+encodeU64 = \_n -> encodeNothing
+encodeU128 = \_n -> encodeNothing
+encodeI8 = \_n -> encodeNothing
+encodeI16 = \_n -> encodeNothing
+encodeI32 = \_n -> encodeNothing
+encodeI64 = \_n -> encodeNothing
+encodeI128 = \_n -> encodeNothing
+encodeF32 = \_n -> encodeNothing
+encodeF64 = \_n -> encodeNothing
+encodeDec = \_n -> encodeNothing
+encodeBool = \_b -> encodeNothing
+encodeString = \str -> Encode.custom \bytes, @OnlyStrEncoder {} -> List.concat bytes (Str.toUtf8 str)
+encodeList : List elem, (elem -> Encoder OnlyStrEncoder) -> Encoder OnlyStrEncoder
+encodeList = \_lst, _encodeElem -> encodeNothing
+encodeRecord : List {key: Str, value: Encoder OnlyStrEncoder} -> Encoder OnlyStrEncoder
+encodeRecord = \_fields -> encodeNothing
+encodeTuple : List (Encoder OnlyStrEncoder) -> Encoder OnlyStrEncoder
+encodeTuple = \_elems -> encodeNothing
+encodeTag : Str, List (Encoder OnlyStrEncoder) -> Encoder OnlyStrEncoder
+encodeTag = \_name, _payload -> encodeNothing
+
+
+HelloWorld := {} implements [Encoding {toEncoder}]
+
+toEncoder = \@HelloWorld {} ->
+    Encode.custom \bytes, fmt ->
+        bytes
+        |> Encode.appendWith (Encode.string "Hello, World!\n") fmt
+
+f =
+    when Str.fromUtf8 (Encode.toBytes (@HelloWorld {}) (@OnlyStrEncoder {})) is
+        Ok s -> s
+        _ -> "<bad>"
+
+main = f
+#      ^ Str