Commit 9aaffe00d3

@@ -15,7 +15,7 @@ fn map(name: []const u8) ![]const u8 {
     return name;
 }
 
-fn renderType(file: *C, writer: std.ArrayList(u8).Writer, T: Type) !void {
+fn renderType(file: *C, writer: std.ArrayList(u8).Writer, T: Type, src: usize) !void {
     if (T.tag() == .usize) {
         file.need_stddef = true;
         try writer.writeAll("size_t");
@@ -26,20 +26,20 @@ fn renderType(file: *C, writer: std.ArrayList(u8).Writer, T: Type) !void {
                 try writer.writeAll("noreturn void");
             },
             .Void => try writer.writeAll("void"),
-            else => return error.Unimplemented,
+            else => |e| return file.fail(src, "TODO implement type {}", .{e}),
         }
     }
 }
 
 fn renderFunctionSignature(file: *C, writer: std.ArrayList(u8).Writer, decl: *Decl) !void {
     const tv = decl.typed_value.most_recent.typed_value;
-    try renderType(file, writer, tv.ty.fnReturnType());
+    try renderType(file, writer, tv.ty.fnReturnType(), decl.src());
     const name = try map(mem.spanZ(decl.name));
     try writer.print(" {}(", .{name});
     if (tv.ty.fnParamLen() == 0) {
         try writer.writeAll("void)");
     } else {
-        return error.Unimplemented;
+        return file.fail(decl.src(), "TODO implement parameters", .{});
     }
 }
 
@@ -68,21 +68,21 @@ pub fn generate(file: *C, decl: *Decl) !void {
                                     if (arg.cast(ir.Inst.Constant)) |c| {
                                         if (c.val.tag() == .int_u64) {
                                             try writer.writeAll("register ");
-                                            try renderType(file, writer, arg.ty);
+                                            try renderType(file, writer, arg.ty, decl.src());
                                             try writer.print(" {}_constant __asm__(\"{}\") = {};\n\t", .{ reg, reg, c.val.toUnsignedInt() });
                                         } else {
-                                            return error.Unimplemented;
+                                            return file.fail(decl.src(), "TODO inline asm {} args", .{c.val.tag()});
                                         }
                                     } else {
-                                        return error.Unimplemented;
+                                        return file.fail(decl.src(), "TODO non-constant inline asm args", .{});
                                     }
                                 } else {
-                                    return error.Unimplemented;
+                                    return file.fail(decl.src(), "TODO non-explicit inline asm regs", .{});
                                 }
                             }
                             try writer.print("__asm {} (\"{}\"", .{ if (as.is_volatile) @as([]const u8, "volatile") else "", as.asm_source });
                             if (as.output) |o| {
-                                return error.Unimplemented;
+                                return file.fail(decl.src(), "TODO inline asm output", .{});
                             }
                             if (as.inputs.len > 0) {
                                 if (as.output == null) {
@@ -99,10 +99,12 @@ pub fn generate(file: *C, decl: *Decl) !void {
                                         if (arg.cast(ir.Inst.Constant)) |c| {
                                             try writer.print("\"\"({}_constant)", .{reg});
                                         } else {
-                                            return error.Unimplemented;
+                                            // This is blocked by the earlier test
+                                            unreachable;
                                         }
                                     } else {
-                                        return error.Unimplemented;
+                                        // This is blocked by the earlier test
+                                        unreachable;
                                     }
                                 }
                             }
@@ -121,20 +123,17 @@ pub fn generate(file: *C, decl: *Decl) !void {
                                     }
                                     try writer.print("{}();", .{tname});
                                 } else {
-                                    std.debug.warn("non-function call target?\n", .{});
-                                    return error.Unimplemented;
+                                    return file.fail(decl.src(), "TODO non-function call target?", .{});
                                 }
                                 if (call.args.len != 0) {
-                                    std.debug.warn("parameters\n", .{});
-                                    return error.Unimplemented;
+                                    return file.fail(decl.src(), "TODO function arguments", .{});
                                 }
                             } else {
-                                std.debug.warn("non-constant call inst?\n", .{});
-                                return error.Unimplemented;
+                                return file.fail(decl.src(), "TODO non-constant call inst?", .{});
                             }
                         },
-                        else => {
-                            std.debug.warn("\nTranslating {}\n", .{inst.*});
+                        else => |e| {
+                            return file.fail(decl.src(), "TODO {}", .{e});
                         },
                     }
                 }
@@ -151,13 +150,12 @@ pub fn generate(file: *C, decl: *Decl) !void {
                     std.debug.warn("\n\nARRAYTRANS\n", .{});
                     if (tv.ty.arraySentinel()) |sentinel| {}
                 } else {
-                    return error.Unimplemented;
+                    return file.fail(decl.src(), "TODO non-byte arrays", .{});
                 }
             }
         },
         else => |e| {
-            std.debug.warn("\nTODO implement {}\n", .{e});
-            return error.Unimplemented;
+            return file.fail(decl.src(), "TODO {}", .{e});
         },
     }
 }

@@ -227,6 +227,12 @@ pub const File = struct {
         need_stddef: bool = false,
         need_stdint: bool = false,
         need_noreturn: bool = false,
+        error_msg: *Module.ErrorMsg = undefined,
+
+        pub fn fail(self: *C, src: usize, comptime format: []const u8, args: var) !void {
+            self.error_msg = try Module.ErrorMsg.create(self.allocator, src, format, args);
+            return error.CGenFailure;
+        }
 
         pub fn deinit(self: *File.C) void {
             self.main.deinit();
@@ -237,7 +243,12 @@ pub const File = struct {
         }
 
         pub fn updateDecl(self: *File.C, module: *Module, decl: *Module.Decl) !void {
-            try cgen.generate(self, decl);
+            cgen.generate(self, decl) catch |err| {
+                if (err == error.CGenFailure) {
+                    try module.failed_decls.put(decl, self.error_msg);
+                }
+                return err;
+            };
         }
 
         pub fn flush(self: *File.C) !void {
@@ -1185,7 +1196,7 @@ pub const File = struct {
                 .appended => code_buffer.items,
                 .fail => |em| {
                     decl.analysis = .codegen_failure;
-                    _ = try module.failed_decls.put(decl, em);
+                    try module.failed_decls.put(decl, em);
                     return;
                 },
             };