Add Decode

src/build/builtin_compiler/main.zig

@@ -1824,16 +1824,16 @@ fn findTypeDeclaration(env: *const ModuleEnv, type_name: []const u8) !CIR.Statem
     const all_stmts = env.store.sliceStatements(env.all_statements);
     for (all_stmts) |stmt_idx| {
         const stmt = env.store.getStatement(stmt_idx);
-        switch (stmt) {
-            .s_nominal_decl => |decl| {
-                const header = env.store.getTypeHeader(decl.header);
-                const ident_idx = header.name;
-                const ident_text = env.getIdentText(ident_idx);
-                if (std.mem.eql(u8, ident_text, qualified_name)) {
-                    return stmt_idx;
-                }
-            },
+        const header_idx = switch (stmt) {
+            .s_nominal_decl => |decl| decl.header,
+            .s_alias_decl => |alias| alias.header,
             else => continue,
+        };
+        const header = env.store.getTypeHeader(header_idx);
+        const ident_idx = header.name;
+        const ident_text = env.getIdentText(ident_idx);
+        if (std.mem.eql(u8, ident_text, qualified_name)) {
+            return stmt_idx;
         }
     }
 

src/build/roc/Builtin.roc

@@ -46,6 +46,13 @@ Builtin :: [].{
 		encode = |self, format| {
 			format.encode_str(self)
 		}
+
+		decode : src, fmt -> (Try(Str, err), src)
+			where [fmt.decode_str : fmt, src -> (Try(Str, err), src)]
+		decode = |source, format| {
+			Fmt : fmt
+			Fmt.decode_str(format, source)
+		}
 	}
 
 	List(_item) :: [ProvidedByCompiler].{
@@ -269,6 +276,18 @@ Builtin :: [].{
 			format.encode_list(self, |elem, f| elem.encode(f))
 		}
 
+		# Decode a list using a format that provides decode_list
+		decode : src, fmt -> (Try(List(item), err), src)
+			where [
+				fmt.decode_list : fmt, src, (src, fmt -> (Try(item, err), src)) -> (Try(List(item), err), src),
+				item.decode : src, fmt -> (Try(item, err), src),
+			]
+		decode = |source, format| {
+			Fmt : fmt
+			Item : item
+			Fmt.decode_list(format, source, |s, f| Item.decode(s, f))
+		}
+
 	}
 
 	Bool := [False, True].{
@@ -286,6 +305,13 @@ Builtin :: [].{
 		encode = |self, format| {
 			format.encode_bool(self)
 		}
+
+		decode : src, fmt -> (Try(Bool, err), src)
+			where [fmt.decode_bool : fmt, src -> (Try(Bool, err), src)]
+		decode = |source, format| {
+			Fmt : fmt
+			Fmt.decode_bool(format, source)
+		}
 	}
 
 	Box(item) :: [ProvidedByCompiler].{
@@ -465,6 +491,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_u8(self)
 			}
+
+			decode : src, fmt -> (Try(U8, err), src)
+				where [fmt.decode_u8 : fmt, src -> (Try(U8, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_u8(format, source)
+			}
 		}
 
 		I8 :: [].{
@@ -541,6 +574,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_i8(self)
 			}
+
+			decode : src, fmt -> (Try(I8, err), src)
+				where [fmt.decode_i8 : fmt, src -> (Try(I8, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_i8(format, source)
+			}
 		}
 
 		U16 :: [].{
@@ -611,6 +651,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_u16(self)
 			}
+
+			decode : src, fmt -> (Try(U16, err), src)
+				where [fmt.decode_u16 : fmt, src -> (Try(U16, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_u16(format, source)
+			}
 		}
 
 		I16 :: [].{
@@ -688,6 +735,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_i16(self)
 			}
+
+			decode : src, fmt -> (Try(I16, err), src)
+				where [fmt.decode_i16 : fmt, src -> (Try(I16, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_i16(format, source)
+			}
 		}
 
 		U32 :: [].{
@@ -760,6 +814,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_u32(self)
 			}
+
+			decode : src, fmt -> (Try(U32, err), src)
+				where [fmt.decode_u32 : fmt, src -> (Try(U32, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_u32(format, source)
+			}
 		}
 
 		I32 :: [].{
@@ -838,6 +899,14 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_i32(self)
 			}
+
+			# Decode an I32 using a format that provides decode_i32
+			decode : src, fmt -> (Try(I32, err), src)
+				where [fmt.decode_i32 : fmt, src -> (Try(I32, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_i32(format, source)
+			}
 		}
 
 		U64 :: [].{
@@ -912,6 +981,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_u64(self)
 			}
+
+			decode : src, fmt -> (Try(U64, err), src)
+				where [fmt.decode_u64 : fmt, src -> (Try(U64, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_u64(format, source)
+			}
 		}
 
 		I64 :: [].{
@@ -991,6 +1067,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_i64(self)
 			}
+
+			decode : src, fmt -> (Try(I64, err), src)
+				where [fmt.decode_i64 : fmt, src -> (Try(I64, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_i64(format, source)
+			}
 		}
 
 		U128 :: [].{
@@ -1069,6 +1152,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_u128(self)
 			}
+
+			decode : src, fmt -> (Try(U128, err), src)
+				where [fmt.decode_u128 : fmt, src -> (Try(U128, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_u128(format, source)
+			}
 		}
 
 		I128 :: [].{
@@ -1151,6 +1241,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_i128(self)
 			}
+
+			decode : src, fmt -> (Try(I128, err), src)
+				where [fmt.decode_i128 : fmt, src -> (Try(I128, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_i128(format, source)
+			}
 		}
 
 		Dec :: [].{
@@ -1229,6 +1326,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_dec(self)
 			}
+
+			decode : src, fmt -> (Try(Dec, err), src)
+				where [fmt.decode_dec : fmt, src -> (Try(Dec, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_dec(format, source)
+			}
 		}
 
 		F32 :: [].{
@@ -1292,6 +1396,13 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_f32(self)
 			}
+
+			decode : src, fmt -> (Try(F32, err), src)
+				where [fmt.decode_f32 : fmt, src -> (Try(F32, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_f32(format, source)
+			}
 		}
 
 		F64 :: [].{
@@ -1365,8 +1476,16 @@ Builtin :: [].{
 			encode = |self, format| {
 				format.encode_f64(self)
 			}
+
+			decode : src, fmt -> (Try(F64, err), src)
+				where [fmt.decode_f64 : fmt, src -> (Try(F64, err), src)]
+			decode = |source, format| {
+				Fmt : fmt
+				Fmt.decode_f64(format, source)
+			}
 		}
 	}
+
 }
 
 range_to = |var $current, end| {

src/canonicalize/Can.zig

@@ -4327,8 +4327,12 @@ pub fn canonicalizeExpr(
                                     if (self.module_envs.?.get(module_alias)) |auto_imported_type_env| {
                                         const module_env = auto_imported_type_env.env;
 
-                                        // Get the qualified name of the method (e.g., "Str.is_empty")
-                                        const qualified_text = self.env.getIdent(type_qualified_idx);
+                                        // Build the FULLY qualified method name using qualified_type_ident
+                                        // e.g., for I32.decode: "Builtin.Num.I32" + "decode" -> "Builtin.Num.I32.decode"
+                                        // e.g., for Str.concat: "Builtin.Str" + "concat" -> "Builtin.Str.concat"
+                                        const qualified_type_text = self.env.getIdent(auto_imported_type_env.qualified_type_ident);
+                                        const fully_qualified_idx = try self.env.insertQualifiedIdent(qualified_type_text, field_text);
+                                        const qualified_text = self.env.getIdent(fully_qualified_idx);
 
                                         // Try to find the method in the Builtin module's exposed items
                                         if (module_env.common.findIdent(qualified_text)) |qname_ident| {
@@ -11705,9 +11709,22 @@ fn tryModuleQualifiedLookup(self: *Self, field_access: AST.BinOp) std.mem.Alloca
     const left_ident = left_expr.ident;
     const module_alias = self.parse_ir.tokens.resolveIdentifier(left_ident.token) orelse return null;
 
-    // Check if this is a module alias
-    const module_info = self.scopeLookupModule(module_alias) orelse return null;
-    const module_name = module_info.module_name;
+    // Check if this is a module alias OR an auto-imported type
+    // Auto-imported types (like I32, Bool, Str) can have static methods called on them
+    const module_info = self.scopeLookupModule(module_alias);
+    const module_name = if (module_info) |info|
+        info.module_name
+    else blk: {
+        // Not a module alias - check if it's an auto-imported type in module_envs
+        if (self.module_envs) |envs_map| {
+            if (envs_map.contains(module_alias)) {
+                // This IS an auto-imported type - use the alias as the module_name
+                break :blk module_alias;
+            }
+        }
+        // Not a module alias and not an auto-imported type
+        return null;
+    };
     const module_text = self.env.getIdent(module_name);
 
     // Check if this module is imported in the current scope
@@ -11761,16 +11778,18 @@ fn tryModuleQualifiedLookup(self: *Self, field_access: AST.BinOp) std.mem.Alloca
         if (self.module_envs) |envs_map| {
             if (envs_map.get(module_name)) |auto_imported_type| {
                 if (auto_imported_type.statement_idx != null) {
-                    // This is an imported type module (like Stdout)
-                    // Look up the qualified method name (e.g., "Stdout.line!") in the module's exposed items
+                    // This is an imported type module (like Stdout, I32, etc.)
+                    // Look up the qualified method name (e.g., "Builtin.Num.I32.decode") in the module's exposed items
                     const module_env = auto_imported_type.env;
                     const module_name_text = module_env.module_name;
                     const auto_import_idx = try self.getOrCreateAutoImport(module_name_text);
 
-                    // Build the qualified method name: "TypeName.method_name"
-                    const type_name_text = self.env.getIdent(module_name);
+                    // Build the FULLY qualified method name using qualified_type_ident
+                    // e.g., for I32.decode: "Builtin.Num.I32" + "decode" -> "Builtin.Num.I32.decode"
+                    // e.g., for Str.concat: "Builtin.Str" + "concat" -> "Builtin.Str.concat"
+                    const qualified_type_text = self.env.getIdent(auto_imported_type.qualified_type_ident);
                     const method_name_text = self.env.getIdent(method_name);
-                    const qualified_method_name = try self.env.insertQualifiedIdent(type_name_text, method_name_text);
+                    const qualified_method_name = try self.env.insertQualifiedIdent(qualified_type_text, method_name_text);
                     const qualified_text = self.env.getIdent(qualified_method_name);
 
                     // Look up the qualified method in the module's exposed items