Commit 8c9ac4db978c80246b4872c899b1618b1b195ec2 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-01-16 22:51:01-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-01-16 22:51:01-07:00
log	8c9ac4db978c80246b4872c899b1618b1b195ec2
tree	e6bddfb9df54fc6d60518978506e6869c1b2be80
parent	8436134499c623485aeb20374a9928685db4211e

stage2: implement error notes and regress -femit-zir

 * Implement error notes
   - note: other symbol exported here
   - note: previous else prong is here
   - note: previous '_' prong is here
 * Add Compilation.CObject.ErrorMsg. This object properly converts to
   AllErrors.Message when the time comes.
 * Add Compilation.CObject.failure_retryable. Properly handles
   out-of-memory and other transient failures.
 * Introduce Module.SrcLoc which has not only a byte offset but also
   references the file which the byte offset applies to.
 * Scope.Block now contains both a pointer to the "owner" Decl and the
   "source" Decl. As an example, during inline function call, the
   "owner" will be the Decl of the caller and the "source" will be the
   Decl of the callee.
 * Module.ErrorMsg now sports a `file_scope` field so that notes can
   refer to source locations in a file other than the parent error
   message.
 * Some instances where a `*Scope` was stored, now store a
   `*Scope.Container`.
 * Some methods in the `Scope` namespace were moved to the more specific
   type, since there was only an implementation for one particular tag.
   - `removeDecl` moved to `Scope.Container`
   - `destroy` moved to `Scope.File`
 * Two kinds of Scope deleted:
   - zir_module
   - decl
 * astgen: properly use DeclVal / DeclRef. DeclVal was incorrectly
   changed to be a reference; this commit fixes it. Fewer ZIR
   instructions processed as a result.
   - declval_in_module is renamed to declval
   - previous declval ZIR instruction is deleted; it was only for .zir
     files.
 * Test harness: friendlier diagnostics when an unexpected set of errors
   is encountered.
 * zir_sema: fix analyzeInstBlockFlat by properly calling resolvingInst
   on the last zir instruction in the block.

Compile log implementation:
 * Write to a buffer rather than directly to stderr.
 * Only keep track of 1 callsite per Decl.
 * No longer mutate the ZIR Inst struct data.
 * "Compile log statement found" errors are only emitted when there are
   no other compile errors.

-femit-zir and support for .zir source files is regressed. If we wanted
to support this again, outputting .zir would need to be done as yet
another backend rather than in the haphazard way it was previously
implemented.

For parsing .zir, it was implemented previously in a way that was not
helpful for debugging. We need tighter integration with the test harness
for it to be useful; so clearly a rewrite is needed. Given that a
rewrite is needed, and it was getting in the way of progress and
organization of the rest of stage2, I regressed the feature.

18 files changed, 904 insertions(+), 2618 deletions(-)

src
- Compilation.zig
- Module.zig
- astgen.zig
- codegen.zig
- codegen
  - c.zig
  - llvm.zig
- link
  - Coff.zig
  - Elf.zig
  - MachO.zig
  - MachO
    DebugSymbols.zig
- main.zig
- test.zig
- type
- zir.zig
- zir_sema.zig
test
- stage2
  - test.zig

src/Compilation.zig+179-126

 @@ -51,7 +51,7 @@ c_object_work_queue: std.fifo.LinearFifo(*CObject, .Dynamic),
 /// The ErrorMsg memory is owned by the `CObject`, using Compilation's general purpose allocator.
 /// This data is accessed by multiple threads and is protected by `mutex`.
-failed_c_objects: std.AutoArrayHashMapUnmanaged(*CObject, *ErrorMsg) = .{},
+failed_c_objects: std.AutoArrayHashMapUnmanaged(*CObject, *CObject.ErrorMsg) = .{},
 keep_source_files_loaded: bool,
 use_clang: bool,
 @@ -215,13 +215,29 @@ pub const CObject = struct {
         },
         /// There will be a corresponding ErrorMsg in Compilation.failed_c_objects.
         failure,
+        /// A transient failure happened when trying to compile the C Object; it may
+        /// succeed if we try again. There may be a corresponding ErrorMsg in
+        /// Compilation.failed_c_objects. If there is not, the failure is out of memory.
+        failure_retryable,
     },
+    pub const ErrorMsg = struct {
+        msg: []const u8,
+        line: u32,
+        column: u32,
+        pub fn destroy(em: *ErrorMsg, gpa: *Allocator) void {
+            gpa.free(em.msg);
+            gpa.destroy(em);
+            em.* = undefined;
+        }
+    };
     /// Returns if there was failure.
     pub fn clearStatus(self: *CObject, gpa: *Allocator) bool {
         switch (self.status) {
             .new => return false,
-            .failure => {
+            .failure, .failure_retryable => {
                 self.status = .new;
                 return true;
             },
 @@ -240,6 +256,11 @@ pub const CObject = struct {
     }
 };
+/// To support incremental compilation, errors are stored in various places
+/// so that they can be created and destroyed appropriately. This structure
+/// is used to collect all the errors from the various places into one
+/// convenient place for API users to consume. It is allocated into 1 heap
+/// and freed all at once.
 pub const AllErrors = struct {
     arena: std.heap.ArenaAllocator.State,
     list: []const Message,
 @@ -251,23 +272,32 @@ pub const AllErrors = struct {
             column: usize,
             byte_offset: usize,
             msg: []const u8,
+            notes: []Message = &.{},
         },
         plain: struct {
             msg: []const u8,
         },
-        pub fn renderToStdErr(self: Message) void {
+        pub fn renderToStdErr(msg: Message) void {
-            switch (self) {
+            return msg.renderToStdErrInner("error");
+        }
+        fn renderToStdErrInner(msg: Message, kind: []const u8) void {
+            switch (msg) {
                 .src => |src| {
-                    std.debug.print("{s}:{d}:{d}: error: {s}\n", .{
+                    std.debug.print("{s}:{d}:{d}: {s}: {s}\n", .{
                         src.src_path,
                         src.line + 1,
                         src.column + 1,
+                        kind,
                         src.msg,
                     });
+                    for (src.notes) |note| {
+                        note.renderToStdErrInner("note");
+                    }
                 },
                 .plain => |plain| {
-                    std.debug.print("error: {s}\n", .{plain.msg});
+                    std.debug.print("{s}: {s}\n", .{ kind, plain.msg });
                 },
             }
         }
 @@ -278,20 +308,38 @@ pub const AllErrors = struct {
     }
     fn add(
+        module: *Module,
         arena: *std.heap.ArenaAllocator,
         errors: *std.ArrayList(Message),
-        sub_file_path: []const u8,
+        module_err_msg: Module.ErrorMsg,
-        source: []const u8,
-        simple_err_msg: ErrorMsg,
     ) !void {
-        const loc = std.zig.findLineColumn(source, simple_err_msg.byte_offset);
+        const notes = try arena.allocator.alloc(Message, module_err_msg.notes.len);
+        for (notes) |*note, i| {
+            const module_note = module_err_msg.notes[i];
+            const source = try module_note.src_loc.file_scope.getSource(module);
+            const loc = std.zig.findLineColumn(source, module_note.src_loc.byte_offset);
+            const sub_file_path = module_note.src_loc.file_scope.sub_file_path;
+            note.* = .{
+                .src = .{
+                    .src_path = try arena.allocator.dupe(u8, sub_file_path),
+                    .msg = try arena.allocator.dupe(u8, module_note.msg),
+                    .byte_offset = module_note.src_loc.byte_offset,
+                    .line = loc.line,
+                    .column = loc.column,
+                },
+            };
+        }
+        const source = try module_err_msg.src_loc.file_scope.getSource(module);
+        const loc = std.zig.findLineColumn(source, module_err_msg.src_loc.byte_offset);
+        const sub_file_path = module_err_msg.src_loc.file_scope.sub_file_path;
         try errors.append(.{
             .src = .{
                 .src_path = try arena.allocator.dupe(u8, sub_file_path),
-                .msg = try arena.allocator.dupe(u8, simple_err_msg.msg),
+                .msg = try arena.allocator.dupe(u8, module_err_msg.msg),
-                .byte_offset = simple_err_msg.byte_offset,
+                .byte_offset = module_err_msg.src_loc.byte_offset,
                 .line = loc.line,
                 .column = loc.column,
+                .notes = notes,
             },
         });
     }
 @@ -849,17 +897,9 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
                             .ty = struct_ty,
                         },
                     };
-                    break :rs &root_scope.base;
+                    break :rs root_scope;
                 } else if (mem.endsWith(u8, root_pkg.root_src_path, ".zir")) {
-                    const root_scope = try gpa.create(Module.Scope.ZIRModule);
+                    return error.ZirFilesUnsupported;
-                    root_scope.* = .{
-                        .sub_file_path = root_pkg.root_src_path,
-                        .source = .{ .unloaded = {} },
-                        .contents = .{ .not_available = {} },
-                        .status = .never_loaded,
-                        .decls = .{},
-                    };
-                    break :rs &root_scope.base;
                 } else {
                     unreachable;
                 }
 @@ -1258,32 +1298,23 @@ pub fn update(self: *Compilation) !void {
     const use_stage1 = build_options.is_stage1 and self.bin_file.options.use_llvm;
     if (!use_stage1) {
         if (self.bin_file.options.module) |module| {
+            module.compile_log_text.shrinkAndFree(module.gpa, 0);
             module.generation += 1;
             // TODO Detect which source files changed.
             // Until then we simulate a full cache miss. Source files could have been loaded for any reason;
             // to force a refresh we unload now.
-            if (module.root_scope.cast(Module.Scope.File)) |zig_file| {
+            module.root_scope.unload(module.gpa);
-                zig_file.unload(module.gpa);
+            module.failed_root_src_file = null;
-                module.failed_root_src_file = null;
+            module.analyzeContainer(&module.root_scope.root_container) catch |err| switch (err) {
-                module.analyzeContainer(&zig_file.root_container) catch |err| switch (err) {
+                error.AnalysisFail => {
-                    error.AnalysisFail => {
+                    assert(self.totalErrorCount() != 0);
-                        assert(self.totalErrorCount() != 0);
+                },
-                    },
+                error.OutOfMemory => return error.OutOfMemory,
-                    error.OutOfMemory => return error.OutOfMemory,
+                else => |e| {
-                    else => |e| {
+                    module.failed_root_src_file = e;
-                        module.failed_root_src_file = e;
+                },
-                    },
+            };
-                };
-            } else if (module.root_scope.cast(Module.Scope.ZIRModule)) |zir_module| {
-                zir_module.unload(module.gpa);
-                module.analyzeRootZIRModule(zir_module) catch |err| switch (err) {
-                    error.AnalysisFail => {
-                        assert(self.totalErrorCount() != 0);
-                    },
-                    else => |e| return e,
-                };
-            }
             // TODO only analyze imports if they are still referenced
             for (module.import_table.items()) |entry| {
 @@ -1359,14 +1390,18 @@ pub fn totalErrorCount(self: *Compilation) usize {
             module.failed_exports.items().len +
             module.failed_files.items().len +
             @boolToInt(module.failed_root_src_file != null);
-        for (module.compile_log_decls.items()) |entry| {
-            total += entry.value.items.len;
-        }
     }
     // The "no entry point found" error only counts if there are no other errors.
     if (total == 0) {
-        return @boolToInt(self.link_error_flags.no_entry_point_found);
+        total += @boolToInt(self.link_error_flags.no_entry_point_found);
+    }
+    // Compile log errors only count if there are no other errors.
+    if (total == 0) {
+        if (self.bin_file.options.module) |module| {
+            total += @boolToInt(module.compile_log_decls.items().len != 0);
+        }
     }
     return total;
 @@ -1382,32 +1417,32 @@ pub fn getAllErrorsAlloc(self: *Compilation) !AllErrors {
     for (self.failed_c_objects.items()) |entry| {
         const c_object = entry.key;
         const err_msg = entry.value;
-        try AllErrors.add(&arena, &errors, c_object.src.src_path, "", err_msg.*);
+        // TODO these fields will need to be adjusted when we have proper
+        // C error reporting bubbling up.
+        try errors.append(.{
+            .src = .{
+                .src_path = try arena.allocator.dupe(u8, c_object.src.src_path),
+                .msg = try std.fmt.allocPrint(&arena.allocator, "unable to build C object: {s}", .{
+                    err_msg.msg,
+                }),
+                .byte_offset = 0,
+                .line = err_msg.line,
+                .column = err_msg.column,
+            },
+        });
     }
     if (self.bin_file.options.module) |module| {
         for (module.failed_files.items()) |entry| {
-            const scope = entry.key;
+            try AllErrors.add(module, &arena, &errors, entry.value.*);
-            const err_msg = entry.value;
-            const source = try scope.getSource(module);
-            try AllErrors.add(&arena, &errors, scope.subFilePath(), source, err_msg.*);
         }
         for (module.failed_decls.items()) |entry| {
-            const decl = entry.key;
+            try AllErrors.add(module, &arena, &errors, entry.value.*);
-            const err_msg = entry.value;
-            const source = try decl.scope.getSource(module);
-            try AllErrors.add(&arena, &errors, decl.scope.subFilePath(), source, err_msg.*);
         }
         for (module.emit_h_failed_decls.items()) |entry| {
-            const decl = entry.key;
+            try AllErrors.add(module, &arena, &errors, entry.value.*);
-            const err_msg = entry.value;
-            const source = try decl.scope.getSource(module);
-            try AllErrors.add(&arena, &errors, decl.scope.subFilePath(), source, err_msg.*);
         }
         for (module.failed_exports.items()) |entry| {
-            const decl = entry.key.owner_decl;
+            try AllErrors.add(module, &arena, &errors, entry.value.*);
-            const err_msg = entry.value;
-            const source = try decl.scope.getSource(module);
-            try AllErrors.add(&arena, &errors, decl.scope.subFilePath(), source, err_msg.*);
         }
         if (module.failed_root_src_file) |err| {
             const file_path = try module.root_pkg.root_src_directory.join(&arena.allocator, &[_][]const u8{
 @@ -1418,15 +1453,6 @@ pub fn getAllErrorsAlloc(self: *Compilation) !AllErrors {
             });
             try AllErrors.addPlain(&arena, &errors, msg);
         }
-        for (module.compile_log_decls.items()) |entry| {
-            const decl = entry.key;
-            const path = decl.scope.subFilePath();
-            const source = try decl.scope.getSource(module);
-            for (entry.value.items) |src_loc| {
-                const err_msg = ErrorMsg{ .byte_offset = src_loc, .msg = "found compile log statement" };
-                try AllErrors.add(&arena, &errors, path, source, err_msg);
-            }
-        }
     }
     if (errors.items.len == 0 and self.link_error_flags.no_entry_point_found) {
 @@ -1437,6 +1463,28 @@ pub fn getAllErrorsAlloc(self: *Compilation) !AllErrors {
         });
     }
+    if (self.bin_file.options.module) |module| {
+        const compile_log_items = module.compile_log_decls.items();
+        if (errors.items.len == 0 and compile_log_items.len != 0) {
+            // First one will be the error; subsequent ones will be notes.
+            const err_msg = Module.ErrorMsg{
+                .src_loc = compile_log_items[0].value,
+                .msg = "found compile log statement",
+                .notes = try self.gpa.alloc(Module.ErrorMsg, compile_log_items.len - 1),
+            };
+            defer self.gpa.free(err_msg.notes);
+            for (compile_log_items[1..]) |entry, i| {
+                err_msg.notes[i] = .{
+                    .src_loc = entry.value,
+                    .msg = "also here",
+                };
+            }
+            try AllErrors.add(module, &arena, &errors, err_msg);
+        }
+    }
     assert(errors.items.len == self.totalErrorCount());
     return AllErrors{
 @@ -1445,6 +1493,11 @@ pub fn getAllErrorsAlloc(self: *Compilation) !AllErrors {
     };
 }
+pub fn getCompileLogOutput(self: *Compilation) []const u8 {
+    const module = self.bin_file.options.module orelse return &[0]u8{};
+    return module.compile_log_text.items;
+}
 pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemory }!void {
     var progress: std.Progress = .{};
     var main_progress_node = try progress.start("", 0);
 @@ -1517,9 +1570,9 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
                     },
                     else => {
                         try module.failed_decls.ensureCapacity(module.gpa, module.failed_decls.items().len + 1);
-                        module.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
+                        module.failed_decls.putAssumeCapacityNoClobber(decl, try Module.ErrorMsg.create(
                             module.gpa,
-                            decl.src(),
+                            decl.srcLoc(),
                             "unable to codegen: {s}",
                             .{@errorName(err)},
                         ));
 @@ -1586,9 +1639,9 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
             const module = self.bin_file.options.module.?;
             self.bin_file.updateDeclLineNumber(module, decl) catch |err| {
                 try module.failed_decls.ensureCapacity(module.gpa, module.failed_decls.items().len + 1);
-                module.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
+                module.failed_decls.putAssumeCapacityNoClobber(decl, try Module.ErrorMsg.create(
                     module.gpa,
-                    decl.src(),
+                    decl.srcLoc(),
                     "unable to update line number: {s}",
                     .{@errorName(err)},
                 ));
 @@ -1858,26 +1911,38 @@ fn workerUpdateCObject(
     comp.updateCObject(c_object, progress_node) catch |err| switch (err) {
         error.AnalysisFail => return,
         else => {
-            {
+            comp.reportRetryableCObjectError(c_object, err) catch |oom| switch (oom) {
-                const lock = comp.mutex.acquire();
+                // Swallowing this error is OK because it's implied to be OOM when
-                defer lock.release();
+                // there is a missing failed_c_objects error message.
-                comp.failed_c_objects.ensureCapacity(comp.gpa, comp.failed_c_objects.items().len + 1) catch {
+                error.OutOfMemory => {},
-                    fatal("TODO handle this by setting c_object.status = oom failure", .{});
+            };
-                };
-                comp.failed_c_objects.putAssumeCapacityNoClobber(c_object, ErrorMsg.create(
-                    comp.gpa,
-                    0,
-                    "unable to build C object: {s}",
-                    .{@errorName(err)},
-                ) catch {
-                    fatal("TODO handle this by setting c_object.status = oom failure", .{});
-                });
-            }
-            c_object.status = .{ .failure = {} };
         },
     };
 }
+fn reportRetryableCObjectError(
+    comp: *Compilation,
+    c_object: *CObject,
+    err: anyerror,
+) error{OutOfMemory}!void {
+    c_object.status = .failure_retryable;
+    const c_obj_err_msg = try comp.gpa.create(CObject.ErrorMsg);
+    errdefer comp.gpa.destroy(c_obj_err_msg);
+    const msg = try std.fmt.allocPrint(comp.gpa, "unable to build C object: {s}", .{@errorName(err)});
+    errdefer comp.gpa.free(msg);
+    c_obj_err_msg.* = .{
+        .msg = msg,
+        .line = 0,
+        .column = 0,
+    };
+    {
+        const lock = comp.mutex.acquire();
+        defer lock.release();
+        try comp.failed_c_objects.putNoClobber(comp.gpa, c_object, c_obj_err_msg);
+    }
+}
 fn updateCObject(comp: *Compilation, c_object: *CObject, c_comp_progress_node: *std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return comp.failCObj(c_object, "clang not available: compiler built without LLVM extensions", .{});
 @@ -1892,7 +1957,9 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_comp_progress_node: *
         // There was previous failure.
         const lock = comp.mutex.acquire();
         defer lock.release();
-        comp.failed_c_objects.removeAssertDiscard(c_object);
+        // If the failure was OOM, there will not be an entry here, so we do
+        // not assert discard.
+        _ = comp.failed_c_objects.swapRemove(c_object);
     }
     var man = comp.obtainCObjectCacheManifest();
 @@ -2343,11 +2410,27 @@ pub fn addCCArgs(
 fn failCObj(comp: *Compilation, c_object: *CObject, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
-    const err_msg = try ErrorMsg.create(comp.gpa, 0, "unable to build C object: " ++ format, args);
+    const err_msg = blk: {
+        const msg = try std.fmt.allocPrint(comp.gpa, format, args);
+        errdefer comp.gpa.free(msg);
+        const err_msg = try comp.gpa.create(CObject.ErrorMsg);
+        errdefer comp.gpa.destroy(err_msg);
+        err_msg.* = .{
+            .msg = msg,
+            .line = 0,
+            .column = 0,
+        };
+        break :blk err_msg;
+    };
     return comp.failCObjWithOwnedErrorMsg(c_object, err_msg);
 }
-fn failCObjWithOwnedErrorMsg(comp: *Compilation, c_object: *CObject, err_msg: *ErrorMsg) InnerError {
+fn failCObjWithOwnedErrorMsg(
+    comp: *Compilation,
+    c_object: *CObject,
+    err_msg: *CObject.ErrorMsg,
+) InnerError {
+    @setCold(true);
     {
         const lock = comp.mutex.acquire();
         defer lock.release();
 @@ -2361,36 +2444,6 @@ fn failCObjWithOwnedErrorMsg(comp: *Compilation, c_object: *CObject, err_msg: *E
     return error.AnalysisFail;
 }
-pub const ErrorMsg = struct {
-    byte_offset: usize,
-    msg: []const u8,
-    pub fn create(gpa: *Allocator, byte_offset: usize, comptime format: []const u8, args: anytype) !*ErrorMsg {
-        const self = try gpa.create(ErrorMsg);
-        errdefer gpa.destroy(self);
-        self.* = try init(gpa, byte_offset, format, args);
-        return self;
-    }
-    /// Assumes the ErrorMsg struct and msg were both allocated with allocator.
-    pub fn destroy(self: *ErrorMsg, gpa: *Allocator) void {
-        self.deinit(gpa);
-        gpa.destroy(self);
-    }
-    pub fn init(gpa: *Allocator, byte_offset: usize, comptime format: []const u8, args: anytype) !ErrorMsg {
-        return ErrorMsg{
-            .byte_offset = byte_offset,
-            .msg = try std.fmt.allocPrint(gpa, format, args),
-        };
-    }
-    pub fn deinit(self: *ErrorMsg, gpa: *Allocator) void {
-        gpa.free(self.msg);
-        self.* = undefined;
-    }
-};
 pub const FileExt = enum {
     c,
     cpp,

src/Module.zig+281-483

 @@ -35,8 +35,7 @@ zig_cache_artifact_directory: Compilation.Directory,
 /// Pointer to externally managed resource. `null` if there is no zig file being compiled.
 root_pkg: *Package,
 /// Module owns this resource.
-/// The `Scope` is either a `Scope.ZIRModule` or `Scope.File`.
+root_scope: *Scope.File,
-root_scope: *Scope,
 /// It's rare for a decl to be exported, so we save memory by having a sparse map of
 /// Decl pointers to details about them being exported.
 /// The Export memory is owned by the `export_owners` table; the slice itself is owned by this table.
 @@ -57,19 +56,19 @@ decl_table: std.ArrayHashMapUnmanaged(Scope.NameHash, *Decl, Scope.name_hash_has
 /// The ErrorMsg memory is owned by the decl, using Module's general purpose allocator.
 /// Note that a Decl can succeed but the Fn it represents can fail. In this case,
 /// a Decl can have a failed_decls entry but have analysis status of success.
-failed_decls: std.AutoArrayHashMapUnmanaged(*Decl, *Compilation.ErrorMsg) = .{},
+failed_decls: std.AutoArrayHashMapUnmanaged(*Decl, *ErrorMsg) = .{},
 /// When emit_h is non-null, each Decl gets one more compile error slot for
 /// emit-h failing for that Decl. This table is also how we tell if a Decl has
 /// failed emit-h or succeeded.
-emit_h_failed_decls: std.AutoArrayHashMapUnmanaged(*Decl, *Compilation.ErrorMsg) = .{},
+emit_h_failed_decls: std.AutoArrayHashMapUnmanaged(*Decl, *ErrorMsg) = .{},
-/// A Decl can have multiple compileLogs, but only one error, so we map a Decl to a the src locs of all the compileLogs
+/// Keep track of one `@compileLog` callsite per owner Decl.
-compile_log_decls: std.AutoArrayHashMapUnmanaged(*Decl, ArrayListUnmanaged(usize)) = .{},
+compile_log_decls: std.AutoArrayHashMapUnmanaged(*Decl, SrcLoc) = .{},
 /// Using a map here for consistency with the other fields here.
 /// The ErrorMsg memory is owned by the `Scope`, using Module's general purpose allocator.
-failed_files: std.AutoArrayHashMapUnmanaged(*Scope, *Compilation.ErrorMsg) = .{},
+failed_files: std.AutoArrayHashMapUnmanaged(*Scope, *ErrorMsg) = .{},
 /// Using a map here for consistency with the other fields here.
 /// The ErrorMsg memory is owned by the `Export`, using Module's general purpose allocator.
-failed_exports: std.AutoArrayHashMapUnmanaged(*Export, *Compilation.ErrorMsg) = .{},
+failed_exports: std.AutoArrayHashMapUnmanaged(*Export, *ErrorMsg) = .{},
 next_anon_name_index: usize = 0,
 @@ -103,6 +102,8 @@ stage1_flags: packed struct {
 emit_h: ?Compilation.EmitLoc,
+compile_log_text: std.ArrayListUnmanaged(u8) = .{},
 pub const Export = struct {
     options: std.builtin.ExportOptions,
     /// Byte offset into the file that contains the export directive.
 @@ -138,9 +139,9 @@ pub const Decl = struct {
     /// mapping them to an address in the output file.
     /// Memory owned by this decl, using Module's allocator.
     name: [*:0]const u8,
-    /// The direct parent container of the Decl. This is either a `Scope.Container` or `Scope.ZIRModule`.
+    /// The direct parent container of the Decl.
     /// Reference to externally owned memory.
-    scope: *Scope,
+    container: *Scope.Container,
     /// The AST Node decl index or ZIR Inst index that contains this declaration.
     /// Must be recomputed when the corresponding source file is modified.
     src_index: usize,
 @@ -235,31 +236,21 @@ pub const Decl = struct {
         }
     }
+    pub fn srcLoc(self: Decl) SrcLoc {
+        return .{
+            .byte_offset = self.src(),
+            .file_scope = self.getFileScope(),
+        };
+    }
     pub fn src(self: Decl) usize {
-        switch (self.scope.tag) {
+        const tree = self.container.file_scope.contents.tree;
-            .container => {
+        const decl_node = tree.root_node.decls()[self.src_index];
-                const container = @fieldParentPtr(Scope.Container, "base", self.scope);
+        return tree.token_locs[decl_node.firstToken()].start;
-                const tree = container.file_scope.contents.tree;
-                // TODO Container should have its own decls()
-                const decl_node = tree.root_node.decls()[self.src_index];
-                return tree.token_locs[decl_node.firstToken()].start;
-            },
-            .zir_module => {
-                const zir_module = @fieldParentPtr(Scope.ZIRModule, "base", self.scope);
-                const module = zir_module.contents.module;
-                const src_decl = module.decls[self.src_index];
-                return src_decl.inst.src;
-            },
-            .file, .block => unreachable,
-            .gen_zir => unreachable,
-            .local_val => unreachable,
-            .local_ptr => unreachable,
-            .decl => unreachable,
-        }
     }
     pub fn fullyQualifiedNameHash(self: Decl) Scope.NameHash {
-        return self.scope.fullyQualifiedNameHash(mem.spanZ(self.name));
+        return self.container.fullyQualifiedNameHash(mem.spanZ(self.name));
     }
     pub fn typedValue(self: *Decl) error{AnalysisFail}!TypedValue {
 @@ -293,9 +284,8 @@ pub const Decl = struct {
         }
     }
-    /// Asserts that the `Decl` is part of AST and not ZIRModule.
+    pub fn getFileScope(self: Decl) *Scope.File {
-    pub fn getFileScope(self: *Decl) *Scope.File {
+        return self.container.file_scope;
-        return self.scope.cast(Scope.Container).?.file_scope;
     }
     pub fn getEmitH(decl: *Decl, module: *Module) *EmitH {
 @@ -326,7 +316,7 @@ pub const Fn = struct {
     /// Contains un-analyzed ZIR instructions generated from Zig source AST.
     /// Even after we finish analysis, the ZIR is kept in memory, so that
     /// comptime and inline function calls can happen.
-    zir: zir.Module.Body,
+    zir: zir.Body,
     /// undefined unless analysis state is `success`.
     body: Body,
     state: Analysis,
 @@ -373,47 +363,49 @@ pub const Scope = struct {
         return @fieldParentPtr(T, "base", base);
     }
-    /// Asserts the scope has a parent which is a DeclAnalysis and
+    /// Returns the arena Allocator associated with the Decl of the Scope.
-    /// returns the arena Allocator.
     pub fn arena(self: *Scope) *Allocator {
         switch (self.tag) {
             .block => return self.cast(Block).?.arena,
-            .decl => return &self.cast(DeclAnalysis).?.arena.allocator,
             .gen_zir => return self.cast(GenZIR).?.arena,
             .local_val => return self.cast(LocalVal).?.gen_zir.arena,
             .local_ptr => return self.cast(LocalPtr).?.gen_zir.arena,
-            .zir_module => return &self.cast(ZIRModule).?.contents.module.arena.allocator,
             .file => unreachable,
             .container => unreachable,
         }
     }
-    /// If the scope has a parent which is a `DeclAnalysis`,
+    pub fn ownerDecl(self: *Scope) ?*Decl {
-    /// returns the `Decl`, otherwise returns `null`.
+        return switch (self.tag) {
-    pub fn decl(self: *Scope) ?*Decl {
+            .block => self.cast(Block).?.owner_decl,
+            .gen_zir => self.cast(GenZIR).?.decl,
+            .local_val => self.cast(LocalVal).?.gen_zir.decl,
+            .local_ptr => self.cast(LocalPtr).?.gen_zir.decl,
+            .file => null,
+            .container => null,
+        };
+    }
+    pub fn srcDecl(self: *Scope) ?*Decl {
         return switch (self.tag) {
-            .block => self.cast(Block).?.decl,
+            .block => self.cast(Block).?.src_decl,
             .gen_zir => self.cast(GenZIR).?.decl,
             .local_val => self.cast(LocalVal).?.gen_zir.decl,
             .local_ptr => self.cast(LocalPtr).?.gen_zir.decl,
-            .decl => self.cast(DeclAnalysis).?.decl,
-            .zir_module => null,
             .file => null,
             .container => null,
         };
     }
-    /// Asserts the scope has a parent which is a ZIRModule or Container and
+    /// Asserts the scope has a parent which is a Container and returns it.
-    /// returns it.
+    pub fn namespace(self: *Scope) *Container {
-    pub fn namespace(self: *Scope) *Scope {
         switch (self.tag) {
-            .block => return self.cast(Block).?.decl.scope,
+            .block => return self.cast(Block).?.owner_decl.container,
-            .gen_zir => return self.cast(GenZIR).?.decl.scope,
+            .gen_zir => return self.cast(GenZIR).?.decl.container,
-            .local_val => return self.cast(LocalVal).?.gen_zir.decl.scope,
+            .local_val => return self.cast(LocalVal).?.gen_zir.decl.container,
-            .local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.scope,
+            .local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.container,
-            .decl => return self.cast(DeclAnalysis).?.decl.scope,
+            .file => return &self.cast(File).?.root_container,
-            .file => return &self.cast(File).?.root_container.base,
+            .container => return self.cast(Container).?,
-            .zir_module, .container => return self,
         }
     }
 @@ -426,9 +418,7 @@ pub const Scope = struct {
             .gen_zir => unreachable,
             .local_val => unreachable,
             .local_ptr => unreachable,
-            .decl => unreachable,
             .file => unreachable,
-            .zir_module => return self.cast(ZIRModule).?.fullyQualifiedNameHash(name),
             .container => return self.cast(Container).?.fullyQualifiedNameHash(name),
         }
     }
 @@ -437,12 +427,10 @@ pub const Scope = struct {
     pub fn tree(self: *Scope) *ast.Tree {
         switch (self.tag) {
             .file => return self.cast(File).?.contents.tree,
-            .zir_module => unreachable,
+            .block => return self.cast(Block).?.src_decl.container.file_scope.contents.tree,
-            .decl => return self.cast(DeclAnalysis).?.decl.scope.cast(Container).?.file_scope.contents.tree,
+            .gen_zir => return self.cast(GenZIR).?.decl.container.file_scope.contents.tree,
-            .block => return self.cast(Block).?.decl.scope.cast(Container).?.file_scope.contents.tree,
+            .local_val => return self.cast(LocalVal).?.gen_zir.decl.container.file_scope.contents.tree,
-            .gen_zir => return self.cast(GenZIR).?.decl.scope.cast(Container).?.file_scope.contents.tree,
+            .local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.container.file_scope.contents.tree,
-            .local_val => return self.cast(LocalVal).?.gen_zir.decl.scope.cast(Container).?.file_scope.contents.tree,
-            .local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.scope.cast(Container).?.file_scope.contents.tree,
             .container => return self.cast(Container).?.file_scope.contents.tree,
         }
     }
 @@ -454,38 +442,21 @@ pub const Scope = struct {
             .gen_zir => self.cast(GenZIR).?,
             .local_val => return self.cast(LocalVal).?.gen_zir,
             .local_ptr => return self.cast(LocalPtr).?.gen_zir,
-            .decl => unreachable,
-            .zir_module => unreachable,
             .file => unreachable,
             .container => unreachable,
         };
     }
-    /// Asserts the scope has a parent which is a ZIRModule, Container or File and
+    /// Asserts the scope has a parent which is a Container or File and
     /// returns the sub_file_path field.
     pub fn subFilePath(base: *Scope) []const u8 {
         switch (base.tag) {
             .container => return @fieldParentPtr(Container, "base", base).file_scope.sub_file_path,
             .file => return @fieldParentPtr(File, "base", base).sub_file_path,
-            .zir_module => return @fieldParentPtr(ZIRModule, "base", base).sub_file_path,
             .block => unreachable,
             .gen_zir => unreachable,
             .local_val => unreachable,
             .local_ptr => unreachable,
-            .decl => unreachable,
-        }
-    }
-    pub fn unload(base: *Scope, gpa: *Allocator) void {
-        switch (base.tag) {
-            .file => return @fieldParentPtr(File, "base", base).unload(gpa),
-            .zir_module => return @fieldParentPtr(ZIRModule, "base", base).unload(gpa),
-            .block => unreachable,
-            .gen_zir => unreachable,
-            .local_val => unreachable,
-            .local_ptr => unreachable,
-            .decl => unreachable,
-            .container => unreachable,
         }
     }
 @@ -493,67 +464,28 @@ pub const Scope = struct {
         switch (base.tag) {
             .container => return @fieldParentPtr(Container, "base", base).file_scope.getSource(module),
             .file => return @fieldParentPtr(File, "base", base).getSource(module),
-            .zir_module => return @fieldParentPtr(ZIRModule, "base", base).getSource(module),
             .gen_zir => unreachable,
             .local_val => unreachable,
             .local_ptr => unreachable,
             .block => unreachable,
-            .decl => unreachable,
         }
     }
+    /// When called from inside a Block Scope, chases the src_decl, not the owner_decl.
     pub fn getFileScope(base: *Scope) *Scope.File {
         var cur = base;
         while (true) {
             cur = switch (cur.tag) {
                 .container => return @fieldParentPtr(Container, "base", cur).file_scope,
                 .file => return @fieldParentPtr(File, "base", cur),
-                .zir_module => unreachable, // TODO are zir modules allowed to import packages?
                 .gen_zir => @fieldParentPtr(GenZIR, "base", cur).parent,
                 .local_val => @fieldParentPtr(LocalVal, "base", cur).parent,
                 .local_ptr => @fieldParentPtr(LocalPtr, "base", cur).parent,
-                .block => @fieldParentPtr(Block, "base", cur).decl.scope,
+                .block => return @fieldParentPtr(Block, "base", cur).src_decl.container.file_scope,
-                .decl => @fieldParentPtr(DeclAnalysis, "base", cur).decl.scope,
             };
         }
     }
-    /// Asserts the scope is a namespace Scope and removes the Decl from the namespace.
-    pub fn removeDecl(base: *Scope, child: *Decl) void {
-        switch (base.tag) {
-            .container => return @fieldParentPtr(Container, "base", base).removeDecl(child),
-            .zir_module => return @fieldParentPtr(ZIRModule, "base", base).removeDecl(child),
-            .file => unreachable,
-            .block => unreachable,
-            .gen_zir => unreachable,
-            .local_val => unreachable,
-            .local_ptr => unreachable,
-            .decl => unreachable,
-        }
-    }
-    /// Asserts the scope is a File or ZIRModule and deinitializes it, then deallocates it.
-    pub fn destroy(base: *Scope, gpa: *Allocator) void {
-        switch (base.tag) {
-            .file => {
-                const scope_file = @fieldParentPtr(File, "base", base);
-                scope_file.deinit(gpa);
-                gpa.destroy(scope_file);
-            },
-            .zir_module => {
-                const scope_zir_module = @fieldParentPtr(ZIRModule, "base", base);
-                scope_zir_module.deinit(gpa);
-                gpa.destroy(scope_zir_module);
-            },
-            .block => unreachable,
-            .gen_zir => unreachable,
-            .local_val => unreachable,
-            .local_ptr => unreachable,
-            .decl => unreachable,
-            .container => unreachable,
-        }
-    }
     fn name_hash_hash(x: NameHash) u32 {
         return @truncate(u32, @bitCast(u128, x));
     }
 @@ -563,14 +495,11 @@ pub const Scope = struct {
     }
     pub const Tag = enum {
-        /// .zir source code.
-        zir_module,
         /// .zig source code.
         file,
         /// struct, enum or union, every .file contains one of these.
         container,
         block,
-        decl,
         gen_zir,
         local_val,
         local_ptr,
 @@ -657,6 +586,11 @@ pub const Scope = struct {
             self.* = undefined;
         }
+        pub fn destroy(self: *File, gpa: *Allocator) void {
+            self.deinit(gpa);
+            gpa.destroy(self);
+        }
         pub fn dumpSrc(self: *File, src: usize) void {
             const loc = std.zig.findLineColumn(self.source.bytes, src);
             std.debug.print("{s}:{d}:{d}\n", .{ self.sub_file_path, loc.line + 1, loc.column + 1 });
 @@ -681,109 +615,6 @@ pub const Scope = struct {
         }
     };
-    pub const ZIRModule = struct {
-        pub const base_tag: Tag = .zir_module;
-        base: Scope = Scope{ .tag = base_tag },
-        /// Relative to the owning package's root_src_dir.
-        /// Reference to external memory, not owned by ZIRModule.
-        sub_file_path: []const u8,
-        source: union(enum) {
-            unloaded: void,
-            bytes: [:0]const u8,
-        },
-        contents: union {
-            not_available: void,
-            module: *zir.Module,
-        },
-        status: enum {
-            never_loaded,
-            unloaded_success,
-            unloaded_parse_failure,
-            unloaded_sema_failure,
-            loaded_sema_failure,
-            loaded_success,
-        },
-        /// Even though .zir files only have 1 module, this set is still needed
-        /// because of anonymous Decls, which can exist in the global set, but
-        /// not this one.
-        decls: ArrayListUnmanaged(*Decl),
-        pub fn unload(self: *ZIRModule, gpa: *Allocator) void {
-            switch (self.status) {
-                .never_loaded,
-                .unloaded_parse_failure,
-                .unloaded_sema_failure,
-                .unloaded_success,
-                => {},
-                .loaded_success => {
-                    self.contents.module.deinit(gpa);
-                    gpa.destroy(self.contents.module);
-                    self.contents = .{ .not_available = {} };
-                    self.status = .unloaded_success;
-                },
-                .loaded_sema_failure => {
-                    self.contents.module.deinit(gpa);
-                    gpa.destroy(self.contents.module);
-                    self.contents = .{ .not_available = {} };
-                    self.status = .unloaded_sema_failure;
-                },
-            }
-            switch (self.source) {
-                .bytes => |bytes| {
-                    gpa.free(bytes);
-                    self.source = .{ .unloaded = {} };
-                },
-                .unloaded => {},
-            }
-        }
-        pub fn deinit(self: *ZIRModule, gpa: *Allocator) void {
-            self.decls.deinit(gpa);
-            self.unload(gpa);
-            self.* = undefined;
-        }
-        pub fn removeDecl(self: *ZIRModule, child: *Decl) void {
-            for (self.decls.items) |item, i| {
-                if (item == child) {
-                    _ = self.decls.swapRemove(i);
-                    return;
-                }
-            }
-        }
-        pub fn dumpSrc(self: *ZIRModule, src: usize) void {
-            const loc = std.zig.findLineColumn(self.source.bytes, src);
-            std.debug.print("{s}:{d}:{d}\n", .{ self.sub_file_path, loc.line + 1, loc.column + 1 });
-        }
-        pub fn getSource(self: *ZIRModule, module: *Module) ![:0]const u8 {
-            switch (self.source) {
-                .unloaded => {
-                    const source = try module.root_pkg.root_src_directory.handle.readFileAllocOptions(
-                        module.gpa,
-                        self.sub_file_path,
-                        std.math.maxInt(u32),
-                        null,
-                        1,
-                        0,
-                    );
-                    self.source = .{ .bytes = source };
-                    return source;
-                },
-                .bytes => |bytes| return bytes,
-            }
-        }
-        pub fn fullyQualifiedNameHash(self: *ZIRModule, name: []const u8) NameHash {
-            // ZIR modules only have 1 file with all decls global in the same namespace.
-            return std.zig.hashSrc(name);
-        }
-    };
     /// This is a temporary structure, references to it are valid only
     /// during semantic analysis of the block.
     pub const Block = struct {
 @@ -794,9 +625,14 @@ pub const Scope = struct {
         /// Maps ZIR to TZIR. Shared to sub-blocks.
         inst_table: *InstTable,
         func: ?*Fn,
-        decl: *Decl,
+        /// When analyzing an inline function call, owner_decl is the Decl of the caller
+        /// and src_decl is the Decl of the callee.
+        /// This Decl owns the arena memory of this Block.
+        owner_decl: *Decl,
+        /// This Decl is the Decl according to the Zig source code corresponding to this Block.
+        src_decl: *Decl,
         instructions: ArrayListUnmanaged(*Inst),
-        /// Points to the arena allocator of DeclAnalysis
+        /// Points to the arena allocator of the Decl.
         arena: *Allocator,
         label: ?Label = null,
         inlining: ?*Inlining,
 @@ -845,21 +681,12 @@ pub const Scope = struct {
         }
     };
-    /// This is a temporary structure, references to it are valid only
-    /// during semantic analysis of the decl.
-    pub const DeclAnalysis = struct {
-        pub const base_tag: Tag = .decl;
-        base: Scope = Scope{ .tag = base_tag },
-        decl: *Decl,
-        arena: std.heap.ArenaAllocator,
-    };
     /// This is a temporary structure, references to it are valid only
     /// during semantic analysis of the decl.
     pub const GenZIR = struct {
         pub const base_tag: Tag = .gen_zir;
         base: Scope = Scope{ .tag = base_tag },
-        /// Parents can be: `GenZIR`, `ZIRModule`, `File`
+        /// Parents can be: `GenZIR`, `File`
         parent: *Scope,
         decl: *Decl,
         arena: *Allocator,
 @@ -905,11 +732,73 @@ pub const Scope = struct {
     };
 };
+/// This struct holds data necessary to construct API-facing `AllErrors.Message`.
+/// Its memory is managed with the general purpose allocator so that they
+/// can be created and destroyed in response to incremental updates.
+/// In some cases, the Scope.File could have been inferred from where the ErrorMsg
+/// is stored. For example, if it is stored in Module.failed_decls, then the Scope.File
+/// would be determined by the Decl Scope. However, the data structure contains the field
+/// anyway so that `ErrorMsg` can be reused for error notes, which may be in a different
+/// file than the parent error message. It also simplifies processing of error messages.
+pub const ErrorMsg = struct {
+    src_loc: SrcLoc,
+    msg: []const u8,
+    notes: []ErrorMsg = &.{},
+    pub fn create(
+        gpa: *Allocator,
+        src_loc: SrcLoc,
+        comptime format: []const u8,
+        args: anytype,
+    ) !*ErrorMsg {
+        const self = try gpa.create(ErrorMsg);
+        errdefer gpa.destroy(self);
+        self.* = try init(gpa, src_loc, format, args);
+        return self;
+    }
+    /// Assumes the ErrorMsg struct and msg were both allocated with `gpa`,
+    /// as well as all notes.
+    pub fn destroy(self: *ErrorMsg, gpa: *Allocator) void {
+        self.deinit(gpa);
+        gpa.destroy(self);
+    }
+    pub fn init(
+        gpa: *Allocator,
+        src_loc: SrcLoc,
+        comptime format: []const u8,
+        args: anytype,
+    ) !ErrorMsg {
+        return ErrorMsg{
+            .src_loc = src_loc,
+            .msg = try std.fmt.allocPrint(gpa, format, args),
+        };
+    }
+    pub fn deinit(self: *ErrorMsg, gpa: *Allocator) void {
+        for (self.notes) |*note| {
+            note.deinit(gpa);
+        }
+        gpa.free(self.notes);
+        gpa.free(self.msg);
+        self.* = undefined;
+    }
+};
+/// Canonical reference to a position within a source file.
+pub const SrcLoc = struct {
+    file_scope: *Scope.File,
+    byte_offset: usize,
+};
 pub const InnerError = error{ OutOfMemory, AnalysisFail };
 pub fn deinit(self: *Module) void {
     const gpa = self.gpa;
+    self.compile_log_text.deinit(gpa);
     self.zig_cache_artifact_directory.handle.close();
     self.deletion_set.deinit(gpa);
 @@ -939,9 +828,6 @@ pub fn deinit(self: *Module) void {
     }
     self.failed_exports.deinit(gpa);
-    for (self.compile_log_decls.items()) |*entry| {
-        entry.value.deinit(gpa);
-    }
     self.compile_log_decls.deinit(gpa);
     for (self.decl_exports.items()) |entry| {
 @@ -965,7 +851,7 @@ pub fn deinit(self: *Module) void {
     self.global_error_set.deinit(gpa);
     for (self.import_table.items()) |entry| {
-        entry.value.base.destroy(gpa);
+        entry.value.destroy(gpa);
     }
     self.import_table.deinit(gpa);
 }
 @@ -978,7 +864,7 @@ fn freeExportList(gpa: *Allocator, export_list: []*Export) void {
     gpa.free(export_list);
 }
-pub fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
+pub fn ensureDeclAnalyzed(mod: *Module, decl: *Decl) InnerError!void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -999,7 +885,7 @@ pub fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
             // The exports this Decl performs will be re-discovered, so we remove them here
             // prior to re-analysis.
-            self.deleteDeclExports(decl);
+            mod.deleteDeclExports(decl);
             // Dependencies will be re-discovered, so we remove them here prior to re-analysis.
             for (decl.dependencies.items()) |entry| {
                 const dep = entry.key;
 @@ -1008,7 +894,7 @@ pub fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
                     // We don't perform a deletion here, because this Decl or another one
                     // may end up referencing it before the update is complete.
                     dep.deletion_flag = true;
-                    try self.deletion_set.append(self.gpa, dep);
+                    try mod.deletion_set.append(mod.gpa, dep);
                 }
             }
             decl.dependencies.clearRetainingCapacity();
 @@ -1019,24 +905,21 @@ pub fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
         .unreferenced => false,
     };
-    const type_changed = if (self.root_scope.cast(Scope.ZIRModule)) |zir_module|
+    const type_changed = mod.astGenAndAnalyzeDecl(decl) catch |err| switch (err) {
-        try zir_sema.analyzeZirDecl(self, decl, zir_module.contents.module.decls[decl.src_index])
+        error.OutOfMemory => return error.OutOfMemory,
-    else
+        error.AnalysisFail => return error.AnalysisFail,
-        self.astGenAndAnalyzeDecl(decl) catch |err| switch (err) {
+        else => {
-            error.OutOfMemory => return error.OutOfMemory,
+            decl.analysis = .sema_failure_retryable;
-            error.AnalysisFail => return error.AnalysisFail,
+            try mod.failed_decls.ensureCapacity(mod.gpa, mod.failed_decls.items().len + 1);
-            else => {
+            mod.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
-                try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
+                mod.gpa,
-                self.failed_decls.putAssumeCapacityNoClobber(decl, try Compilation.ErrorMsg.create(
+                decl.srcLoc(),
-                    self.gpa,
+                "unable to analyze: {s}",
-                    decl.src(),
+                .{@errorName(err)},
-                    "unable to analyze: {s}",
+            ));
-                    .{@errorName(err)},
+            return error.AnalysisFail;
-                ));
+        },
-                decl.analysis = .sema_failure_retryable;
+    };
-                return error.AnalysisFail;
-            },
-        };
     if (subsequent_analysis) {
         // We may need to chase the dependants and re-analyze them.
 @@ -1055,8 +938,8 @@ pub fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
                     .codegen_failure,
                     .codegen_failure_retryable,
                     .complete,
-                    => if (dep.generation != self.generation) {
+                    => if (dep.generation != mod.generation) {
-                        try self.markOutdatedDecl(dep);
+                        try mod.markOutdatedDecl(dep);
                     },
                 }
             }
 @@ -1068,8 +951,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
     const tracy = trace(@src());
     defer tracy.end();
-    const container_scope = decl.scope.cast(Scope.Container).?;
+    const tree = try self.getAstTree(decl.container.file_scope);
-    const tree = try self.getAstTree(container_scope.file_scope);
     const ast_node = tree.root_node.decls()[decl.src_index];
     switch (ast_node.tag) {
         .FnProto => {
 @@ -1085,7 +967,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             var fn_type_scope: Scope.GenZIR = .{
                 .decl = decl,
                 .arena = &fn_type_scope_arena.allocator,
-                .parent = decl.scope,
+                .parent = &decl.container.base,
             };
             defer fn_type_scope.instructions.deinit(self.gpa);
 @@ -1197,7 +1079,8 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 .parent = null,
                 .inst_table = &inst_table,
                 .func = null,
-                .decl = decl,
+                .owner_decl = decl,
+                .src_decl = decl,
                 .instructions = .{},
                 .arena = &decl_arena.allocator,
                 .inlining = null,
 @@ -1242,12 +1125,12 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             const new_func = try decl_arena.allocator.create(Fn);
             const fn_payload = try decl_arena.allocator.create(Value.Payload.Function);
-            const fn_zir: zir.Module.Body = blk: {
+            const fn_zir: zir.Body = blk: {
                 // We put the ZIR inside the Decl arena.
                 var gen_scope: Scope.GenZIR = .{
                     .decl = decl,
                     .arena = &decl_arena.allocator,
-                    .parent = decl.scope,
+                    .parent = &decl.container.base,
                 };
                 defer gen_scope.instructions.deinit(self.gpa);
 @@ -1400,7 +1283,8 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 .parent = null,
                 .inst_table = &decl_inst_table,
                 .func = null,
-                .decl = decl,
+                .owner_decl = decl,
+                .src_decl = decl,
                 .instructions = .{},
                 .arena = &decl_arena.allocator,
                 .inlining = null,
 @@ -1444,7 +1328,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 var gen_scope: Scope.GenZIR = .{
                     .decl = decl,
                     .arena = &gen_scope_arena.allocator,
-                    .parent = decl.scope,
+                    .parent = &decl.container.base,
                 };
                 defer gen_scope.instructions.deinit(self.gpa);
 @@ -1472,7 +1356,8 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     .parent = null,
                     .inst_table = &var_inst_table,
                     .func = null,
-                    .decl = decl,
+                    .owner_decl = decl,
+                    .src_decl = decl,
                     .instructions = .{},
                     .arena = &gen_scope_arena.allocator,
                     .inlining = null,
 @@ -1503,7 +1388,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 var type_scope: Scope.GenZIR = .{
                     .decl = decl,
                     .arena = &type_scope_arena.allocator,
-                    .parent = decl.scope,
+                    .parent = &decl.container.base,
                 };
                 defer type_scope.instructions.deinit(self.gpa);
 @@ -1584,7 +1469,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             var gen_scope: Scope.GenZIR = .{
                 .decl = decl,
                 .arena = &analysis_arena.allocator,
-                .parent = decl.scope,
+                .parent = &decl.container.base,
             };
             defer gen_scope.instructions.deinit(self.gpa);
 @@ -1602,7 +1487,8 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 .parent = null,
                 .inst_table = &inst_table,
                 .func = null,
-                .decl = decl,
+                .owner_decl = decl,
+                .src_decl = decl,
                 .instructions = .{},
                 .arena = &analysis_arena.allocator,
                 .inlining = null,
 @@ -1632,44 +1518,6 @@ fn declareDeclDependency(self: *Module, depender: *Decl, dependee: *Decl) !void
     dependee.dependants.putAssumeCapacity(depender, {});
 }
-fn getSrcModule(self: *Module, root_scope: *Scope.ZIRModule) !*zir.Module {
-    switch (root_scope.status) {
-        .never_loaded, .unloaded_success => {
-            try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
-            const source = try root_scope.getSource(self);
-            var keep_zir_module = false;
-            const zir_module = try self.gpa.create(zir.Module);
-            defer if (!keep_zir_module) self.gpa.destroy(zir_module);
-            zir_module.* = try zir.parse(self.gpa, source);
-            defer if (!keep_zir_module) zir_module.deinit(self.gpa);
-            if (zir_module.error_msg) |src_err_msg| {
-                self.failed_files.putAssumeCapacityNoClobber(
-                    &root_scope.base,
-                    try Compilation.ErrorMsg.create(self.gpa, src_err_msg.byte_offset, "{s}", .{src_err_msg.msg}),
-                );
-                root_scope.status = .unloaded_parse_failure;
-                return error.AnalysisFail;
-            }
-            root_scope.status = .loaded_success;
-            root_scope.contents = .{ .module = zir_module };
-            keep_zir_module = true;
-            return zir_module;
-        },
-        .unloaded_parse_failure,
-        .unloaded_sema_failure,
-        => return error.AnalysisFail,
-        .loaded_success, .loaded_sema_failure => return root_scope.contents.module,
-    }
-}
 pub fn getAstTree(self: *Module, root_scope: *Scope.File) !*ast.Tree {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1691,10 +1539,13 @@ pub fn getAstTree(self: *Module, root_scope: *Scope.File) !*ast.Tree {
                 defer msg.deinit();
                 try parse_err.render(tree.token_ids, msg.writer());
-                const err_msg = try self.gpa.create(Compilation.ErrorMsg);
+                const err_msg = try self.gpa.create(ErrorMsg);
                 err_msg.* = .{
+                    .src_loc = .{
+                        .file_scope = root_scope,
+                        .byte_offset = tree.token_locs[parse_err.loc()].start,
+                    },
                     .msg = msg.toOwnedSlice(),
-                    .byte_offset = tree.token_locs[parse_err.loc()].start,
                 };
                 self.failed_files.putAssumeCapacityNoClobber(&root_scope.base, err_msg);
 @@ -1753,9 +1604,12 @@ pub fn analyzeContainer(self: *Module, container_scope: *Scope.Container) !void
                 decl.src_index = decl_i;
                 if (deleted_decls.swapRemove(decl) == null) {
                     decl.analysis = .sema_failure;
-                    const err_msg = try Compilation.ErrorMsg.create(self.gpa, tree.token_locs[name_tok].start, "redefinition of '{s}'", .{decl.name});
+                    const msg = try ErrorMsg.create(self.gpa, .{
-                    errdefer err_msg.destroy(self.gpa);
+                        .file_scope = container_scope.file_scope,
-                    try self.failed_decls.putNoClobber(self.gpa, decl, err_msg);
+                        .byte_offset = tree.token_locs[name_tok].start,
+                    }, "redefinition of '{s}'", .{decl.name});
+                    errdefer msg.destroy(self.gpa);
+                    try self.failed_decls.putNoClobber(self.gpa, decl, msg);
                 } else {
                     if (!srcHashEql(decl.contents_hash, contents_hash)) {
                         try self.markOutdatedDecl(decl);
 @@ -1795,7 +1649,10 @@ pub fn analyzeContainer(self: *Module, container_scope: *Scope.Container) !void
                 decl.src_index = decl_i;
                 if (deleted_decls.swapRemove(decl) == null) {
                     decl.analysis = .sema_failure;
-                    const err_msg = try Compilation.ErrorMsg.create(self.gpa, name_loc.start, "redefinition of '{s}'", .{decl.name});
+                    const err_msg = try ErrorMsg.create(self.gpa, .{
+                        .file_scope = container_scope.file_scope,
+                        .byte_offset = name_loc.start,
+                    }, "redefinition of '{s}'", .{decl.name});
                     errdefer err_msg.destroy(self.gpa);
                     try self.failed_decls.putNoClobber(self.gpa, decl, err_msg);
                 } else if (!srcHashEql(decl.contents_hash, contents_hash)) {
 @@ -1840,65 +1697,12 @@ pub fn analyzeContainer(self: *Module, container_scope: *Scope.Container) !void
     }
 }
-pub fn analyzeRootZIRModule(self: *Module, root_scope: *Scope.ZIRModule) !void {
-    // We may be analyzing it for the first time, or this may be
-    // an incremental update. This code handles both cases.
-    const src_module = try self.getSrcModule(root_scope);
-    try self.comp.work_queue.ensureUnusedCapacity(src_module.decls.len);
-    try root_scope.decls.ensureCapacity(self.gpa, src_module.decls.len);
-    var exports_to_resolve = std.ArrayList(*zir.Decl).init(self.gpa);
-    defer exports_to_resolve.deinit();
-    // Keep track of the decls that we expect to see in this file so that
-    // we know which ones have been deleted.
-    var deleted_decls = std.AutoArrayHashMap(*Decl, void).init(self.gpa);
-    defer deleted_decls.deinit();
-    try deleted_decls.ensureCapacity(self.decl_table.items().len);
-    for (self.decl_table.items()) |entry| {
-        deleted_decls.putAssumeCapacityNoClobber(entry.value, {});
-    }
-    for (src_module.decls) |src_decl, decl_i| {
-        const name_hash = root_scope.fullyQualifiedNameHash(src_decl.name);
-        if (self.decl_table.get(name_hash)) |decl| {
-            deleted_decls.removeAssertDiscard(decl);
-            if (!srcHashEql(src_decl.contents_hash, decl.contents_hash)) {
-                try self.markOutdatedDecl(decl);
-                decl.contents_hash = src_decl.contents_hash;
-            }
-        } else {
-            const new_decl = try self.createNewDecl(
-                &root_scope.base,
-                src_decl.name,
-                decl_i,
-                name_hash,
-                src_decl.contents_hash,
-            );
-            root_scope.decls.appendAssumeCapacity(new_decl);
-            if (src_decl.inst.cast(zir.Inst.Export)) |export_inst| {
-                try exports_to_resolve.append(src_decl);
-            }
-        }
-    }
-    for (exports_to_resolve.items) |export_decl| {
-        _ = try zir_sema.resolveZirDecl(self, &root_scope.base, export_decl);
-    }
-    // Handle explicitly deleted decls from the source code. Not to be confused
-    // with when we delete decls because they are no longer referenced.
-    for (deleted_decls.items()) |entry| {
-        log.debug("noticed '{s}' deleted from source\n", .{entry.key.name});
-        try self.deleteDecl(entry.key);
-    }
-}
 pub fn deleteDecl(self: *Module, decl: *Decl) !void {
     try self.deletion_set.ensureCapacity(self.gpa, self.deletion_set.items.len + decl.dependencies.items().len);
     // Remove from the namespace it resides in. In the case of an anonymous Decl it will
     // not be present in the set, and this does nothing.
-    decl.scope.removeDecl(decl);
+    decl.container.removeDecl(decl);
     log.debug("deleting decl '{s}'\n", .{decl.name});
     const name_hash = decl.fullyQualifiedNameHash();
 @@ -1929,9 +1733,7 @@ pub fn deleteDecl(self: *Module, decl: *Decl) !void {
     if (self.emit_h_failed_decls.swapRemove(decl)) |entry| {
         entry.value.destroy(self.gpa);
     }
-    if (self.compile_log_decls.swapRemove(decl)) |*entry| {
+    _ = self.compile_log_decls.swapRemove(decl);
-        entry.value.deinit(self.gpa);
-    }
     self.deleteDeclExports(decl);
     self.comp.bin_file.freeDecl(decl);
 @@ -1993,7 +1795,8 @@ pub fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
         .parent = null,
         .inst_table = &inst_table,
         .func = func,
-        .decl = decl,
+        .owner_decl = decl,
+        .src_decl = decl,
         .instructions = .{},
         .arena = &arena.allocator,
         .inlining = null,
 @@ -2022,9 +1825,7 @@ fn markOutdatedDecl(self: *Module, decl: *Decl) !void {
     if (self.emit_h_failed_decls.swapRemove(decl)) |entry| {
         entry.value.destroy(self.gpa);
     }
-    if (self.compile_log_decls.swapRemove(decl)) |*entry| {
+    _ = self.compile_log_decls.swapRemove(decl);
-        entry.value.deinit(self.gpa);
-    }
     decl.analysis = .outdated;
 }
 @@ -2046,7 +1847,7 @@ fn allocateNewDecl(
     new_decl.* = .{
         .name = "",
-        .scope = scope.namespace(),
+        .container = scope.namespace(),
         .src_index = src_index,
         .typed_value = .{ .never_succeeded = {} },
         .analysis = .unreferenced,
 @@ -2129,34 +1930,34 @@ pub fn resolveDefinedValue(self: *Module, scope: *Scope, base: *Inst) !?Value {
 }
 pub fn analyzeExport(
-    self: *Module,
+    mod: *Module,
     scope: *Scope,
     src: usize,
     borrowed_symbol_name: []const u8,
     exported_decl: *Decl,
 ) !void {
-    try self.ensureDeclAnalyzed(exported_decl);
+    try mod.ensureDeclAnalyzed(exported_decl);
     const typed_value = exported_decl.typed_value.most_recent.typed_value;
     switch (typed_value.ty.zigTypeTag()) {
         .Fn => {},
-        else => return self.fail(scope, src, "unable to export type '{}'", .{typed_value.ty}),
+        else => return mod.fail(scope, src, "unable to export type '{}'", .{typed_value.ty}),
     }
-    try self.decl_exports.ensureCapacity(self.gpa, self.decl_exports.items().len + 1);
+    try mod.decl_exports.ensureCapacity(mod.gpa, mod.decl_exports.items().len + 1);
-    try self.export_owners.ensureCapacity(self.gpa, self.export_owners.items().len + 1);
+    try mod.export_owners.ensureCapacity(mod.gpa, mod.export_owners.items().len + 1);
-    const new_export = try self.gpa.create(Export);
+    const new_export = try mod.gpa.create(Export);
-    errdefer self.gpa.destroy(new_export);
+    errdefer mod.gpa.destroy(new_export);
-    const symbol_name = try self.gpa.dupe(u8, borrowed_symbol_name);
+    const symbol_name = try mod.gpa.dupe(u8, borrowed_symbol_name);
-    errdefer self.gpa.free(symbol_name);
+    errdefer mod.gpa.free(symbol_name);
-    const owner_decl = scope.decl().?;
+    const owner_decl = scope.ownerDecl().?;
     new_export.* = .{
         .options = .{ .name = symbol_name },
         .src = src,
-        .link = switch (self.comp.bin_file.tag) {
+        .link = switch (mod.comp.bin_file.tag) {
             .coff => .{ .coff = {} },
             .elf => .{ .elf = link.File.Elf.Export{} },
             .macho => .{ .macho = link.File.MachO.Export{} },
 @@ -2169,48 +1970,53 @@ pub fn analyzeExport(
     };
     // Add to export_owners table.
-    const eo_gop = self.export_owners.getOrPutAssumeCapacity(owner_decl);
+    const eo_gop = mod.export_owners.getOrPutAssumeCapacity(owner_decl);
     if (!eo_gop.found_existing) {
         eo_gop.entry.value = &[0]*Export{};
     }
-    eo_gop.entry.value = try self.gpa.realloc(eo_gop.entry.value, eo_gop.entry.value.len + 1);
+    eo_gop.entry.value = try mod.gpa.realloc(eo_gop.entry.value, eo_gop.entry.value.len + 1);
     eo_gop.entry.value[eo_gop.entry.value.len - 1] = new_export;
-    errdefer eo_gop.entry.value = self.gpa.shrink(eo_gop.entry.value, eo_gop.entry.value.len - 1);
+    errdefer eo_gop.entry.value = mod.gpa.shrink(eo_gop.entry.value, eo_gop.entry.value.len - 1);
     // Add to exported_decl table.
-    const de_gop = self.decl_exports.getOrPutAssumeCapacity(exported_decl);
+    const de_gop = mod.decl_exports.getOrPutAssumeCapacity(exported_decl);
     if (!de_gop.found_existing) {
         de_gop.entry.value = &[0]*Export{};
     }
-    de_gop.entry.value = try self.gpa.realloc(de_gop.entry.value, de_gop.entry.value.len + 1);
+    de_gop.entry.value = try mod.gpa.realloc(de_gop.entry.value, de_gop.entry.value.len + 1);
     de_gop.entry.value[de_gop.entry.value.len - 1] = new_export;
-    errdefer de_gop.entry.value = self.gpa.shrink(de_gop.entry.value, de_gop.entry.value.len - 1);
+    errdefer de_gop.entry.value = mod.gpa.shrink(de_gop.entry.value, de_gop.entry.value.len - 1);
-    if (self.symbol_exports.get(symbol_name)) |_| {
+    if (mod.symbol_exports.get(symbol_name)) |other_export| {
-        try self.failed_exports.ensureCapacity(self.gpa, self.failed_exports.items().len + 1);
+        new_export.status = .failed_retryable;
-        self.failed_exports.putAssumeCapacityNoClobber(new_export, try Compilation.ErrorMsg.create(
+        try mod.failed_exports.ensureCapacity(mod.gpa, mod.failed_exports.items().len + 1);
-            self.gpa,
+        const msg = try mod.errMsg(
+            scope,
             src,
             "exported symbol collision: {s}",
             .{symbol_name},
-        ));
+        );
-        // TODO: add a note
+        errdefer msg.destroy(mod.gpa);
+        try mod.errNote(
+            &other_export.owner_decl.container.base,
+            other_export.src,
+            msg,
+            "other symbol here",
+            .{},
+        );
+        mod.failed_exports.putAssumeCapacityNoClobber(new_export, msg);
         new_export.status = .failed;
         return;
     }
-    try self.symbol_exports.putNoClobber(self.gpa, symbol_name, new_export);
+    try mod.symbol_exports.putNoClobber(mod.gpa, symbol_name, new_export);
-    self.comp.bin_file.updateDeclExports(self, exported_decl, de_gop.entry.value) catch |err| switch (err) {
+    mod.comp.bin_file.updateDeclExports(mod, exported_decl, de_gop.entry.value) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         else => {
-            try self.failed_exports.ensureCapacity(self.gpa, self.failed_exports.items().len + 1);
-            self.failed_exports.putAssumeCapacityNoClobber(new_export, try Compilation.ErrorMsg.create(
-                self.gpa,
-                src,
-                "unable to export: {s}",
-                .{@errorName(err)},
-            ));
             new_export.status = .failed_retryable;
+            try mod.failed_exports.ensureCapacity(mod.gpa, mod.failed_exports.items().len + 1);
+            const msg = try mod.errMsg(scope, src, "unable to export: {s}", .{@errorName(err)});
+            mod.failed_exports.putAssumeCapacityNoClobber(new_export, msg);
         },
     };
 }
 @@ -2476,7 +2282,7 @@ pub fn createAnonymousDecl(
     typed_value: TypedValue,
 ) !*Decl {
     const name_index = self.getNextAnonNameIndex();
-    const scope_decl = scope.decl().?;
+    const scope_decl = scope.ownerDecl().?;
     const name = try std.fmt.allocPrint(self.gpa, "{s}__anon_{d}", .{ scope_decl.name, name_index });
     defer self.gpa.free(name);
     const name_hash = scope.namespace().fullyQualifiedNameHash(name);
 @@ -2512,7 +2318,7 @@ pub fn createContainerDecl(
     decl_arena: *std.heap.ArenaAllocator,
     typed_value: TypedValue,
 ) !*Decl {
-    const scope_decl = scope.decl().?;
+    const scope_decl = scope.ownerDecl().?;
     const name = try self.getAnonTypeName(scope, base_token);
     defer self.gpa.free(name);
     const name_hash = scope.namespace().fullyQualifiedNameHash(name);
 @@ -2558,14 +2364,14 @@ pub fn lookupDeclName(self: *Module, scope: *Scope, ident_name: []const u8) ?*De
 }
 pub fn analyzeDeclRef(self: *Module, scope: *Scope, src: usize, decl: *Decl) InnerError!*Inst {
-    const scope_decl = scope.decl().?;
+    const scope_decl = scope.ownerDecl().?;
     try self.declareDeclDependency(scope_decl, decl);
     self.ensureDeclAnalyzed(decl) catch |err| {
         if (scope.cast(Scope.Block)) |block| {
             if (block.func) |func| {
                 func.state = .dependency_failure;
             } else {
-                block.decl.analysis = .dependency_failure;
+                block.owner_decl.analysis = .dependency_failure;
             }
         } else {
             scope_decl.analysis = .dependency_failure;
 @@ -3217,10 +3023,51 @@ fn coerceArrayPtrToMany(self: *Module, scope: *Scope, dest_type: Type, inst: *In
     return self.fail(scope, inst.src, "TODO implement coerceArrayPtrToMany runtime instruction", .{});
 }
-pub fn fail(self: *Module, scope: *Scope, src: usize, comptime format: []const u8, args: anytype) InnerError {
+/// We don't return a pointer to the new error note because the pointer
-    @setCold(true);
+/// becomes invalid when you add another one.
-    const err_msg = try Compilation.ErrorMsg.create(self.gpa, src, format, args);
+pub fn errNote(
-    return self.failWithOwnedErrorMsg(scope, src, err_msg);
+    mod: *Module,
+    scope: *Scope,
+    src: usize,
+    parent: *ErrorMsg,
+    comptime format: []const u8,
+    args: anytype,
+) error{OutOfMemory}!void {
+    const msg = try std.fmt.allocPrint(mod.gpa, format, args);
+    errdefer mod.gpa.free(msg);
+    parent.notes = try mod.gpa.realloc(parent.notes, parent.notes.len + 1);
+    parent.notes[parent.notes.len - 1] = .{
+        .src_loc = .{
+            .file_scope = scope.getFileScope(),
+            .byte_offset = src,
+        },
+        .msg = msg,
+    };
+}
+pub fn errMsg(
+    mod: *Module,
+    scope: *Scope,
+    src_byte_offset: usize,
+    comptime format: []const u8,
+    args: anytype,
+) error{OutOfMemory}!*ErrorMsg {
+    return ErrorMsg.create(mod.gpa, .{
+        .file_scope = scope.getFileScope(),
+        .byte_offset = src_byte_offset,
+    }, format, args);
+}
+pub fn fail(
+    mod: *Module,
+    scope: *Scope,
+    src_byte_offset: usize,
+    comptime format: []const u8,
+    args: anytype,
+) InnerError {
+    const err_msg = try mod.errMsg(scope, src_byte_offset, format, args);
+    return mod.failWithOwnedErrorMsg(scope, err_msg);
 }
 pub fn failTok(
 @@ -3230,7 +3077,6 @@ pub fn failTok(
     comptime format: []const u8,
     args: anytype,
 ) InnerError {
-    @setCold(true);
     const src = scope.tree().token_locs[token_index].start;
     return self.fail(scope, src, format, args);
 }
 @@ -3242,80 +3088,36 @@ pub fn failNode(
     comptime format: []const u8,
     args: anytype,
 ) InnerError {
-    @setCold(true);
     const src = scope.tree().token_locs[ast_node.firstToken()].start;
     return self.fail(scope, src, format, args);
 }
-fn addCompileLog(self: *Module, decl: *Decl, src: usize) error{OutOfMemory}!void {
+pub fn failWithOwnedErrorMsg(self: *Module, scope: *Scope, err_msg: *ErrorMsg) InnerError {
-    const entry = try self.compile_log_decls.getOrPutValue(self.gpa, decl, .{});
+    @setCold(true);
-    try entry.value.append(self.gpa, src);
-}
-pub fn failCompileLog(
-    self: *Module,
-    scope: *Scope,
-    src: usize,
-) InnerError!void {
-    switch (scope.tag) {
-        .decl => {
-            const decl = scope.cast(Scope.DeclAnalysis).?.decl;
-            try self.addCompileLog(decl, src);
-        },
-        .block => {
-            const block = scope.cast(Scope.Block).?;
-            try self.addCompileLog(block.decl, src);
-        },
-        .gen_zir => {
-            const gen_zir = scope.cast(Scope.GenZIR).?;
-            try self.addCompileLog(gen_zir.decl, src);
-        },
-        .local_val => {
-            const gen_zir = scope.cast(Scope.LocalVal).?.gen_zir;
-            try self.addCompileLog(gen_zir.decl, src);
-        },
-        .local_ptr => {
-            const gen_zir = scope.cast(Scope.LocalPtr).?.gen_zir;
-            try self.addCompileLog(gen_zir.decl, src);
-        },
-        .zir_module,
-        .file,
-        .container,
-        => unreachable,
-    }
-}
-fn failWithOwnedErrorMsg(self: *Module, scope: *Scope, src: usize, err_msg: *Compilation.ErrorMsg) InnerError {
     {
         errdefer err_msg.destroy(self.gpa);
         try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
         try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
     }
     switch (scope.tag) {
-        .decl => {
-            const decl = scope.cast(Scope.DeclAnalysis).?.decl;
-            decl.analysis = .sema_failure;
-            decl.generation = self.generation;
-            self.failed_decls.putAssumeCapacityNoClobber(decl, err_msg);
-        },
         .block => {
             const block = scope.cast(Scope.Block).?;
             if (block.inlining) |inlining| {
                 if (inlining.shared.caller) |func| {
                     func.state = .sema_failure;
                 } else {
-                    block.decl.analysis = .sema_failure;
+                    block.owner_decl.analysis = .sema_failure;
-                    block.decl.generation = self.generation;
+                    block.owner_decl.generation = self.generation;
                 }
             } else {
                 if (block.func) |func| {
                     func.state = .sema_failure;
                 } else {
-                    block.decl.analysis = .sema_failure;
+                    block.owner_decl.analysis = .sema_failure;
-                    block.decl.generation = self.generation;
+                    block.owner_decl.generation = self.generation;
                 }
             }
-            self.failed_decls.putAssumeCapacityNoClobber(block.decl, err_msg);
+            self.failed_decls.putAssumeCapacityNoClobber(block.owner_decl, err_msg);
         },
         .gen_zir => {
             const gen_zir = scope.cast(Scope.GenZIR).?;
 @@ -3335,11 +3137,6 @@ fn failWithOwnedErrorMsg(self: *Module, scope: *Scope, src: usize, err_msg: *Com
             gen_zir.decl.generation = self.generation;
             self.failed_decls.putAssumeCapacityNoClobber(gen_zir.decl, err_msg);
         },
-        .zir_module => {
-            const zir_module = scope.cast(Scope.ZIRModule).?;
-            zir_module.status = .loaded_sema_failure;
-            self.failed_files.putAssumeCapacityNoClobber(scope, err_msg);
-        },
         .file => unreachable,
         .container => unreachable,
     }
 @@ -3671,7 +3468,8 @@ pub fn addSafetyCheck(mod: *Module, parent_block: *Scope.Block, ok: *Inst, panic
         .parent = parent_block,
         .inst_table = parent_block.inst_table,
         .func = parent_block.func,
-        .decl = parent_block.decl,
+        .owner_decl = parent_block.owner_decl,
+        .src_decl = parent_block.src_decl,
         .instructions = .{},
         .arena = parent_block.arena,
         .inlining = parent_block.inlining,

src/astgen.zig+56-21

 @@ -318,7 +318,7 @@ pub fn comptimeExpr(mod: *Module, parent_scope: *Scope, rl: ResultLoc, node: *as
     // Make a scope to collect generated instructions in the sub-expression.
     var block_scope: Scope.GenZIR = .{
         .parent = parent_scope,
-        .decl = parent_scope.decl().?,
+        .decl = parent_scope.ownerDecl().?,
         .arena = parent_scope.arena(),
         .instructions = .{},
     };
 @@ -474,7 +474,7 @@ fn labeledBlockExpr(
     var block_scope: Scope.GenZIR = .{
         .parent = parent_scope,
-        .decl = parent_scope.decl().?,
+        .decl = parent_scope.ownerDecl().?,
         .arena = gen_zir.arena,
         .instructions = .{},
         .break_result_loc = rl,
 @@ -899,7 +899,7 @@ fn containerDecl(mod: *Module, scope: *Scope, rl: ResultLoc, node: *ast.Node.Con
     var gen_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1028,7 +1028,13 @@ fn containerDecl(mod: *Module, scope: *Scope, rl: ResultLoc, node: *ast.Node.Con
         .ty = Type.initTag(.type),
         .val = val,
     });
-    return rlWrapPtr(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclValInModule, .{ .decl = decl }, .{}));
+    if (rl == .ref) {
+        return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});
+    } else {
+        return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{
+            .decl = decl,
+        }, .{}));
+    }
 }
 fn errorSetDecl(mod: *Module, scope: *Scope, rl: ResultLoc, node: *ast.Node.ErrorSetDecl) InnerError!*zir.Inst {
 @@ -1084,7 +1090,7 @@ fn orelseCatchExpr(
     var block_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1266,7 +1272,7 @@ fn boolBinOp(
     var block_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1412,7 +1418,7 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
     }
     var block_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1513,7 +1519,7 @@ fn whileExpr(mod: *Module, scope: *Scope, rl: ResultLoc, while_node: *ast.Node.W
     var expr_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1649,7 +1655,7 @@ fn forExpr(mod: *Module, scope: *Scope, rl: ResultLoc, for_node: *ast.Node.For)
     var for_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1843,7 +1849,7 @@ fn getRangeNode(node: *ast.Node) ?*ast.Node.SimpleInfixOp {
 fn switchExpr(mod: *Module, scope: *Scope, rl: ResultLoc, switch_node: *ast.Node.Switch) InnerError!*zir.Inst {
     var block_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1885,7 +1891,7 @@ fn switchExpr(mod: *Module, scope: *Scope, rl: ResultLoc, switch_node: *ast.Node
     var item_scope: Scope.GenZIR = .{
         .parent = scope,
-        .decl = scope.decl().?,
+        .decl = scope.ownerDecl().?,
         .arena = scope.arena(),
         .instructions = .{},
     };
 @@ -1922,8 +1928,15 @@ fn switchExpr(mod: *Module, scope: *Scope, rl: ResultLoc, switch_node: *ast.Node
         // Check for else/_ prong, those are handled last.
         if (case.items_len == 1 and case.items()[0].tag == .SwitchElse) {
             if (else_src) |src| {
-                return mod.fail(scope, case_src, "multiple else prongs in switch expression", .{});
+                const msg = try mod.errMsg(
-                // TODO notes "previous else prong is here"
+                    scope,
+                    case_src,
+                    "multiple else prongs in switch expression",
+                    .{},
+                );
+                errdefer msg.destroy(mod.gpa);
+                try mod.errNote(scope, src, msg, "previous else prong is here", .{});
+                return mod.failWithOwnedErrorMsg(scope, msg);
             }
             else_src = case_src;
             special_case = case;
 @@ -1932,8 +1945,15 @@ fn switchExpr(mod: *Module, scope: *Scope, rl: ResultLoc, switch_node: *ast.Node
             mem.eql(u8, tree.tokenSlice(case.items()[0].firstToken()), "_"))
         {
             if (underscore_src) |src| {
-                return mod.fail(scope, case_src, "multiple '_' prongs in switch expression", .{});
+                const msg = try mod.errMsg(
-                // TODO notes "previous '_' prong is here"
+                    scope,
+                    case_src,
+                    "multiple '_' prongs in switch expression",
+                    .{},
+                );
+                errdefer msg.destroy(mod.gpa);
+                try mod.errNote(scope, src, msg, "previous '_' prong is here", .{});
+                return mod.failWithOwnedErrorMsg(scope, msg);
             }
             underscore_src = case_src;
             special_case = case;
 @@ -1942,9 +1962,16 @@ fn switchExpr(mod: *Module, scope: *Scope, rl: ResultLoc, switch_node: *ast.Node
         if (else_src) |some_else| {
             if (underscore_src) |some_underscore| {
-                return mod.fail(scope, switch_src, "else and '_' prong in switch expression", .{});
+                const msg = try mod.errMsg(
-                // TODO notes "else prong is here"
+                    scope,
-                // TODO notes "'_' prong is here"
+                    switch_src,
+                    "else and '_' prong in switch expression",
+                    .{},
+                );
+                errdefer msg.destroy(mod.gpa);
+                try mod.errNote(scope, some_else, msg, "else prong is here", .{});
+                try mod.errNote(scope, some_underscore, msg, "'_' prong is here", .{});
+                return mod.failWithOwnedErrorMsg(scope, msg);
             }
         }
 @@ -2162,7 +2189,13 @@ fn identifier(mod: *Module, scope: *Scope, rl: ResultLoc, ident: *ast.Node.OneTo
     }
     if (mod.lookupDeclName(scope, ident_name)) |decl| {
-        return rlWrapPtr(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclValInModule, .{ .decl = decl }, .{}));
+        if (rl == .ref) {
+            return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});
+        } else {
+            return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{
+                .decl = decl,
+            }, .{}));
+        }
     }
     return mod.failNode(scope, &ident.base, "use of undeclared identifier '{s}'", .{ident_name});
 @@ -2927,6 +2960,8 @@ fn rlWrapVoid(mod: *Module, scope: *Scope, rl: ResultLoc, node: *ast.Node, resul
     return rlWrap(mod, scope, rl, void_inst);
 }
+/// TODO go over all the callsites and see where we can introduce "by-value" ZIR instructions
+/// to save ZIR memory. For example, see DeclVal vs DeclRef.
 fn rlWrapPtr(mod: *Module, scope: *Scope, rl: ResultLoc, ptr: *zir.Inst) InnerError!*zir.Inst {
     if (rl == .ref) return ptr;
 @@ -3032,7 +3067,7 @@ pub fn addZIRInstBlock(
     scope: *Scope,
     src: usize,
     tag: zir.Inst.Tag,
-    body: zir.Module.Body,
+    body: zir.Body,
 ) !*zir.Inst.Block {
     const gen_zir = scope.getGenZIR();
     try gen_zir.instructions.ensureCapacity(mod.gpa, gen_zir.instructions.items.len + 1);
 @@ -3070,7 +3105,7 @@ pub fn addZIRInstConst(mod: *Module, scope: *Scope, src: usize, typed_value: Typ
 }
 /// TODO The existence of this function is a workaround for a bug in stage1.
-pub fn addZIRInstLoop(mod: *Module, scope: *Scope, src: usize, body: zir.Module.Body) !*zir.Inst.Loop {
+pub fn addZIRInstLoop(mod: *Module, scope: *Scope, src: usize, body: zir.Body) !*zir.Inst.Loop {
     const P = std.meta.fieldInfo(zir.Inst.Loop, .positionals).field_type;
     return addZIRInstSpecial(mod, scope, src, zir.Inst.Loop, P{ .body = body }, .{});
 }

src/codegen.zig+87-79

 @@ -9,7 +9,7 @@ const TypedValue = @import("TypedValue.zig");
 const link = @import("link.zig");
 const Module = @import("Module.zig");
 const Compilation = @import("Compilation.zig");
-const ErrorMsg = Compilation.ErrorMsg;
+const ErrorMsg = Module.ErrorMsg;
 const Target = std.Target;
 const Allocator = mem.Allocator;
 const trace = @import("tracy.zig").trace;
 @@ -74,7 +74,7 @@ pub const DebugInfoOutput = union(enum) {
 pub fn generateSymbol(
     bin_file: *link.File,
-    src: usize,
+    src_loc: Module.SrcLoc,
     typed_value: TypedValue,
     code: *std.ArrayList(u8),
     debug_output: DebugInfoOutput,
 @@ -87,56 +87,56 @@ pub fn generateSymbol(
             switch (bin_file.options.target.cpu.arch) {
                 .wasm32 => unreachable, // has its own code path
                 .wasm64 => unreachable, // has its own code path
-                .arm => return Function(.arm).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .arm => return Function(.arm).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .armeb => return Function(.armeb).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .armeb => return Function(.armeb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .aarch64 => return Function(.aarch64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .aarch64 => return Function(.aarch64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .aarch64_be => return Function(.aarch64_be).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .aarch64_be => return Function(.aarch64_be).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .aarch64_32 => return Function(.aarch64_32).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .aarch64_32 => return Function(.aarch64_32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.arc => return Function(.arc).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.arc => return Function(.arc).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.avr => return Function(.avr).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.avr => return Function(.avr).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.bpfel => return Function(.bpfel).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.bpfel => return Function(.bpfel).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.bpfeb => return Function(.bpfeb).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.bpfeb => return Function(.bpfeb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.hexagon => return Function(.hexagon).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.hexagon => return Function(.hexagon).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.mips => return Function(.mips).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.mips => return Function(.mips).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.mipsel => return Function(.mipsel).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.mipsel => return Function(.mipsel).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.mips64 => return Function(.mips64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.mips64 => return Function(.mips64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.mips64el => return Function(.mips64el).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.mips64el => return Function(.mips64el).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.msp430 => return Function(.msp430).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.msp430 => return Function(.msp430).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.powerpc => return Function(.powerpc).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.powerpc => return Function(.powerpc).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.powerpc64 => return Function(.powerpc64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.powerpc64 => return Function(.powerpc64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.powerpc64le => return Function(.powerpc64le).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.powerpc64le => return Function(.powerpc64le).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.r600 => return Function(.r600).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.r600 => return Function(.r600).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.amdgcn => return Function(.amdgcn).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.amdgcn => return Function(.amdgcn).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.riscv32 => return Function(.riscv32).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.riscv32 => return Function(.riscv32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .riscv64 => return Function(.riscv64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .riscv64 => return Function(.riscv64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.sparc => return Function(.sparc).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.sparc => return Function(.sparc).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.sparcv9 => return Function(.sparcv9).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.sparcv9 => return Function(.sparcv9).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.sparcel => return Function(.sparcel).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.sparcel => return Function(.sparcel).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.s390x => return Function(.s390x).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.s390x => return Function(.s390x).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .spu_2 => return Function(.spu_2).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .spu_2 => return Function(.spu_2).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.tce => return Function(.tce).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.tce => return Function(.tce).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.tcele => return Function(.tcele).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.tcele => return Function(.tcele).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.thumb => return Function(.thumb).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.thumb => return Function(.thumb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.thumbeb => return Function(.thumbeb).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.thumbeb => return Function(.thumbeb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.i386 => return Function(.i386).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.i386 => return Function(.i386).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                .x86_64 => return Function(.x86_64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                .x86_64 => return Function(.x86_64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.xcore => return Function(.xcore).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.xcore => return Function(.xcore).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.nvptx => return Function(.nvptx).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.nvptx => return Function(.nvptx).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.nvptx64 => return Function(.nvptx64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.nvptx64 => return Function(.nvptx64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.le32 => return Function(.le32).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.le32 => return Function(.le32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.le64 => return Function(.le64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.le64 => return Function(.le64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.amdil => return Function(.amdil).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.amdil => return Function(.amdil).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.amdil64 => return Function(.amdil64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.amdil64 => return Function(.amdil64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.hsail => return Function(.hsail).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.hsail => return Function(.hsail).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.hsail64 => return Function(.hsail64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.hsail64 => return Function(.hsail64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.spir => return Function(.spir).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.spir => return Function(.spir).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.spir64 => return Function(.spir64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.spir64 => return Function(.spir64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.kalimba => return Function(.kalimba).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.kalimba => return Function(.kalimba).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.shave => return Function(.shave).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.shave => return Function(.shave).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.lanai => return Function(.lanai).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.lanai => return Function(.lanai).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.renderscript32 => return Function(.renderscript32).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.renderscript32 => return Function(.renderscript32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.renderscript64 => return Function(.renderscript64).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.renderscript64 => return Function(.renderscript64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
-                //.ve => return Function(.ve).generateSymbol(bin_file, src, typed_value, code, debug_output),
+                //.ve => return Function(.ve).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),
                 else => @panic("Backend architectures that don't have good support yet are commented out, to improve compilation performance. If you are interested in one of these other backends feel free to uncomment them. Eventually these will be completed, but stage1 is slow and a memory hog."),
             }
         },
 @@ -147,7 +147,7 @@ pub fn generateSymbol(
                     try code.ensureCapacity(code.items.len + payload.data.len + 1);
                     code.appendSliceAssumeCapacity(payload.data);
                     const prev_len = code.items.len;
-                    switch (try generateSymbol(bin_file, src, .{
+                    switch (try generateSymbol(bin_file, src_loc, .{
                         .ty = typed_value.ty.elemType(),
                         .val = sentinel,
                     }, code, debug_output)) {
 @@ -165,7 +165,7 @@ pub fn generateSymbol(
             return Result{
                 .fail = try ErrorMsg.create(
                     bin_file.allocator,
-                    src,
+                    src_loc,
                     "TODO implement generateSymbol for more kinds of arrays",
                     .{},
                 ),
 @@ -200,7 +200,7 @@ pub fn generateSymbol(
             return Result{
                 .fail = try ErrorMsg.create(
                     bin_file.allocator,
-                    src,
+                    src_loc,
                     "TODO implement generateSymbol for pointer {}",
                     .{typed_value.val},
                 ),
 @@ -217,7 +217,7 @@ pub fn generateSymbol(
             return Result{
                 .fail = try ErrorMsg.create(
                     bin_file.allocator,
-                    src,
+                    src_loc,
                     "TODO implement generateSymbol for int type '{}'",
                     .{typed_value.ty},
                 ),
 @@ -227,7 +227,7 @@ pub fn generateSymbol(
             return Result{
                 .fail = try ErrorMsg.create(
                     bin_file.allocator,
-                    src,
+                    src_loc,
                     "TODO implement generateSymbol for type '{s}'",
                     .{@tagName(t)},
                 ),
 @@ -259,7 +259,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
         ret_mcv: MCValue,
         fn_type: Type,
         arg_index: usize,
-        src: usize,
+        src_loc: Module.SrcLoc,
         stack_align: u32,
         /// Byte offset within the source file.
 @@ -428,7 +428,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
         fn generateSymbol(
             bin_file: *link.File,
-            src: usize,
+            src_loc: Module.SrcLoc,
             typed_value: TypedValue,
             code: *std.ArrayList(u8),
             debug_output: DebugInfoOutput,
 @@ -450,19 +450,17 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             try branch_stack.append(.{});
             const src_data: struct { lbrace_src: usize, rbrace_src: usize, source: []const u8 } = blk: {
-                if (module_fn.owner_decl.scope.cast(Module.Scope.Container)) |container_scope| {
+                const container_scope = module_fn.owner_decl.container;
-                    const tree = container_scope.file_scope.contents.tree;
+                const tree = container_scope.file_scope.contents.tree;
-                    const fn_proto = tree.root_node.decls()[module_fn.owner_decl.src_index].castTag(.FnProto).?;
+                const fn_proto = tree.root_node.decls()[module_fn.owner_decl.src_index].castTag(.FnProto).?;
-                    const block = fn_proto.getBodyNode().?.castTag(.Block).?;
+                const block = fn_proto.getBodyNode().?.castTag(.Block).?;
-                    const lbrace_src = tree.token_locs[block.lbrace].start;
+                const lbrace_src = tree.token_locs[block.lbrace].start;
-                    const rbrace_src = tree.token_locs[block.rbrace].start;
+                const rbrace_src = tree.token_locs[block.rbrace].start;
-                    break :blk .{ .lbrace_src = lbrace_src, .rbrace_src = rbrace_src, .source = tree.source };
+                break :blk .{
-                } else if (module_fn.owner_decl.scope.cast(Module.Scope.ZIRModule)) |zir_module| {
+                    .lbrace_src = lbrace_src,
-                    const byte_off = zir_module.contents.module.decls[module_fn.owner_decl.src_index].inst.src;
+                    .rbrace_src = rbrace_src,
-                    break :blk .{ .lbrace_src = byte_off, .rbrace_src = byte_off, .source = zir_module.source.bytes };
+                    .source = tree.source,
-                } else {
+                };
-                    unreachable;
-                }
             };
             var function = Self{
 @@ -478,7 +476,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                 .fn_type = fn_type,
                 .arg_index = 0,
                 .branch_stack = &branch_stack,
-                .src = src,
+                .src_loc = src_loc,
                 .stack_align = undefined,
                 .prev_di_pc = 0,
                 .prev_di_src = src_data.lbrace_src,
 @@ -489,7 +487,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             defer function.stack.deinit(bin_file.allocator);
             defer function.exitlude_jump_relocs.deinit(bin_file.allocator);
-            var call_info = function.resolveCallingConventionValues(src, fn_type) catch |err| switch (err) {
+            var call_info = function.resolveCallingConventionValues(src_loc.byte_offset, fn_type) catch |err| switch (err) {
                 error.CodegenFail => return Result{ .fail = function.err_msg.? },
                 else => |e| return e,
             };
 @@ -536,12 +534,12 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                         const stack_end = self.max_end_stack;
                         if (stack_end > math.maxInt(i32))
-                            return self.fail(self.src, "too much stack used in call parameters", .{});
+                            return self.failSymbol("too much stack used in call parameters", .{});
                         const aligned_stack_end = mem.alignForward(stack_end, self.stack_align);
                         mem.writeIntLittle(u32, self.code.items[reloc_index..][0..4], @intCast(u32, aligned_stack_end));
                         if (self.code.items.len >= math.maxInt(i32)) {
-                            return self.fail(self.src, "unable to perform relocation: jump too far", .{});
+                            return self.failSymbol("unable to perform relocation: jump too far", .{});
                         }
                         if (self.exitlude_jump_relocs.items.len == 1) {
                             self.code.items.len -= 5;
 @@ -598,7 +596,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                         if (Instruction.Operand.fromU32(@intCast(u32, aligned_stack_end))) |op| {
                             writeInt(u32, self.code.items[backpatch_reloc..][0..4], Instruction.sub(.al, .sp, .sp, op).toU32());
                         } else {
-                            return self.fail(self.src, "TODO ARM: allow larger stacks", .{});
+                            return self.failSymbol("TODO ARM: allow larger stacks", .{});
                         }
                         try self.dbgSetEpilogueBegin();
 @@ -624,7 +622,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                                 if (math.cast(i26, amt)) |offset| {
                                     writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.b(.al, offset).toU32());
                                 } else |err| {
-                                    return self.fail(self.src, "exitlude jump is too large", .{});
+                                    return self.failSymbol("exitlude jump is too large", .{});
                                 }
                             }
                         }
 @@ -3678,7 +3676,17 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
         fn fail(self: *Self, src: usize, comptime format: []const u8, args: anytype) InnerError {
             @setCold(true);
             assert(self.err_msg == null);
-            self.err_msg = try ErrorMsg.create(self.bin_file.allocator, src, format, args);
+            self.err_msg = try ErrorMsg.create(self.bin_file.allocator, .{
+                .file_scope = self.src_loc.file_scope,
+                .byte_offset = src,
+            }, format, args);
+            return error.CodegenFail;
+        }
+        fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+            @setCold(true);
+            assert(self.err_msg == null);
+            self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);
             return error.CodegenFail;
         }

src/codegen/c.zig+5-2

 @@ -114,10 +114,13 @@ pub const DeclGen = struct {
     module: *Module,
     decl: *Decl,
     fwd_decl: std.ArrayList(u8),
-    error_msg: ?*Compilation.ErrorMsg,
+    error_msg: ?*Module.ErrorMsg,
     fn fail(dg: *DeclGen, src: usize, comptime format: []const u8, args: anytype) error{ AnalysisFail, OutOfMemory } {
-        dg.error_msg = try Compilation.ErrorMsg.create(dg.module.gpa, src, format, args);
+        dg.error_msg = try Module.ErrorMsg.create(dg.module.gpa, .{
+            .file_scope = dg.decl.getFileScope(),
+            .byte_offset = src,
+        }, format, args);
         return error.AnalysisFail;
     }

src/codegen/llvm.zig+11-2

...	@@ -148,7 +148,7 @@ pub const LLVMIRModule = struct {	...	@@ -148,7 +148,7 @@ pub const LLVMIRModule = struct {
148	object_path: []const u8,	148	object_path: []const u8,
149		149
150	gpa: *Allocator,	150	gpa: *Allocator,
151	err_msg: ?*Compilation.ErrorMsg = null,	151	err_msg: ?*Module.ErrorMsg = null,
152		152
153	// TODO: The fields below should really move into a different struct,	153	// TODO: The fields below should really move into a different struct,
154	// because they are only valid when generating a function	154	// because they are only valid when generating a function
...	@@ -177,6 +177,8 @@ pub const LLVMIRModule = struct {	...	@@ -177,6 +177,8 @@ pub const LLVMIRModule = struct {
177	break_vals: *BreakValues,	177	break_vals: *BreakValues,
178	}) = .{},	178	}) = .{},
179		179
		180	src_loc: Module.SrcLoc,
		181
180	const BreakBasicBlocks = std.ArrayListUnmanaged(*const llvm.BasicBlock);	182	const BreakBasicBlocks = std.ArrayListUnmanaged(*const llvm.BasicBlock);
181	const BreakValues = std.ArrayListUnmanaged(*const llvm.Value);	183	const BreakValues = std.ArrayListUnmanaged(*const llvm.Value);
182		184
...	@@ -254,6 +256,8 @@ pub const LLVMIRModule = struct {	...	@@ -254,6 +256,8 @@ pub const LLVMIRModule = struct {
254	.builder = builder,	256	.builder = builder,
255	.object_path = object_path,	257	.object_path = object_path,
256	.gpa = gpa,	258	.gpa = gpa,
		259	// TODO move this field into a struct that is only instantiated per gen() call
		260	.src_loc = undefined,
257	};	261	};
258	return self;	262	return self;
259	}	263	}
...	@@ -335,6 +339,8 @@ pub const LLVMIRModule = struct {	...	@@ -335,6 +339,8 @@ pub const LLVMIRModule = struct {
335	const typed_value = decl.typed_value.most_recent.typed_value;	339	const typed_value = decl.typed_value.most_recent.typed_value;
336	const src = decl.src();	340	const src = decl.src();
337		341
		342	self.src_loc = decl.srcLoc();
		343
338	log.debug("gen: {s} type: {}, value: {}", .{ decl.name, typed_value.ty, typed_value.val });	344	log.debug("gen: {s} type: {}, value: {}", .{ decl.name, typed_value.ty, typed_value.val });
339		345
340	if (typed_value.val.castTag(.function)) \|func_payload\| {	346	if (typed_value.val.castTag(.function)) \|func_payload\| {
...	@@ -853,7 +859,10 @@ pub const LLVMIRModule = struct {	...	@@ -853,7 +859,10 @@ pub const LLVMIRModule = struct {
853	pub fn fail(self: *LLVMIRModule, src: usize, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {	859	pub fn fail(self: *LLVMIRModule, src: usize, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
854	@setCold(true);	860	@setCold(true);
855	assert(self.err_msg == null);	861	assert(self.err_msg == null);
856	self.err_msg = try Compilation.ErrorMsg.create(self.gpa, src, format, args);	862	self.err_msg = try Module.ErrorMsg.create(self.gpa, .{
		863	.file_scope = self.src_loc.file_scope,
		864	.byte_offset = src,
		865	}, format, args);
857	return error.CodegenFail;	866	return error.CodegenFail;
858	}	867	}
859	};	868	};

src/link/Coff.zig+3-3

src/link/Elf.zig+12-21

 @@ -2189,22 +2189,14 @@ pub fn updateDecl(self: *Elf, module: *Module, decl: *Module.Decl) !void {
         try dbg_line_buffer.ensureCapacity(26);
         const line_off: u28 = blk: {
-            if (decl.scope.cast(Module.Scope.Container)) |container_scope| {
+            const tree = decl.container.file_scope.contents.tree;
-                const tree = container_scope.file_scope.contents.tree;
+            const file_ast_decls = tree.root_node.decls();
-                const file_ast_decls = tree.root_node.decls();
+            // TODO Look into improving the performance here by adding a token-index-to-line
-                // TODO Look into improving the performance here by adding a token-index-to-line
+            // lookup table. Currently this involves scanning over the source code for newlines.
-                // lookup table. Currently this involves scanning over the source code for newlines.
+            const fn_proto = file_ast_decls[decl.src_index].castTag(.FnProto).?;
-                const fn_proto = file_ast_decls[decl.src_index].castTag(.FnProto).?;
+            const block = fn_proto.getBodyNode().?.castTag(.Block).?;
-                const block = fn_proto.getBodyNode().?.castTag(.Block).?;
+            const line_delta = std.zig.lineDelta(tree.source, 0, tree.token_locs[block.lbrace].start);
-                const line_delta = std.zig.lineDelta(tree.source, 0, tree.token_locs[block.lbrace].start);
+            break :blk @intCast(u28, line_delta);
-                break :blk @intCast(u28, line_delta);
-            } else if (decl.scope.cast(Module.Scope.ZIRModule)) |zir_module| {
-                const byte_off = zir_module.contents.module.decls[decl.src_index].inst.src;
-                const line_delta = std.zig.lineDelta(zir_module.source.bytes, 0, byte_off);
-                break :blk @intCast(u28, line_delta);
-            } else {
-                unreachable;
-            }
         };
         const ptr_width_bytes = self.ptrWidthBytes();
 @@ -2268,7 +2260,7 @@ pub fn updateDecl(self: *Elf, module: *Module, decl: *Module.Decl) !void {
     } else {
         // TODO implement .debug_info for global variables
     }
-    const res = try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .{
+    const res = try codegen.generateSymbol(&self.base, decl.srcLoc(), typed_value, &code_buffer, .{
         .dwarf = .{
             .dbg_line = &dbg_line_buffer,
             .dbg_info = &dbg_info_buffer,
 @@ -2642,7 +2634,7 @@ pub fn updateDeclExports(
                 try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
                 module.failed_exports.putAssumeCapacityNoClobber(
                     exp,
-                    try Compilation.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
+                    try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: ExportOptions.section", .{}),
                 );
                 continue;
             }
 @@ -2660,7 +2652,7 @@ pub fn updateDeclExports(
                 try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
                 module.failed_exports.putAssumeCapacityNoClobber(
                     exp,
-                    try Compilation.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),
+                    try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: GlobalLinkage.LinkOnce", .{}),
                 );
                 continue;
             },
 @@ -2703,8 +2695,7 @@ pub fn updateDeclLineNumber(self: *Elf, module: *Module, decl: *const Module.Dec
     if (self.llvm_ir_module) |_| return;
-    const container_scope = decl.scope.cast(Module.Scope.Container).?;
+    const tree = decl.container.file_scope.contents.tree;
-    const tree = container_scope.file_scope.contents.tree;
     const file_ast_decls = tree.root_node.decls();
     // TODO Look into improving the performance here by adding a token-index-to-line
     // lookup table. Currently this involves scanning over the source code for newlines.

src/link/MachO.zig+4-4

src/link/MachO/DebugSymbols.zig+9-18

 @@ -906,8 +906,7 @@ pub fn updateDeclLineNumber(self: *DebugSymbols, module: *Module, decl: *const M
     const tracy = trace(@src());
     defer tracy.end();
-    const container_scope = decl.scope.cast(Module.Scope.Container).?;
+    const tree = decl.container.file_scope.contents.tree;
-    const tree = container_scope.file_scope.contents.tree;
     const file_ast_decls = tree.root_node.decls();
     // TODO Look into improving the performance here by adding a token-index-to-line
     // lookup table. Currently this involves scanning over the source code for newlines.
 @@ -951,22 +950,14 @@ pub fn initDeclDebugBuffers(
             try dbg_line_buffer.ensureCapacity(26);
             const line_off: u28 = blk: {
-                if (decl.scope.cast(Module.Scope.Container)) |container_scope| {
+                const tree = decl.container.file_scope.contents.tree;
-                    const tree = container_scope.file_scope.contents.tree;
+                const file_ast_decls = tree.root_node.decls();
-                    const file_ast_decls = tree.root_node.decls();
+                // TODO Look into improving the performance here by adding a token-index-to-line
-                    // TODO Look into improving the performance here by adding a token-index-to-line
+                // lookup table. Currently this involves scanning over the source code for newlines.
-                    // lookup table. Currently this involves scanning over the source code for newlines.
+                const fn_proto = file_ast_decls[decl.src_index].castTag(.FnProto).?;
-                    const fn_proto = file_ast_decls[decl.src_index].castTag(.FnProto).?;
+                const block = fn_proto.getBodyNode().?.castTag(.Block).?;
-                    const block = fn_proto.getBodyNode().?.castTag(.Block).?;
+                const line_delta = std.zig.lineDelta(tree.source, 0, tree.token_locs[block.lbrace].start);
-                    const line_delta = std.zig.lineDelta(tree.source, 0, tree.token_locs[block.lbrace].start);
+                break :blk @intCast(u28, line_delta);
-                    break :blk @intCast(u28, line_delta);
-                } else if (decl.scope.cast(Module.Scope.ZIRModule)) |zir_module| {
-                    const byte_off = zir_module.contents.module.decls[decl.src_index].inst.src;
-                    const line_delta = std.zig.lineDelta(zir_module.source.bytes, 0, byte_off);
-                    break :blk @intCast(u28, line_delta);
-                } else {
-                    unreachable;
-                }
             };
             dbg_line_buffer.appendSliceAssumeCapacity(&[_]u8{

src/main.zig+14-33

 @@ -221,7 +221,6 @@ const usage_build_generic =
     \\
     \\Supported file types:
     \\                    .zig    Zig source code
-    \\                    .zir    Zig Intermediate Representation code
     \\                      .o    ELF object file
     \\                      .o    MACH-O (macOS) object file
     \\                    .obj    COFF (Windows) object file
 @@ -245,8 +244,6 @@ const usage_build_generic =
     \\  -fno-emit-bin             Do not output machine code
     \\  -femit-asm[=path]         Output .s (assembly code)
     \\  -fno-emit-asm             (default) Do not output .s (assembly code)
-    \\  -femit-zir[=path]         Produce a .zir file with Zig IR
-    \\  -fno-emit-zir             (default) Do not produce a .zir file with Zig IR
     \\  -femit-llvm-ir[=path]     Produce a .ll file with LLVM IR (requires LLVM extensions)
     \\  -fno-emit-llvm-ir         (default) Do not produce a .ll file with LLVM IR
     \\  -femit-h[=path]           Generate a C header file (.h)
 @@ -1631,18 +1628,12 @@ fn buildOutputType(
     var emit_docs_resolved = try emit_docs.resolve("docs");
     defer emit_docs_resolved.deinit();
-    const zir_out_path: ?[]const u8 = switch (emit_zir) {
+    switch (emit_zir) {
-        .no => null,
+        .no => {},
-        .yes_default_path => blk: {
+        .yes_default_path, .yes => {
-            if (root_src_file) |rsf| {
+            fatal("The -femit-zir implementation has been intentionally deleted so that it can be rewritten as a proper backend.", .{});
-                if (mem.endsWith(u8, rsf, ".zir")) {
-                    break :blk try std.fmt.allocPrint(arena, "{s}.out.zir", .{root_name});
-                }
-            }
-            break :blk try std.fmt.allocPrint(arena, "{s}.zir", .{root_name});
         },
-        .yes => |p| p,
+    }
-    };
     const root_pkg: ?*Package = if (root_src_file) |src_path| blk: {
         if (main_pkg_path) |p| {
 @@ -1753,7 +1744,7 @@ fn buildOutputType(
         .dll_export_fns = dll_export_fns,
         .object_format = object_format,
         .optimize_mode = optimize_mode,
-        .keep_source_files_loaded = zir_out_path != null,
+        .keep_source_files_loaded = false,
         .clang_argv = clang_argv.items,
         .lld_argv = lld_argv.items,
         .lib_dirs = lib_dirs.items,
 @@ -1845,7 +1836,7 @@ fn buildOutputType(
         }
     };
-    updateModule(gpa, comp, zir_out_path, hook) catch |err| switch (err) {
+    updateModule(gpa, comp, hook) catch |err| switch (err) {
         error.SemanticAnalyzeFail => if (!watch) process.exit(1),
         else => |e| return e,
     };
 @@ -1980,7 +1971,7 @@ fn buildOutputType(
                 if (output_mode == .Exe) {
                     try comp.makeBinFileWritable();
                 }
-                updateModule(gpa, comp, zir_out_path, hook) catch |err| switch (err) {
+                updateModule(gpa, comp, hook) catch |err| switch (err) {
                     error.SemanticAnalyzeFail => continue,
                     else => |e| return e,
                 };
 @@ -2003,7 +1994,7 @@ const AfterUpdateHook = union(enum) {
     update: []const u8,
 };
-fn updateModule(gpa: *Allocator, comp: *Compilation, zir_out_path: ?[]const u8, hook: AfterUpdateHook) !void {
+fn updateModule(gpa: *Allocator, comp: *Compilation, hook: AfterUpdateHook) !void {
     try comp.update();
     var errors = try comp.getAllErrorsAlloc();
 @@ -2013,6 +2004,10 @@ fn updateModule(gpa: *Allocator, comp: *Compilation, zir_out_path: ?[]const u8,
         for (errors.list) |full_err_msg| {
             full_err_msg.renderToStdErr();
         }
+        const log_text = comp.getCompileLogOutput();
+        if (log_text.len != 0) {
+            std.debug.print("\nCompile Log Output:\n{s}", .{log_text});
+        }
         return error.SemanticAnalyzeFail;
     } else switch (hook) {
         .none => {},
 @@ -2024,20 +2019,6 @@ fn updateModule(gpa: *Allocator, comp: *Compilation, zir_out_path: ?[]const u8,
             .{},
         ),
     }
-    if (zir_out_path) |zop| {
-        const module = comp.bin_file.options.module orelse
-            fatal("-femit-zir with no zig source code", .{});
-        var new_zir_module = try zir.emit(gpa, module);
-        defer new_zir_module.deinit(gpa);
-        const baf = try io.BufferedAtomicFile.create(gpa, fs.cwd(), zop, .{});
-        defer baf.destroy();
-        try new_zir_module.writeToStream(gpa, baf.writer());
-        try baf.finish();
-    }
 }
 fn cmdTranslateC(comp: *Compilation, arena: *Allocator, enable_cache: bool) !void {
 @@ -2506,7 +2487,7 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v
         };
         defer comp.destroy();
-        try updateModule(gpa, comp, null, .none);
+        try updateModule(gpa, comp, .none);
         try comp.makeBinFileExecutable();
         child_argv.items[argv_index_exe] = try comp.bin_file.options.emit.?.directory.join(

src/test.zig+124-88

...	@@ -15,6 +15,8 @@ const CrossTarget = std.zig.CrossTarget;	...	@@ -15,6 +15,8 @@ const CrossTarget = std.zig.CrossTarget;
15		15
16	const zig_h = link.File.C.zig_h;	16	const zig_h = link.File.C.zig_h;
17		17
		18	const hr = "=" ** 40;
		19
18	test "self-hosted" {	20	test "self-hosted" {
19	var ctx = TestContext.init();	21	var ctx = TestContext.init();
20	defer ctx.deinit();	22	defer ctx.deinit();
...	@@ -29,23 +31,32 @@ const ErrorMsg = union(enum) {	...	@@ -29,23 +31,32 @@ const ErrorMsg = union(enum) {
29	msg: []const u8,	31	msg: []const u8,
30	line: u32,	32	line: u32,
31	column: u32,	33	column: u32,
		34	kind: Kind,
32	},	35	},
33	plain: struct {	36	plain: struct {
34	msg: []const u8,	37	msg: []const u8,
		38	kind: Kind,
35	},	39	},
36		40
37	fn init(other: Compilation.AllErrors.Message) ErrorMsg {	41	const Kind = enum {
		42	@"error",
		43	note,
		44	};
		45
		46	fn init(other: Compilation.AllErrors.Message, kind: Kind) ErrorMsg {
38	switch (other) {	47	switch (other) {
39	.src => \|src\| return .{	48	.src => \|src\| return .{
40	.src = .{	49	.src = .{
41	.msg = src.msg,	50	.msg = src.msg,
42	.line = @intCast(u32, src.line),	51	.line = @intCast(u32, src.line),
43	.column = @intCast(u32, src.column),	52	.column = @intCast(u32, src.column),
		53	.kind = kind,
44	},	54	},
45	},	55	},
46	.plain => \|plain\| return .{	56	.plain => \|plain\| return .{
47	.plain = .{	57	.plain = .{
48	.msg = plain.msg,	58	.msg = plain.msg,
		59	.kind = kind,
49	},	60	},
50	},	61	},
51	}	62	}
...	@@ -59,14 +70,15 @@ const ErrorMsg = union(enum) {	...	@@ -59,14 +70,15 @@ const ErrorMsg = union(enum) {
59	) !void {	70	) !void {
60	switch (self) {	71	switch (self) {
61	.src => \|src\| {	72	.src => \|src\| {
62	return writer.print(":{d}:{d}: error: {s}", .{	73	return writer.print(":{d}:{d}: {s}: {s}", .{
63	src.line + 1,	74	src.line + 1,
64	src.column + 1,	75	src.column + 1,
		76	@tagName(src.kind),
65	src.msg,	77	src.msg,
66	});	78	});
67	},	79	},
68	.plain => \|plain\| {	80	.plain => \|plain\| {
69	return writer.print("error: {s}", .{plain.msg});	81	return writer.print("{s}: {s}", .{ plain.msg, @tagName(plain.kind) });
70	},	82	},
71	}	83	}
72	}	84	}
...	@@ -86,9 +98,6 @@ pub const TestContext = struct {	...	@@ -86,9 +98,6 @@ pub const TestContext = struct {
86	/// effects of the incremental compilation.	98	/// effects of the incremental compilation.
87	src: [:0]const u8,	99	src: [:0]const u8,
88	case: union(enum) {	100	case: union(enum) {
89	/// A transformation update transforms the input and tests against
90	/// the expected output ZIR.
91	Transformation: [:0]const u8,
92	/// Check the main binary output file against an expected set of bytes.	101	/// Check the main binary output file against an expected set of bytes.
93	/// This is most useful with, for example, `-ofmt=c`.	102	/// This is most useful with, for example, `-ofmt=c`.
94	CompareObjectFile: []const u8,	103	CompareObjectFile: []const u8,
...	@@ -139,15 +148,6 @@ pub const TestContext = struct {	...	@@ -139,15 +148,6 @@ pub const TestContext = struct {
139		148
140	files: std.ArrayList(File),	149	files: std.ArrayList(File),
141		150
142	/// Adds a subcase in which the module is updated with `src`, and the
143	/// resulting ZIR is validated against `result`.
144	pub fn addTransform(self: *Case, src: [:0]const u8, result: [:0]const u8) void {
145	self.updates.append(.{
146	.src = src,
147	.case = .{ .Transformation = result },
148	}) catch unreachable;
149	}
150
151	/// Adds a subcase in which the module is updated with `src`, and a C	151	/// Adds a subcase in which the module is updated with `src`, and a C
152	/// header is generated.	152	/// header is generated.
153	pub fn addHeader(self: *Case, src: [:0]const u8, result: [:0]const u8) void {	153	pub fn addHeader(self: *Case, src: [:0]const u8, result: [:0]const u8) void {
...	@@ -182,31 +182,37 @@ pub const TestContext = struct {	...	@@ -182,31 +182,37 @@ pub const TestContext = struct {
182	/// the form `:line:column: error: message`.	182	/// the form `:line:column: error: message`.
183	pub fn addError(self: *Case, src: [:0]const u8, errors: []const []const u8) void {	183	pub fn addError(self: *Case, src: [:0]const u8, errors: []const []const u8) void {
184	var array = self.updates.allocator.alloc(ErrorMsg, errors.len) catch unreachable;	184	var array = self.updates.allocator.alloc(ErrorMsg, errors.len) catch unreachable;
185	for (errors) \|e, i\| {	185	for (errors) \|err_msg_line, i\| {
186	if (e[0] != ':') {	186	if (std.mem.startsWith(u8, err_msg_line, "error: ")) {
187	array[i] = .{ .plain = .{ .msg = e } };	187	array[i] = .{
		188	.plain = .{ .msg = err_msg_line["error: ".len..], .kind = .@"error" },
		189	};
		190	continue;
		191	} else if (std.mem.startsWith(u8, err_msg_line, "note: ")) {
		192	array[i] = .{
		193	.plain = .{ .msg = err_msg_line["note: ".len..], .kind = .note },
		194	};
188	continue;	195	continue;
189	}	196	}
190	var cur = e[1..];	197	// example: ":1:2: error: bad thing happened"
191	var line_index = std.mem.indexOf(u8, cur, ":");	198	var it = std.mem.split(err_msg_line, ":");
192	if (line_index == null) {	199	_ = it.next() orelse @panic("missing colon");
193	@panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");	200	const line_text = it.next() orelse @panic("missing line");
194	}	201	const col_text = it.next() orelse @panic("missing column");
195	const line = std.fmt.parseInt(u32, cur[0..line_index.?], 10) catch @panic("Unable to parse line number");	202	const kind_text = it.next() orelse @panic("missing 'error'/'note'");
196	cur = cur[line_index.? + 1 ..];	203	const msg = it.rest()[1..]; // skip over the space at end of "error: "
197	const column_index = std.mem.indexOf(u8, cur, ":");	204
198	if (column_index == null) {	205	const line = std.fmt.parseInt(u32, line_text, 10) catch @panic("bad line number");
199	@panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");	206	const column = std.fmt.parseInt(u32, col_text, 10) catch @panic("bad column number");
200	}	207	const kind: ErrorMsg.Kind = if (std.mem.eql(u8, kind_text, " error"))
201	const column = std.fmt.parseInt(u32, cur[0..column_index.?], 10) catch @panic("Unable to parse column number");	208	.@"error"
202	cur = cur[column_index.? + 2 ..];	209	else if (std.mem.eql(u8, kind_text, " note"))
203	if (!std.mem.eql(u8, cur[0..7], "error: ")) {	210	.note
204	@panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");	211	else
205	}	212	@panic("expected 'error'/'note'");
206	const msg = cur[7..];
207		213
208	if (line == 0 or column == 0) {	214	if (line == 0 or column == 0) {
209	@panic("Invalid test: error line and column must be specified starting at one!");	215	@panic("line and column must be specified starting at one");
210	}	216	}
211		217
212	array[i] = .{	218	array[i] = .{
...	@@ -214,6 +220,7 @@ pub const TestContext = struct {	...	@@ -214,6 +220,7 @@ pub const TestContext = struct {
214	.msg = msg,	220	.msg = msg,
215	.line = line - 1,	221	.line = line - 1,
216	.column = column - 1,	222	.column = column - 1,
		223	.kind = kind,
217	},	224	},
218	};	225	};
219	}	226	}
...	@@ -689,25 +696,20 @@ pub const TestContext = struct {	...	@@ -689,25 +696,20 @@ pub const TestContext = struct {
689	var all_errors = try comp.getAllErrorsAlloc();	696	var all_errors = try comp.getAllErrorsAlloc();
690	defer all_errors.deinit(allocator);	697	defer all_errors.deinit(allocator);
691	if (all_errors.list.len != 0) {	698	if (all_errors.list.len != 0) {
692	std.debug.print("\nErrors occurred updating the compilation:\n================\n", .{});	699	std.debug.print("\nErrors occurred updating the compilation:\n{s}\n", .{hr});
693	for (all_errors.list) \|err_msg\| {	700	for (all_errors.list) \|err_msg\| {
694	switch (err_msg) {	701	switch (err_msg) {
695	.src => \|src\| {	702	.src => \|src\| {
696	std.debug.print(":{d}:{d}: error: {s}\n================\n", .{	703	std.debug.print(":{d}:{d}: error: {s}\n{s}\n", .{
697	src.line + 1, src.column + 1, src.msg,	704	src.line + 1, src.column + 1, src.msg, hr,
698	});	705	});
699	},	706	},
700	.plain => \|plain\| {	707	.plain => \|plain\| {
701	std.debug.print("error: {s}\n================\n", .{plain.msg});	708	std.debug.print("error: {s}\n{s}\n", .{ plain.msg, hr });
702	},	709	},
703	}	710	}
704	}	711	}
705	// TODO print generated C code	712	// TODO print generated C code
706	//if (comp.bin_file.cast(link.File.C)) \|c_file\| {
707	// std.debug.print("Generated C: \n===============\n{s}\n\n===========\n\n", .{
708	// c_file.main.items,
709	// });
710	//}
711	std.debug.print("Test failed.\n", .{});	713	std.debug.print("Test failed.\n", .{});
712	std.process.exit(1);	714	std.process.exit(1);
713	}	715	}
...	@@ -728,48 +730,74 @@ pub const TestContext = struct {	...	@@ -728,48 +730,74 @@ pub const TestContext = struct {
728		730
729	std.testing.expectEqualStrings(expected_output, out);	731	std.testing.expectEqualStrings(expected_output, out);
730	},	732	},
731	.Transformation => \|expected_output\| {	733	.Error => \|case_error_list\| {
732	update_node.setEstimatedTotalItems(5);
733	var emit_node = update_node.start("emit", 0);
734	emit_node.activate();
735	var new_zir_module = try zir.emit(allocator, comp.bin_file.options.module.?);
736	defer new_zir_module.deinit(allocator);
737	emit_node.end();
738
739	var write_node = update_node.start("write", 0);
740	write_node.activate();
741	var out_zir = std.ArrayList(u8).init(allocator);
742	defer out_zir.deinit();
743	try new_zir_module.writeToStream(allocator, out_zir.writer());
744	write_node.end();
745
746	var test_node = update_node.start("assert", 0);	734	var test_node = update_node.start("assert", 0);
747	test_node.activate();	735	test_node.activate();
748	defer test_node.end();	736	defer test_node.end();
749		737
750	std.testing.expectEqualStrings(expected_output, out_zir.items);	738	const handled_errors = try arena.alloc(bool, case_error_list.len);
751	},	739	std.mem.set(bool, handled_errors, false);
752	.Error => \|e\| {	740
753	var test_node = update_node.start("assert", 0);	741	var actual_errors = try comp.getAllErrorsAlloc();
754	test_node.activate();	742	defer actual_errors.deinit(allocator);
755	defer test_node.end();	743
756	var handled_errors = try arena.alloc(bool, e.len);	744	var any_failed = false;
757	for (handled_errors) \|*handled\| {	745	var notes_to_check = std.ArrayList(*const Compilation.AllErrors.Message).init(allocator);
758	handled.* = false;	746	defer notes_to_check.deinit();
		747
		748	for (actual_errors.list) \|actual_error\| {
		749	for (case_error_list) \|case_msg, i\| {
		750	const ex_tag: @TagType(@TypeOf(case_msg)) = case_msg;
		751	switch (actual_error) {
		752	.src => \|actual_msg\| {
		753	for (actual_msg.notes) \|*note\| {
		754	try notes_to_check.append(note);
		755	}
		756
		757	if (ex_tag != .src) continue;
		758
		759	if (actual_msg.line == case_msg.src.line and
		760	actual_msg.column == case_msg.src.column and
		761	std.mem.eql(u8, case_msg.src.msg, actual_msg.msg) and
		762	case_msg.src.kind == .@"error")
		763	{
		764	handled_errors[i] = true;
		765	break;
		766	}
		767	},
		768	.plain => \|plain\| {
		769	if (ex_tag != .plain) continue;
		770
		771	if (std.mem.eql(u8, case_msg.plain.msg, plain.msg) and
		772	case_msg.plain.kind == .@"error")
		773	{
		774	handled_errors[i] = true;
		775	break;
		776	}
		777	},
		778	}
		779	} else {
		780	std.debug.print(
		781	"\nUnexpected error:\n{s}\n{}\n{s}",
		782	.{ hr, ErrorMsg.init(actual_error, .@"error"), hr },
		783	);
		784	any_failed = true;
		785	}
759	}	786	}
760	var all_errors = try comp.getAllErrorsAlloc();	787	while (notes_to_check.popOrNull()) \|note\| {
761	defer all_errors.deinit(allocator);	788	for (case_error_list) \|case_msg, i\| {
762	for (all_errors.list) \|a\| {	789	const ex_tag: @TagType(@TypeOf(case_msg)) = case_msg;
763	for (e) \|ex, i\| {	790	switch (note.*) {
764	const a_tag: @TagType(@TypeOf(a)) = a;	791	.src => \|actual_msg\| {
765	const ex_tag: @TagType(@TypeOf(ex)) = ex;	792	for (actual_msg.notes) \|*sub_note\| {
766	switch (a) {	793	try notes_to_check.append(sub_note);
767	.src => \|src\| {	794	}
768	if (ex_tag != .src) continue;	795	if (ex_tag != .src) continue;
769		796
770	if (src.line == ex.src.line and	797	if (actual_msg.line == case_msg.src.line and
771	src.column == ex.src.column and	798	actual_msg.column == case_msg.src.column and
772	std.mem.eql(u8, ex.src.msg, src.msg))	799	std.mem.eql(u8, case_msg.src.msg, actual_msg.msg) and
		800	case_msg.src.kind == .note)
773	{	801	{
774	handled_errors[i] = true;	802	handled_errors[i] = true;
775	break;	803	break;
...	@@ -778,7 +806,9 @@ pub const TestContext = struct {	...	@@ -778,7 +806,9 @@ pub const TestContext = struct {
778	.plain => \|plain\| {	806	.plain => \|plain\| {
779	if (ex_tag != .plain) continue;	807	if (ex_tag != .plain) continue;
780		808
781	if (std.mem.eql(u8, ex.plain.msg, plain.msg)) {	809	if (std.mem.eql(u8, case_msg.plain.msg, plain.msg) and
		810	case_msg.plain.kind == .note)
		811	{
782	handled_errors[i] = true;	812	handled_errors[i] = true;
783	break;	813	break;
784	}	814	}
...	@@ -786,23 +816,29 @@ pub const TestContext = struct {	...	@@ -786,23 +816,29 @@ pub const TestContext = struct {
786	}	816	}
787	} else {	817	} else {
788	std.debug.print(	818	std.debug.print(
789	"{s}\nUnexpected error:\n================\n{}\n================\nTest failed.\n",	819	"\nUnexpected note:\n{s}\n{}\n{s}",
790	.{ case.name, ErrorMsg.init(a) },	820	.{ hr, ErrorMsg.init(note.*, .note), hr },
791	);	821	);
792	std.process.exit(1);	822	any_failed = true;
793	}	823	}
794	}	824	}
795		825
796	for (handled_errors) \|handled, i\| {	826	for (handled_errors) \|handled, i\| {
797	if (!handled) {	827	if (!handled) {
798	const er = e[i];
799	std.debug.print(	828	std.debug.print(
800	"{s}\nDid not receive error:\n================\n{}\n================\nTest failed.\n",	829	"\nExpected error not found:\n{s}\n{}\n{s}",
801	.{ case.name, er },	830	.{ hr, case_error_list[i], hr },
802	);	831	);
803	std.process.exit(1);	832	any_failed = true;
804	}	833	}
805	}	834	}
		835
		836	if (any_failed) {
		837	std.debug.print("\nTest case '{s}' failed, update_index={d}.\n", .{
		838	case.name, update_index,
		839	});
		840	std.process.exit(1);
		841	}
806	},	842	},
807	.Execution => \|expected_stdout\| {	843	.Execution => \|expected_stdout\| {
808	update_node.setEstimatedTotalItems(4);	844	update_node.setEstimatedTotalItems(4);

src/type/Enum.zig+1-1

...	@@ -21,7 +21,7 @@ pub const Field = struct {	...	@@ -21,7 +21,7 @@ pub const Field = struct {
21	};	21	};
22		22
23	pub const Zir = struct {	23	pub const Zir = struct {
24	body: zir.Module.Body,	24	body: zir.Body,
25	inst: *zir.Inst,	25	inst: *zir.Inst,
26	};	26	};
27		27

src/type/Struct.zig+1-1

...	@@ -24,7 +24,7 @@ pub const Field = struct {	...	@@ -24,7 +24,7 @@ pub const Field = struct {
24	};	24	};
25		25
26	pub const Zir = struct {	26	pub const Zir = struct {
27	body: zir.Module.Body,	27	body: zir.Body,
28	inst: *zir.Inst,	28	inst: *zir.Inst,
29	};	29	};
30		30

src/type/Union.zig+1-1

...	@@ -24,7 +24,7 @@ pub const Field = struct {	...	@@ -24,7 +24,7 @@ pub const Field = struct {
24	};	24	};
25		25
26	pub const Zir = struct {	26	pub const Zir = struct {
27	body: zir.Module.Body,	27	body: zir.Body,
28	inst: *zir.Inst,	28	inst: *zir.Inst,
29	};	29	};
30		30

src/zir.zig+27-1583

...	@@ -12,17 +12,6 @@ const TypedValue = @import("TypedValue.zig");	...	@@ -12,17 +12,6 @@ const TypedValue = @import("TypedValue.zig");
12	const ir = @import("ir.zig");	12	const ir = @import("ir.zig");
13	const IrModule = @import("Module.zig");	13	const IrModule = @import("Module.zig");
14		14
15	/// This struct is relevent only for the ZIR Module text format. It is not used for
16	/// semantic analysis of Zig source code.
17	pub const Decl = struct {
18	name: []const u8,
19
20	/// Hash of slice into the source of the part after the = and before the next instruction.
21	contents_hash: std.zig.SrcHash,
22
23	inst: *Inst,
24	};
25
26	/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for	15	/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for
27	/// in-memory, analyzed instructions with types and values.	16	/// in-memory, analyzed instructions with types and values.
28	/// We use a table to map these instruction to their respective semantically analyzed	17	/// We use a table to map these instruction to their respective semantically analyzed
...	@@ -141,15 +130,12 @@ pub const Inst = struct {	...	@@ -141,15 +130,12 @@ pub const Inst = struct {
141	container_field,	130	container_field,
142	/// Declares the beginning of a statement. Used for debug info.	131	/// Declares the beginning of a statement. Used for debug info.
143	dbg_stmt,	132	dbg_stmt,
144	/// Represents a pointer to a global decl by name.	133	/// Represents a pointer to a global decl.
145	declref,	134	declref,
146	/// Represents a pointer to a global decl by string name.	135	/// Represents a pointer to a global decl by string name.
147	declref_str,	136	declref_str,
148	/// The syntax `@foo` is equivalent to `declval("foo")`.	137	/// Equivalent to a declref followed by deref.
149	/// declval is equivalent to declref followed by deref.
150	declval,	138	declval,
151	/// Same as declval but the parameter is a `*Module.Decl` rather than a name.
152	declval_in_module,
153	/// Load the value from a pointer.	139	/// Load the value from a pointer.
154	deref,	140	deref,
155	/// Arithmetic division. Asserts no integer overflow.	141	/// Arithmetic division. Asserts no integer overflow.
...	@@ -419,7 +405,6 @@ pub const Inst = struct {	...	@@ -419,7 +405,6 @@ pub const Inst = struct {
419	.declref => DeclRef,	405	.declref => DeclRef,
420	.declref_str => DeclRefStr,	406	.declref_str => DeclRefStr,
421	.declval => DeclVal,	407	.declval => DeclVal,
422	.declval_in_module => DeclValInModule,
423	.coerce_result_block_ptr => CoerceResultBlockPtr,	408	.coerce_result_block_ptr => CoerceResultBlockPtr,
424	.compilelog => CompileLog,	409	.compilelog => CompileLog,
425	.loop => Loop,	410	.loop => Loop,
...	@@ -496,7 +481,6 @@ pub const Inst = struct {	...	@@ -496,7 +481,6 @@ pub const Inst = struct {
496	.declref,	481	.declref,
497	.declref_str,	482	.declref_str,
498	.declval,	483	.declval,
499	.declval_in_module,
500	.deref,	484	.deref,
501	.div,	485	.div,
502	.elemptr,	486	.elemptr,
...	@@ -650,7 +634,7 @@ pub const Inst = struct {	...	@@ -650,7 +634,7 @@ pub const Inst = struct {
650	base: Inst,	634	base: Inst,
651		635
652	positionals: struct {	636	positionals: struct {
653	body: Module.Body,	637	body: Body,
654	},	638	},
655	kw_args: struct {},	639	kw_args: struct {},
656	};	640	};
...	@@ -705,7 +689,7 @@ pub const Inst = struct {	...	@@ -705,7 +689,7 @@ pub const Inst = struct {
705	base: Inst,	689	base: Inst,
706		690
707	positionals: struct {	691	positionals: struct {
708	name: []const u8,	692	decl: *IrModule.Decl,
709	},	693	},
710	kw_args: struct {},	694	kw_args: struct {},
711	};	695	};
...	@@ -724,16 +708,6 @@ pub const Inst = struct {	...	@@ -724,16 +708,6 @@ pub const Inst = struct {
724	pub const base_tag = Tag.declval;	708	pub const base_tag = Tag.declval;
725	base: Inst,	709	base: Inst,
726		710
727	positionals: struct {
728	name: []const u8,
729	},
730	kw_args: struct {},
731	};
732
733	pub const DeclValInModule = struct {
734	pub const base_tag = Tag.declval_in_module;
735	base: Inst,
736
737	positionals: struct {	711	positionals: struct {
738	decl: *IrModule.Decl,	712	decl: *IrModule.Decl,
739	},	713	},
...	@@ -758,10 +732,7 @@ pub const Inst = struct {	...	@@ -758,10 +732,7 @@ pub const Inst = struct {
758	positionals: struct {	732	positionals: struct {
759	to_log: []*Inst,	733	to_log: []*Inst,
760	},	734	},
761	kw_args: struct {	735	kw_args: struct {},
762	/// If we have seen it already so don't make another error
763	seen: bool = false,
764	},
765	};	736	};
766		737
767	pub const Const = struct {	738	pub const Const = struct {
...	@@ -799,7 +770,7 @@ pub const Inst = struct {	...	@@ -799,7 +770,7 @@ pub const Inst = struct {
799	base: Inst,	770	base: Inst,
800		771
801	positionals: struct {	772	positionals: struct {
802	body: Module.Body,	773	body: Body,
803	},	774	},
804	kw_args: struct {},	775	kw_args: struct {},
805	};	776	};
...	@@ -838,7 +809,7 @@ pub const Inst = struct {	...	@@ -838,7 +809,7 @@ pub const Inst = struct {
838		809
839	positionals: struct {	810	positionals: struct {
840	fn_type: *Inst,	811	fn_type: *Inst,
841	body: Module.Body,	812	body: Body,
842	},	813	},
843	kw_args: struct {	814	kw_args: struct {
844	is_inline: bool = false,	815	is_inline: bool = false,
...	@@ -998,8 +969,8 @@ pub const Inst = struct {	...	@@ -998,8 +969,8 @@ pub const Inst = struct {
998		969
999	positionals: struct {	970	positionals: struct {
1000	condition: *Inst,	971	condition: *Inst,
1001	then_body: Module.Body,	972	then_body: Body,
1002	else_body: Module.Body,	973	else_body: Body,
1003	},	974	},
1004	kw_args: struct {},	975	kw_args: struct {},
1005	};	976	};
...	@@ -1078,7 +1049,7 @@ pub const Inst = struct {	...	@@ -1078,7 +1049,7 @@ pub const Inst = struct {
1078	/// List of all individual items and ranges	1049	/// List of all individual items and ranges
1079	items: []*Inst,	1050	items: []*Inst,
1080	cases: []Case,	1051	cases: []Case,
1081	else_body: Module.Body,	1052	else_body: Body,
1082	},	1053	},
1083	kw_args: struct {	1054	kw_args: struct {
1084	/// Pointer to first range if such exists.	1055	/// Pointer to first range if such exists.
...	@@ -1092,7 +1063,7 @@ pub const Inst = struct {	...	@@ -1092,7 +1063,7 @@ pub const Inst = struct {
1092		1063
1093	pub const Case = struct {	1064	pub const Case = struct {
1094	item: *Inst,	1065	item: *Inst,
1095	body: Module.Body,	1066	body: Body,
1096	};	1067	};
1097	};	1068	};
1098	pub const TypeOfPeer = struct {	1069	pub const TypeOfPeer = struct {
...	@@ -1192,6 +1163,10 @@ pub const ErrorMsg = struct {	...	@@ -1192,6 +1163,10 @@ pub const ErrorMsg = struct {
1192	msg: []const u8,	1163	msg: []const u8,
1193	};	1164	};
1194		1165
		1166	pub const Body = struct {
		1167	instructions: []*Inst,
		1168	};
		1169
1195	pub const Module = struct {	1170	pub const Module = struct {
1196	decls: []*Decl,	1171	decls: []*Decl,
1197	arena: std.heap.ArenaAllocator,	1172	arena: std.heap.ArenaAllocator,
...	@@ -1199,6 +1174,15 @@ pub const Module = struct {	...	@@ -1199,6 +1174,15 @@ pub const Module = struct {
1199	metadata: std.AutoHashMap(*Inst, MetaData),	1174	metadata: std.AutoHashMap(*Inst, MetaData),
1200	body_metadata: std.AutoHashMap(*Body, BodyMetaData),	1175	body_metadata: std.AutoHashMap(*Body, BodyMetaData),
1201		1176
		1177	pub const Decl = struct {
		1178	name: []const u8,
		1179
		1180	/// Hash of slice into the source of the part after the = and before the next instruction.
		1181	contents_hash: std.zig.SrcHash,
		1182
		1183	inst: *Inst,
		1184	};
		1185
1202	pub const MetaData = struct {	1186	pub const MetaData = struct {
1203	deaths: ir.Inst.DeathsInt,	1187	deaths: ir.Inst.DeathsInt,
1204	addr: usize,	1188	addr: usize,
...	@@ -1208,10 +1192,6 @@ pub const Module = struct {	...	@@ -1208,10 +1192,6 @@ pub const Module = struct {
1208	deaths: []*Inst,	1192	deaths: []*Inst,
1209	};	1193	};
1210		1194
1211	pub const Body = struct {
1212	instructions: []*Inst,
1213	};
1214
1215	pub fn deinit(self: Module, allocator: Allocator) void {	1195	pub fn deinit(self: Module, allocator: Allocator) void {
1216	self.metadata.deinit();	1196	self.metadata.deinit();
1217	self.body_metadata.deinit();	1197	self.body_metadata.deinit();
...	@@ -1369,7 +1349,7 @@ const Writer = struct {	...	@@ -1369,7 +1349,7 @@ const Writer = struct {
1369	}	1349	}
1370	try stream.writeByte(']');	1350	try stream.writeByte(']');
1371	},	1351	},
1372	Module.Body => {	1352	Body => {
1373	try stream.writeAll("{\n");	1353	try stream.writeAll("{\n");
1374	if (self.module.body_metadata.get(param_ptr)) \|metadata\| {	1354	if (self.module.body_metadata.get(param_ptr)) \|metadata\| {
1375	if (metadata.deaths.len > 0) {	1355	if (metadata.deaths.len > 0) {
...	@@ -1468,8 +1448,6 @@ const Writer = struct {	...	@@ -1468,8 +1448,6 @@ const Writer = struct {
1468	try stream.print("@{s}", .{info.name});	1448	try stream.print("@{s}", .{info.name});
1469	}	1449	}
1470	} else if (inst.cast(Inst.DeclVal)) \|decl_val\| {	1450	} else if (inst.cast(Inst.DeclVal)) \|decl_val\| {
1471	try stream.print("@{s}", .{decl_val.positionals.name});
1472	} else if (inst.cast(Inst.DeclValInModule)) \|decl_val\| {
1473	try stream.print("@{s}", .{decl_val.positionals.decl.name});	1451	try stream.print("@{s}", .{decl_val.positionals.decl.name});
1474	} else {	1452	} else {
1475	// This should be unreachable in theory, but since ZIR is used for debugging the compiler	1453	// This should be unreachable in theory, but since ZIR is used for debugging the compiler
...	@@ -1479,502 +1457,6 @@ const Writer = struct {	...	@@ -1479,502 +1457,6 @@ const Writer = struct {
1479	}	1457	}
1480	};	1458	};
1481		1459
1482	pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module {
1483	var global_name_map = std.StringHashMap(*Inst).init(allocator);
1484	defer global_name_map.deinit();
1485
1486	var parser: Parser = .{
1487	.allocator = allocator,
1488	.arena = std.heap.ArenaAllocator.init(allocator),
1489	.i = 0,
1490	.source = source,
1491	.global_name_map = &global_name_map,
1492	.decls = .{},
1493	.unnamed_index = 0,
1494	.block_table = std.StringHashMap(*Inst.Block).init(allocator),
1495	.loop_table = std.StringHashMap(*Inst.Loop).init(allocator),
1496	};
1497	defer parser.block_table.deinit();
1498	defer parser.loop_table.deinit();
1499	errdefer parser.arena.deinit();
1500
1501	parser.parseRoot() catch \|err\| switch (err) {
1502	error.ParseFailure => {
1503	assert(parser.error_msg != null);
1504	},
1505	else => \|e\| return e,
1506	};
1507
1508	return Module{
1509	.decls = parser.decls.toOwnedSlice(allocator),
1510	.arena = parser.arena,
1511	.error_msg = parser.error_msg,
1512	.metadata = std.AutoHashMap(*Inst, Module.MetaData).init(allocator),
1513	.body_metadata = std.AutoHashMap(*Module.Body, Module.BodyMetaData).init(allocator),
1514	};
1515	}
1516
1517	const Parser = struct {
1518	allocator: *Allocator,
1519	arena: std.heap.ArenaAllocator,
1520	i: usize,
1521	source: [:0]const u8,
1522	decls: std.ArrayListUnmanaged(*Decl),
1523	global_name_map: std.StringHashMap(Inst),
1524	error_msg: ?ErrorMsg = null,
1525	unnamed_index: usize,
1526	block_table: std.StringHashMap(*Inst.Block),
1527	loop_table: std.StringHashMap(*Inst.Loop),
1528
1529	const Body = struct {
1530	instructions: std.ArrayList(*Inst),
1531	name_map: std.StringHashMap(Inst),
1532	};
1533
1534	fn parseBody(self: Parser, body_ctx: ?Body) !Module.Body {
1535	var name_map = std.StringHashMap(*Inst).init(self.allocator);
1536	defer name_map.deinit();
1537
1538	var body_context = Body{
1539	.instructions = std.ArrayList(*Inst).init(self.allocator),
1540	.name_map = if (body_ctx) \|bctx\| bctx.name_map else &name_map,
1541	};
1542	defer body_context.instructions.deinit();
1543
1544	try requireEatBytes(self, "{");
1545	skipSpace(self);
1546
1547	while (true) : (self.i += 1) switch (self.source[self.i]) {
1548	';' => _ = try skipToAndOver(self, '\n'),
1549	'%' => {
1550	self.i += 1;
1551	const ident = try skipToAndOver(self, ' ');
1552	skipSpace(self);
1553	try requireEatBytes(self, "=");
1554	skipSpace(self);
1555	const decl = try parseInstruction(self, &body_context, ident);
1556	const ident_index = body_context.instructions.items.len;
1557	if (try body_context.name_map.fetchPut(ident, decl.inst)) \|_\| {
1558	return self.fail("redefinition of identifier '{s}'", .{ident});
1559	}
1560	try body_context.instructions.append(decl.inst);
1561	continue;
1562	},
1563	' ', '\n' => continue,
1564	'}' => {
1565	self.i += 1;
1566	break;
1567	},
1568	else => \|byte\| return self.failByte(byte),
1569	};
1570
1571	// Move the instructions to the arena
1572	const instrs = try self.arena.allocator.alloc(*Inst, body_context.instructions.items.len);
1573	mem.copy(*Inst, instrs, body_context.instructions.items);
1574	return Module.Body{ .instructions = instrs };
1575	}
1576
1577	fn parseStringLiteral(self: *Parser) ![]u8 {
1578	const start = self.i;
1579	try self.requireEatBytes("\"");
1580
1581	while (true) : (self.i += 1) switch (self.source[self.i]) {
1582	'"' => {
1583	self.i += 1;
1584	const span = self.source[start..self.i];
1585	var bad_index: usize = undefined;
1586	const parsed = std.zig.parseStringLiteral(&self.arena.allocator, span, &bad_index) catch \|err\| switch (err) {
1587	error.InvalidCharacter => {
1588	self.i = start + bad_index;
1589	const bad_byte = self.source[self.i];
1590	return self.fail("invalid string literal character: '{c}'\n", .{bad_byte});
1591	},
1592	else => \|e\| return e,
1593	};
1594	return parsed;
1595	},
1596	'\\' => {
1597	self.i += 1;
1598	continue;
1599	},
1600	0 => return self.failByte(0),
1601	else => continue,
1602	};
1603	}
1604
1605	fn parseIntegerLiteral(self: *Parser) !BigIntConst {
1606	const start = self.i;
1607	if (self.source[self.i] == '-') self.i += 1;
1608	while (true) : (self.i += 1) switch (self.source[self.i]) {
1609	'0'...'9' => continue,
1610	else => break,
1611	};
1612	const number_text = self.source[start..self.i];
1613	const base = 10;
1614	// TODO reuse the same array list for this
1615	const limbs_buffer_len = std.math.big.int.calcSetStringLimbsBufferLen(base, number_text.len);
1616	const limbs_buffer = try self.allocator.alloc(std.math.big.Limb, limbs_buffer_len);
1617	defer self.allocator.free(limbs_buffer);
1618	const limb_len = std.math.big.int.calcSetStringLimbCount(base, number_text.len);
1619	const limbs = try self.arena.allocator.alloc(std.math.big.Limb, limb_len);
1620	var result = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
1621	result.setString(base, number_text, limbs_buffer, self.allocator) catch \|err\| switch (err) {
1622	error.InvalidCharacter => {
1623	self.i = start;
1624	return self.fail("invalid digit in integer literal", .{});
1625	},
1626	};
1627	return result.toConst();
1628	}
1629
1630	fn parseRoot(self: *Parser) !void {
1631	// The IR format is designed so that it can be tokenized and parsed at the same time.
1632	while (true) {
1633	switch (self.source[self.i]) {
1634	';' => _ = try skipToAndOver(self, '\n'),
1635	'@' => {
1636	self.i += 1;
1637	const ident = try skipToAndOver(self, ' ');
1638	skipSpace(self);
1639	try requireEatBytes(self, "=");
1640	skipSpace(self);
1641	const decl = try parseInstruction(self, null, ident);
1642	const ident_index = self.decls.items.len;
1643	if (try self.global_name_map.fetchPut(ident, decl.inst)) \|_\| {
1644	return self.fail("redefinition of identifier '{s}'", .{ident});
1645	}
1646	try self.decls.append(self.allocator, decl);
1647	},
1648	' ', '\n' => self.i += 1,
1649	0 => break,
1650	else => \|byte\| return self.fail("unexpected byte: '{c}'", .{byte}),
1651	}
1652	}
1653	}
1654
1655	fn eatByte(self: *Parser, byte: u8) bool {
1656	if (self.source[self.i] != byte) return false;
1657	self.i += 1;
1658	return true;
1659	}
1660
1661	fn skipSpace(self: *Parser) void {
1662	while (self.source[self.i] == ' ' or self.source[self.i] == '\n') {
1663	self.i += 1;
1664	}
1665	}
1666
1667	fn requireEatBytes(self: *Parser, bytes: []const u8) !void {
1668	const start = self.i;
1669	for (bytes) \|byte\| {
1670	if (self.source[self.i] != byte) {
1671	self.i = start;
1672	return self.fail("expected '{s}'", .{bytes});
1673	}
1674	self.i += 1;
1675	}
1676	}
1677
1678	fn skipToAndOver(self: *Parser, byte: u8) ![]const u8 {
1679	const start_i = self.i;
1680	while (self.source[self.i] != 0) : (self.i += 1) {
1681	if (self.source[self.i] == byte) {
1682	const result = self.source[start_i..self.i];
1683	self.i += 1;
1684	return result;
1685	}
1686	}
1687	return self.fail("unexpected EOF", .{});
1688	}
1689
1690	/// ParseFailure is an internal error code; handled in `parse`.
1691	const InnerError = error{ ParseFailure, OutOfMemory };
1692
1693	fn failByte(self: *Parser, byte: u8) InnerError {
1694	if (byte == 0) {
1695	return self.fail("unexpected EOF", .{});
1696	} else {
1697	return self.fail("unexpected byte: '{c}'", .{byte});
1698	}
1699	}
1700
1701	fn fail(self: *Parser, comptime format: []const u8, args: anytype) InnerError {
1702	@setCold(true);
1703	self.error_msg = ErrorMsg{
1704	.byte_offset = self.i,
1705	.msg = try std.fmt.allocPrint(&self.arena.allocator, format, args),
1706	};
1707	return error.ParseFailure;
1708	}
1709
1710	fn parseInstruction(self: Parser, body_ctx: ?Body, name: []const u8) InnerError!*Decl {
1711	const contents_start = self.i;
1712	const fn_name = try skipToAndOver(self, '(');
1713	inline for (@typeInfo(Inst.Tag).Enum.fields) \|field\| {
1714	if (mem.eql(u8, field.name, fn_name)) {
1715	const tag = @field(Inst.Tag, field.name);
1716	return parseInstructionGeneric(self, field.name, tag.Type(), tag, body_ctx, name, contents_start);
1717	}
1718	}
1719	return self.fail("unknown instruction '{s}'", .{fn_name});
1720	}
1721
1722	fn parseInstructionGeneric(
1723	self: *Parser,
1724	comptime fn_name: []const u8,
1725	comptime InstType: type,
1726	tag: Inst.Tag,
1727	body_ctx: ?*Body,
1728	inst_name: []const u8,
1729	contents_start: usize,
1730	) InnerError!*Decl {
1731	const inst_specific = try self.arena.allocator.create(InstType);
1732	inst_specific.base = .{
1733	.src = self.i,
1734	.tag = tag,
1735	};
1736
1737	if (InstType == Inst.Block) {
1738	try self.block_table.put(inst_name, inst_specific);
1739	} else if (InstType == Inst.Loop) {
1740	try self.loop_table.put(inst_name, inst_specific);
1741	}
1742
1743	if (@hasField(InstType, "ty")) {
1744	inst_specific.ty = opt_type orelse {
1745	return self.fail("instruction '" ++ fn_name ++ "' requires type", .{});
1746	};
1747	}
1748
1749	const Positionals = @TypeOf(inst_specific.positionals);
1750	inline for (@typeInfo(Positionals).Struct.fields) \|arg_field\| {
1751	if (self.source[self.i] == ',') {
1752	self.i += 1;
1753	skipSpace(self);
1754	} else if (self.source[self.i] == ')') {
1755	return self.fail("expected positional parameter '{s}'", .{arg_field.name});
1756	}
1757	@field(inst_specific.positionals, arg_field.name) = try parseParameterGeneric(
1758	self,
1759	arg_field.field_type,
1760	body_ctx,
1761	);
1762	skipSpace(self);
1763	}
1764
1765	const KW_Args = @TypeOf(inst_specific.kw_args);
1766	inst_specific.kw_args = .{}; // assign defaults
1767	skipSpace(self);
1768	while (eatByte(self, ',')) {
1769	skipSpace(self);
1770	const name = try skipToAndOver(self, '=');
1771	inline for (@typeInfo(KW_Args).Struct.fields) \|arg_field\| {
1772	const field_name = arg_field.name;
1773	if (mem.eql(u8, name, field_name)) {
1774	const NonOptional = switch (@typeInfo(arg_field.field_type)) {
1775	.Optional => \|info\| info.child,
1776	else => arg_field.field_type,
1777	};
1778	@field(inst_specific.kw_args, field_name) = try parseParameterGeneric(self, NonOptional, body_ctx);
1779	break;
1780	}
1781	} else {
1782	return self.fail("unrecognized keyword parameter: '{s}'", .{name});
1783	}
1784	skipSpace(self);
1785	}
1786	try requireEatBytes(self, ")");
1787
1788	const decl = try self.arena.allocator.create(Decl);
1789	decl.* = .{
1790	.name = inst_name,
1791	.contents_hash = std.zig.hashSrc(self.source[contents_start..self.i]),
1792	.inst = &inst_specific.base,
1793	};
1794
1795	return decl;
1796	}
1797
1798	fn parseParameterGeneric(self: Parser, comptime T: type, body_ctx: ?Body) !T {
1799	if (@typeInfo(T) == .Enum) {
1800	const start = self.i;
1801	while (true) : (self.i += 1) switch (self.source[self.i]) {
1802	' ', '\n', ',', ')' => {
1803	const enum_name = self.source[start..self.i];
1804	return std.meta.stringToEnum(T, enum_name) orelse {
1805	return self.fail("tag '{s}' not a member of enum '{s}'", .{ enum_name, @typeName(T) });
1806	};
1807	},
1808	0 => return self.failByte(0),
1809	else => continue,
1810	};
1811	}
1812	switch (T) {
1813	Module.Body => return parseBody(self, body_ctx),
1814	bool => {
1815	const bool_value = switch (self.source[self.i]) {
1816	'0' => false,
1817	'1' => true,
1818	else => \|byte\| return self.fail("expected '0' or '1' for boolean value, found {c}", .{byte}),
1819	};
1820	self.i += 1;
1821	return bool_value;
1822	},
1823	[]*Inst => {
1824	try requireEatBytes(self, "[");
1825	skipSpace(self);
1826	if (eatByte(self, ']')) return &[0]*Inst{};
1827
1828	var instructions = std.ArrayList(*Inst).init(&self.arena.allocator);
1829	while (true) {
1830	skipSpace(self);
1831	try instructions.append(try parseParameterInst(self, body_ctx));
1832	skipSpace(self);
1833	if (!eatByte(self, ',')) break;
1834	}
1835	try requireEatBytes(self, "]");
1836	return instructions.toOwnedSlice();
1837	},
1838	*Inst => return parseParameterInst(self, body_ctx),
1839	[]u8, []const u8 => return self.parseStringLiteral(),
1840	BigIntConst => return self.parseIntegerLiteral(),
1841	usize => {
1842	const big_int = try self.parseIntegerLiteral();
1843	return big_int.to(usize) catch \|err\| return self.fail("integer literal: {s}", .{@errorName(err)});
1844	},
1845	TypedValue => return self.fail("'const' is a special instruction; not legal in ZIR text", .{}),
1846	*IrModule.Decl => return self.fail("'declval_in_module' is a special instruction; not legal in ZIR text", .{}),
1847	*Inst.Block => {
1848	const name = try self.parseStringLiteral();
1849	return self.block_table.get(name).?;
1850	},
1851	*Inst.Loop => {
1852	const name = try self.parseStringLiteral();
1853	return self.loop_table.get(name).?;
1854	},
1855	[][]const u8 => {
1856	try requireEatBytes(self, "[");
1857	skipSpace(self);
1858	if (eatByte(self, ']')) return &[0][]const u8{};
1859
1860	var strings = std.ArrayList([]const u8).init(&self.arena.allocator);
1861	while (true) {
1862	skipSpace(self);
1863	try strings.append(try self.parseStringLiteral());
1864	skipSpace(self);
1865	if (!eatByte(self, ',')) break;
1866	}
1867	try requireEatBytes(self, "]");
1868	return strings.toOwnedSlice();
1869	},
1870	[]Inst.SwitchBr.Case => {
1871	try requireEatBytes(self, "{");
1872	skipSpace(self);
1873	if (eatByte(self, '}')) return &[0]Inst.SwitchBr.Case{};
1874
1875	var cases = std.ArrayList(Inst.SwitchBr.Case).init(&self.arena.allocator);
1876	while (true) {
1877	const cur = try cases.addOne();
1878	skipSpace(self);
1879	cur.item = try self.parseParameterGeneric(*Inst, body_ctx);
1880	skipSpace(self);
1881	try requireEatBytes(self, "=>");
1882	cur.body = try self.parseBody(body_ctx);
1883	skipSpace(self);
1884	if (!eatByte(self, ',')) break;
1885	}
1886	skipSpace(self);
1887	try requireEatBytes(self, "}");
1888	return cases.toOwnedSlice();
1889	},
1890	else => @compileError("Unimplemented: ir parseParameterGeneric for type " ++ @typeName(T)),
1891	}
1892	return self.fail("TODO parse parameter {s}", .{@typeName(T)});
1893	}
1894
1895	fn parseParameterInst(self: Parser, body_ctx: ?Body) !*Inst {
1896	const local_ref = switch (self.source[self.i]) {
1897	'@' => false,
1898	'%' => true,
1899	else => \|byte\| return self.fail("unexpected byte: '{c}'", .{byte}),
1900	};
1901	const map = if (local_ref)
1902	if (body_ctx) \|bc\|
1903	bc.name_map
1904	else
1905	return self.fail("referencing a % instruction in global scope", .{})
1906	else
1907	self.global_name_map;
1908
1909	self.i += 1;
1910	const name_start = self.i;
1911	while (true) : (self.i += 1) switch (self.source[self.i]) {
1912	0, ' ', '\n', ',', ')', ']' => break,
1913	else => continue,
1914	};
1915	const ident = self.source[name_start..self.i];
1916	return map.get(ident) orelse {
1917	const bad_name = self.source[name_start - 1 .. self.i];
1918	const src = name_start - 1;
1919	if (local_ref) {
1920	self.i = src;
1921	return self.fail("unrecognized identifier: {s}", .{bad_name});
1922	} else {
1923	const declval = try self.arena.allocator.create(Inst.DeclVal);
1924	declval.* = .{
1925	.base = .{
1926	.src = src,
1927	.tag = Inst.DeclVal.base_tag,
1928	},
1929	.positionals = .{ .name = ident },
1930	.kw_args = .{},
1931	};
1932	return &declval.base;
1933	}
1934	};
1935	}
1936
1937	fn generateName(self: *Parser) ![]u8 {
1938	const result = try std.fmt.allocPrint(&self.arena.allocator, "unnamed${d}", .{self.unnamed_index});
1939	self.unnamed_index += 1;
1940	return result;
1941	}
1942	};
1943
1944	pub fn emit(allocator: Allocator, old_module: IrModule) !Module {
1945	var ctx: EmitZIR = .{
1946	.allocator = allocator,
1947	.decls = .{},
1948	.arena = std.heap.ArenaAllocator.init(allocator),
1949	.old_module = old_module,
1950	.next_auto_name = 0,
1951	.names = std.StringArrayHashMap(void).init(allocator),
1952	.primitive_table = std.AutoHashMap(Inst.Primitive.Builtin, *Decl).init(allocator),
1953	.indent = 0,
1954	.block_table = std.AutoHashMap(ir.Inst.Block, Inst.Block).init(allocator),
1955	.loop_table = std.AutoHashMap(ir.Inst.Loop, Inst.Loop).init(allocator),
1956	.metadata = std.AutoHashMap(*Inst, Module.MetaData).init(allocator),
1957	.body_metadata = std.AutoHashMap(*Module.Body, Module.BodyMetaData).init(allocator),
1958	};
1959	errdefer ctx.metadata.deinit();
1960	errdefer ctx.body_metadata.deinit();
1961	defer ctx.block_table.deinit();
1962	defer ctx.loop_table.deinit();
1963	defer ctx.decls.deinit(allocator);
1964	defer ctx.names.deinit();
1965	defer ctx.primitive_table.deinit();
1966	errdefer ctx.arena.deinit();
1967
1968	try ctx.emit();
1969
1970	return Module{
1971	.decls = ctx.decls.toOwnedSlice(allocator),
1972	.arena = ctx.arena,
1973	.metadata = ctx.metadata,
1974	.body_metadata = ctx.body_metadata,
1975	};
1976	}
1977
1978	/// For debugging purposes, prints a function representation to stderr.	1460	/// For debugging purposes, prints a function representation to stderr.
1979	pub fn dumpFn(old_module: IrModule, module_fn: *IrModule.Fn) void {	1461	pub fn dumpFn(old_module: IrModule, module_fn: *IrModule.Fn) void {
1980	const allocator = old_module.gpa;	1462	const allocator = old_module.gpa;
...	@@ -2374,1052 +1856,14 @@ const DumpTzir = struct {	...	@@ -2374,1052 +1856,14 @@ const DumpTzir = struct {
2374	}	1856	}
2375	};	1857	};
2376		1858
2377	const EmitZIR = struct {
2378	allocator: *Allocator,
2379	arena: std.heap.ArenaAllocator,
2380	old_module: *const IrModule,
2381	decls: std.ArrayListUnmanaged(*Decl),
2382	names: std.StringArrayHashMap(void),
2383	next_auto_name: usize,
2384	primitive_table: std.AutoHashMap(Inst.Primitive.Builtin, *Decl),
2385	indent: usize,
2386	block_table: std.AutoHashMap(ir.Inst.Block, Inst.Block),
2387	loop_table: std.AutoHashMap(ir.Inst.Loop, Inst.Loop),
2388	metadata: std.AutoHashMap(*Inst, Module.MetaData),
2389	body_metadata: std.AutoHashMap(*Module.Body, Module.BodyMetaData),
2390
2391	fn emit(self: *EmitZIR) !void {
2392	// Put all the Decls in a list and sort them by name to avoid nondeterminism introduced
2393	// by the hash table.
2394	var src_decls = std.ArrayList(*IrModule.Decl).init(self.allocator);
2395	defer src_decls.deinit();
2396	try src_decls.ensureCapacity(self.old_module.decl_table.items().len);
2397	try self.decls.ensureCapacity(self.allocator, self.old_module.decl_table.items().len);
2398	try self.names.ensureCapacity(self.old_module.decl_table.items().len);
2399
2400	for (self.old_module.decl_table.items()) \|entry\| {
2401	const decl = entry.value;
2402	src_decls.appendAssumeCapacity(decl);
2403	self.names.putAssumeCapacityNoClobber(mem.spanZ(decl.name), {});
2404	}
2405	std.sort.sort(*IrModule.Decl, src_decls.items, {}, (struct {
2406	fn lessThan(context: void, a: IrModule.Decl, b: IrModule.Decl) bool {
2407	return a.src_index < b.src_index;
2408	}
2409	}).lessThan);
2410
2411	// Emit all the decls.
2412	for (src_decls.items) \|ir_decl\| {
2413	switch (ir_decl.analysis) {
2414	.unreferenced => continue,
2415
2416	.complete => {},
2417	.codegen_failure => {}, // We still can emit the ZIR.
2418	.codegen_failure_retryable => {}, // We still can emit the ZIR.
2419
2420	.in_progress => unreachable,
2421	.outdated => unreachable,
2422
2423	.sema_failure,
2424	.sema_failure_retryable,
2425	.dependency_failure,
2426	=> if (self.old_module.failed_decls.get(ir_decl)) \|err_msg\| {
2427	const fail_inst = try self.arena.allocator.create(Inst.UnOp);
2428	fail_inst.* = .{
2429	.base = .{
2430	.src = ir_decl.src(),
2431	.tag = .compileerror,
2432	},
2433	.positionals = .{
2434	.operand = blk: {
2435	const msg_str = try self.arena.allocator.dupe(u8, err_msg.msg);
2436
2437	const str_inst = try self.arena.allocator.create(Inst.Str);
2438	str_inst.* = .{
2439	.base = .{
2440	.src = ir_decl.src(),
2441	.tag = Inst.Str.base_tag,
2442	},
2443	.positionals = .{
2444	.bytes = err_msg.msg,
2445	},
2446	.kw_args = .{},
2447	};
2448	break :blk &str_inst.base;
2449	},
2450	},
2451	.kw_args = .{},
2452	};
2453	const decl = try self.arena.allocator.create(Decl);
2454	decl.* = .{
2455	.name = mem.spanZ(ir_decl.name),
2456	.contents_hash = undefined,
2457	.inst = &fail_inst.base,
2458	};
2459	try self.decls.append(self.allocator, decl);
2460	continue;
2461	},
2462	}
2463	if (self.old_module.export_owners.get(ir_decl)) \|exports\| {
2464	for (exports) \|module_export\| {
2465	const symbol_name = try self.emitStringLiteral(module_export.src, module_export.options.name);
2466	const export_inst = try self.arena.allocator.create(Inst.Export);
2467	export_inst.* = .{
2468	.base = .{
2469	.src = module_export.src,
2470	.tag = Inst.Export.base_tag,
2471	},
2472	.positionals = .{
2473	.symbol_name = symbol_name.inst,
2474	.decl_name = mem.spanZ(module_export.exported_decl.name),
2475	},
2476	.kw_args = .{},
2477	};
2478	_ = try self.emitUnnamedDecl(&export_inst.base);
2479	}
2480	}
2481	const new_decl = try self.emitTypedValue(ir_decl.src(), ir_decl.typed_value.most_recent.typed_value);
2482	new_decl.name = try self.arena.allocator.dupe(u8, mem.spanZ(ir_decl.name));
2483	}
2484	}
2485
2486	const ZirBody = struct {
2487	inst_table: std.AutoHashMap(ir.Inst, *Inst),
2488	instructions: std.ArrayList(Inst),
2489	};
2490
2491	fn resolveInst(self: EmitZIR, new_body: ZirBody, inst: ir.Inst) !*Inst {
2492	if (inst.cast(ir.Inst.Constant)) \|const_inst\| {
2493	const new_inst = if (const_inst.val.castTag(.function)) \|func_pl\| blk: {
2494	const owner_decl = func_pl.data.owner_decl;
2495	break :blk try self.emitDeclVal(inst.src, mem.spanZ(owner_decl.name));
2496	} else if (const_inst.val.castTag(.decl_ref)) \|declref\| blk: {
2497	const decl_ref = try self.emitDeclRef(inst.src, declref.data);
2498	try new_body.instructions.append(decl_ref);
2499	break :blk decl_ref;
2500	} else if (const_inst.val.castTag(.variable)) \|var_pl\| blk: {
2501	const owner_decl = var_pl.data.owner_decl;
2502	break :blk try self.emitDeclVal(inst.src, mem.spanZ(owner_decl.name));
2503	} else blk: {
2504	break :blk (try self.emitTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val })).inst;
2505	};
2506	_ = try new_body.inst_table.put(inst, new_inst);
2507	return new_inst;
2508	} else {
2509	return new_body.inst_table.get(inst).?;
2510	}
2511	}
2512
2513	fn emitDeclVal(self: EmitZIR, src: usize, decl_name: []const u8) !Inst {
2514	const declval = try self.arena.allocator.create(Inst.DeclVal);
2515	declval.* = .{
2516	.base = .{
2517	.src = src,
2518	.tag = Inst.DeclVal.base_tag,
2519	},
2520	.positionals = .{ .name = try self.arena.allocator.dupe(u8, decl_name) },
2521	.kw_args = .{},
2522	};
2523	return &declval.base;
2524	}
2525
2526	fn emitComptimeIntVal(self: EmitZIR, src: usize, val: Value) !Decl {
2527	const big_int_space = try self.arena.allocator.create(Value.BigIntSpace);
2528	const int_inst = try self.arena.allocator.create(Inst.Int);
2529	int_inst.* = .{
2530	.base = .{
2531	.src = src,
2532	.tag = Inst.Int.base_tag,
2533	},
2534	.positionals = .{
2535	.int = val.toBigInt(big_int_space),
2536	},
2537	.kw_args = .{},
2538	};
2539	return self.emitUnnamedDecl(&int_inst.base);
2540	}
2541
2542	fn emitDeclRef(self: EmitZIR, src: usize, module_decl: IrModule.Decl) !*Inst {
2543	const declref_inst = try self.arena.allocator.create(Inst.DeclRef);
2544	declref_inst.* = .{
2545	.base = .{
2546	.src = src,
2547	.tag = Inst.DeclRef.base_tag,
2548	},
2549	.positionals = .{
2550	.name = mem.spanZ(module_decl.name),
2551	},
2552	.kw_args = .{},
2553	};
2554	return &declref_inst.base;
2555	}
2556
2557	fn emitFn(self: EmitZIR, module_fn: IrModule.Fn, src: usize, ty: Type) Allocator.Error!*Decl {
2558	var inst_table = std.AutoHashMap(ir.Inst, Inst).init(self.allocator);
2559	defer inst_table.deinit();
2560
2561	var instructions = std.ArrayList(*Inst).init(self.allocator);
2562	defer instructions.deinit();
2563
2564	switch (module_fn.state) {
2565	.queued => unreachable,
2566	.in_progress => unreachable,
2567	.inline_only => unreachable,
2568	.success => {
2569	try self.emitBody(module_fn.body, &inst_table, &instructions);
2570	},
2571	.sema_failure => {
2572	const err_msg = self.old_module.failed_decls.get(module_fn.owner_decl).?;
2573	const fail_inst = try self.arena.allocator.create(Inst.UnOp);
2574	fail_inst.* = .{
2575	.base = .{
2576	.src = src,
2577	.tag = .compileerror,
2578	},
2579	.positionals = .{
2580	.operand = blk: {
2581	const msg_str = try self.arena.allocator.dupe(u8, err_msg.msg);
2582
2583	const str_inst = try self.arena.allocator.create(Inst.Str);
2584	str_inst.* = .{
2585	.base = .{
2586	.src = src,
2587	.tag = Inst.Str.base_tag,
2588	},
2589	.positionals = .{
2590	.bytes = msg_str,
2591	},
2592	.kw_args = .{},
2593	};
2594	break :blk &str_inst.base;
2595	},
2596	},
2597	.kw_args = .{},
2598	};
2599	try instructions.append(&fail_inst.base);
2600	},
2601	.dependency_failure => {
2602	const fail_inst = try self.arena.allocator.create(Inst.UnOp);
2603	fail_inst.* = .{
2604	.base = .{
2605	.src = src,
2606	.tag = .compileerror,
2607	},
2608	.positionals = .{
2609	.operand = blk: {
2610	const msg_str = try self.arena.allocator.dupe(u8, "depends on another failed Decl");
2611
2612	const str_inst = try self.arena.allocator.create(Inst.Str);
2613	str_inst.* = .{
2614	.base = .{
2615	.src = src,
2616	.tag = Inst.Str.base_tag,
2617	},
2618	.positionals = .{
2619	.bytes = msg_str,
2620	},
2621	.kw_args = .{},
2622	};
2623	break :blk &str_inst.base;
2624	},
2625	},
2626	.kw_args = .{},
2627	};
2628	try instructions.append(&fail_inst.base);
2629	},
2630	}
2631
2632	const fn_type = try self.emitType(src, ty);
2633
2634	const arena_instrs = try self.arena.allocator.alloc(*Inst, instructions.items.len);
2635	mem.copy(*Inst, arena_instrs, instructions.items);
2636
2637	const fn_inst = try self.arena.allocator.create(Inst.Fn);
2638	fn_inst.* = .{
2639	.base = .{
2640	.src = src,
2641	.tag = Inst.Fn.base_tag,
2642	},
2643	.positionals = .{
2644	.fn_type = fn_type.inst,
2645	.body = .{ .instructions = arena_instrs },
2646	},
2647	.kw_args = .{
2648	.is_inline = module_fn.state == .inline_only,
2649	},
2650	};
2651	return self.emitUnnamedDecl(&fn_inst.base);
2652	}
2653
2654	fn emitTypedValue(self: EmitZIR, src: usize, typed_value: TypedValue) Allocator.Error!Decl {
2655	const allocator = &self.arena.allocator;
2656	if (typed_value.val.castTag(.decl_ref)) \|decl_ref\| {
2657	const decl = decl_ref.data;
2658	return try self.emitUnnamedDecl(try self.emitDeclRef(src, decl));
2659	} else if (typed_value.val.castTag(.variable)) \|variable\| {
2660	return self.emitTypedValue(src, .{
2661	.ty = typed_value.ty,
2662	.val = variable.data.init,
2663	});
2664	}
2665	if (typed_value.val.isUndef()) {
2666	const as_inst = try self.arena.allocator.create(Inst.BinOp);
2667	as_inst.* = .{
2668	.base = .{
2669	.tag = .as,
2670	.src = src,
2671	},
2672	.positionals = .{
2673	.lhs = (try self.emitType(src, typed_value.ty)).inst,
2674	.rhs = (try self.emitPrimitive(src, .@"undefined")).inst,
2675	},
2676	.kw_args = .{},
2677	};
2678	return self.emitUnnamedDecl(&as_inst.base);
2679	}
2680	switch (typed_value.ty.zigTypeTag()) {
2681	.Pointer => {
2682	const ptr_elem_type = typed_value.ty.elemType();
2683	switch (ptr_elem_type.zigTypeTag()) {
2684	.Array => {
2685	// TODO more checks to make sure this can be emitted as a string literal
2686	//const array_elem_type = ptr_elem_type.elemType();
2687	//if (array_elem_type.eql(Type.initTag(.u8)) and
2688	// ptr_elem_type.hasSentinel(Value.initTag(.zero)))
2689	//{
2690	//}
2691	const bytes = typed_value.val.toAllocatedBytes(allocator) catch \|err\| switch (err) {
2692	error.AnalysisFail => unreachable,
2693	else => \|e\| return e,
2694	};
2695	return self.emitStringLiteral(src, bytes);
2696	},
2697	else => \|t\| std.debug.panic("TODO implement emitTypedValue for pointer to {s}", .{@tagName(t)}),
2698	}
2699	},
2700	.ComptimeInt => return self.emitComptimeIntVal(src, typed_value.val),
2701	.Int => {
2702	const as_inst = try self.arena.allocator.create(Inst.BinOp);
2703	as_inst.* = .{
2704	.base = .{
2705	.tag = .as,
2706	.src = src,
2707	},
2708	.positionals = .{
2709	.lhs = (try self.emitType(src, typed_value.ty)).inst,
2710	.rhs = (try self.emitComptimeIntVal(src, typed_value.val)).inst,
2711	},
2712	.kw_args = .{},
2713	};
2714	return self.emitUnnamedDecl(&as_inst.base);
2715	},
2716	.Type => {
2717	const ty = try typed_value.val.toType(&self.arena.allocator);
2718	return self.emitType(src, ty);
2719	},
2720	.Fn => {
2721	const module_fn = typed_value.val.castTag(.function).?.data;
2722	return self.emitFn(module_fn, src, typed_value.ty);
2723	},
2724	.Array => {
2725	// TODO more checks to make sure this can be emitted as a string literal
2726	//const array_elem_type = ptr_elem_type.elemType();
2727	//if (array_elem_type.eql(Type.initTag(.u8)) and
2728	// ptr_elem_type.hasSentinel(Value.initTag(.zero)))
2729	//{
2730	//}
2731	const bytes = typed_value.val.toAllocatedBytes(allocator) catch \|err\| switch (err) {
2732	error.AnalysisFail => unreachable,
2733	else => \|e\| return e,
2734	};
2735	const str_inst = try self.arena.allocator.create(Inst.Str);
2736	str_inst.* = .{
2737	.base = .{
2738	.src = src,
2739	.tag = Inst.Str.base_tag,
2740	},
2741	.positionals = .{
2742	.bytes = bytes,
2743	},
2744	.kw_args = .{},
2745	};
2746	return self.emitUnnamedDecl(&str_inst.base);
2747	},
2748	.Void => return self.emitPrimitive(src, .void_value),
2749	.Bool => if (typed_value.val.toBool())
2750	return self.emitPrimitive(src, .@"true")
2751	else
2752	return self.emitPrimitive(src, .@"false"),
2753	.EnumLiteral => {
2754	const enum_literal = typed_value.val.castTag(.enum_literal).?;
2755	const inst = try self.arena.allocator.create(Inst.Str);
2756	inst.* = .{
2757	.base = .{
2758	.src = src,
2759	.tag = .enum_literal,
2760	},
2761	.positionals = .{
2762	.bytes = enum_literal.data,
2763	},
2764	.kw_args = .{},
2765	};
2766	return self.emitUnnamedDecl(&inst.base);
2767	},
2768	else => \|t\| std.debug.panic("TODO implement emitTypedValue for {s}", .{@tagName(t)}),
2769	}
2770	}
2771
2772	fn emitNoOp(self: EmitZIR, src: usize, old_inst: ir.Inst.NoOp, tag: Inst.Tag) Allocator.Error!*Inst {
2773	const new_inst = try self.arena.allocator.create(Inst.NoOp);
2774	new_inst.* = .{
2775	.base = .{
2776	.src = src,
2777	.tag = tag,
2778	},
2779	.positionals = .{},
2780	.kw_args = .{},
2781	};
2782	return &new_inst.base;
2783	}
2784
2785	fn emitUnOp(
2786	self: *EmitZIR,
2787	src: usize,
2788	new_body: ZirBody,
2789	old_inst: *ir.Inst.UnOp,
2790	tag: Inst.Tag,
2791	) Allocator.Error!*Inst {
2792	const new_inst = try self.arena.allocator.create(Inst.UnOp);
2793	new_inst.* = .{
2794	.base = .{
2795	.src = src,
2796	.tag = tag,
2797	},
2798	.positionals = .{
2799	.operand = try self.resolveInst(new_body, old_inst.operand),
2800	},
2801	.kw_args = .{},
2802	};
2803	return &new_inst.base;
2804	}
2805
2806	fn emitBinOp(
2807	self: *EmitZIR,
2808	src: usize,
2809	new_body: ZirBody,
2810	old_inst: *ir.Inst.BinOp,
2811	tag: Inst.Tag,
2812	) Allocator.Error!*Inst {
2813	const new_inst = try self.arena.allocator.create(Inst.BinOp);
2814	new_inst.* = .{
2815	.base = .{
2816	.src = src,
2817	.tag = tag,
2818	},
2819	.positionals = .{
2820	.lhs = try self.resolveInst(new_body, old_inst.lhs),
2821	.rhs = try self.resolveInst(new_body, old_inst.rhs),
2822	},
2823	.kw_args = .{},
2824	};
2825	return &new_inst.base;
2826	}
2827
2828	fn emitCast(
2829	self: *EmitZIR,
2830	src: usize,
2831	new_body: ZirBody,
2832	old_inst: *ir.Inst.UnOp,
2833	tag: Inst.Tag,
2834	) Allocator.Error!*Inst {
2835	const new_inst = try self.arena.allocator.create(Inst.BinOp);
2836	new_inst.* = .{
2837	.base = .{
2838	.src = src,
2839	.tag = tag,
2840	},
2841	.positionals = .{
2842	.lhs = (try self.emitType(old_inst.base.src, old_inst.base.ty)).inst,
2843	.rhs = try self.resolveInst(new_body, old_inst.operand),
2844	},
2845	.kw_args = .{},
2846	};
2847	return &new_inst.base;
2848	}
2849
2850	fn emitBody(
2851	self: *EmitZIR,
2852	body: ir.Body,
2853	inst_table: std.AutoHashMap(ir.Inst, *Inst),
2854	instructions: std.ArrayList(Inst),
2855	) Allocator.Error!void {
2856	const new_body = ZirBody{
2857	.inst_table = inst_table,
2858	.instructions = instructions,
2859	};
2860	for (body.instructions) \|inst\| {
2861	const new_inst = switch (inst.tag) {
2862	.constant => unreachable, // excluded from function bodies
2863
2864	.breakpoint => try self.emitNoOp(inst.src, inst.castTag(.breakpoint).?, .breakpoint),
2865	.unreach => try self.emitNoOp(inst.src, inst.castTag(.unreach).?, .unreach_nocheck),
2866	.retvoid => try self.emitNoOp(inst.src, inst.castTag(.retvoid).?, .returnvoid),
2867	.dbg_stmt => try self.emitNoOp(inst.src, inst.castTag(.dbg_stmt).?, .dbg_stmt),
2868
2869	.not => try self.emitUnOp(inst.src, new_body, inst.castTag(.not).?, .boolnot),
2870	.ret => try self.emitUnOp(inst.src, new_body, inst.castTag(.ret).?, .@"return"),
2871	.ptrtoint => try self.emitUnOp(inst.src, new_body, inst.castTag(.ptrtoint).?, .ptrtoint),
2872	.isnull => try self.emitUnOp(inst.src, new_body, inst.castTag(.isnull).?, .isnull),
2873	.isnonnull => try self.emitUnOp(inst.src, new_body, inst.castTag(.isnonnull).?, .isnonnull),
2874	.iserr => try self.emitUnOp(inst.src, new_body, inst.castTag(.iserr).?, .iserr),
2875	.load => try self.emitUnOp(inst.src, new_body, inst.castTag(.load).?, .deref),
2876	.ref => try self.emitUnOp(inst.src, new_body, inst.castTag(.ref).?, .ref),
2877	.unwrap_optional => try self.emitUnOp(inst.src, new_body, inst.castTag(.unwrap_optional).?, .unwrap_optional_unsafe),
2878	.wrap_optional => try self.emitCast(inst.src, new_body, inst.castTag(.wrap_optional).?, .as),
2879
2880	.add => try self.emitBinOp(inst.src, new_body, inst.castTag(.add).?, .add),
2881	.sub => try self.emitBinOp(inst.src, new_body, inst.castTag(.sub).?, .sub),
2882	.store => try self.emitBinOp(inst.src, new_body, inst.castTag(.store).?, .store),
2883	.cmp_lt => try self.emitBinOp(inst.src, new_body, inst.castTag(.cmp_lt).?, .cmp_lt),
2884	.cmp_lte => try self.emitBinOp(inst.src, new_body, inst.castTag(.cmp_lte).?, .cmp_lte),
2885	.cmp_eq => try self.emitBinOp(inst.src, new_body, inst.castTag(.cmp_eq).?, .cmp_eq),
2886	.cmp_gte => try self.emitBinOp(inst.src, new_body, inst.castTag(.cmp_gte).?, .cmp_gte),
2887	.cmp_gt => try self.emitBinOp(inst.src, new_body, inst.castTag(.cmp_gt).?, .cmp_gt),
2888	.cmp_neq => try self.emitBinOp(inst.src, new_body, inst.castTag(.cmp_neq).?, .cmp_neq),
2889	.booland => try self.emitBinOp(inst.src, new_body, inst.castTag(.booland).?, .booland),
2890	.boolor => try self.emitBinOp(inst.src, new_body, inst.castTag(.boolor).?, .boolor),
2891	.bitand => try self.emitBinOp(inst.src, new_body, inst.castTag(.bitand).?, .bitand),
2892	.bitor => try self.emitBinOp(inst.src, new_body, inst.castTag(.bitor).?, .bitor),
2893	.xor => try self.emitBinOp(inst.src, new_body, inst.castTag(.xor).?, .xor),
2894
2895	.bitcast => try self.emitCast(inst.src, new_body, inst.castTag(.bitcast).?, .bitcast),
2896	.intcast => try self.emitCast(inst.src, new_body, inst.castTag(.intcast).?, .intcast),
2897	.floatcast => try self.emitCast(inst.src, new_body, inst.castTag(.floatcast).?, .floatcast),
2898
2899	.alloc => blk: {
2900	const new_inst = try self.arena.allocator.create(Inst.UnOp);
2901	new_inst.* = .{
2902	.base = .{
2903	.src = inst.src,
2904	.tag = .alloc,
2905	},
2906	.positionals = .{
2907	.operand = (try self.emitType(inst.src, inst.ty)).inst,
2908	},
2909	.kw_args = .{},
2910	};
2911	break :blk &new_inst.base;
2912	},
2913
2914	.arg => blk: {
2915	const old_inst = inst.castTag(.arg).?;
2916	const new_inst = try self.arena.allocator.create(Inst.Arg);
2917	new_inst.* = .{
2918	.base = .{
2919	.src = inst.src,
2920	.tag = .arg,
2921	},
2922	.positionals = .{
2923	.name = try self.arena.allocator.dupe(u8, mem.spanZ(old_inst.name)),
2924	},
2925	.kw_args = .{},
2926	};
2927	break :blk &new_inst.base;
2928	},
2929
2930	.block => blk: {
2931	const old_inst = inst.castTag(.block).?;
2932	const new_inst = try self.arena.allocator.create(Inst.Block);
2933
2934	try self.block_table.put(old_inst, new_inst);
2935
2936	var block_body = std.ArrayList(*Inst).init(self.allocator);
2937	defer block_body.deinit();
2938
2939	try self.emitBody(old_inst.body, inst_table, &block_body);
2940
2941	new_inst.* = .{
2942	.base = .{
2943	.src = inst.src,
2944	.tag = Inst.Block.base_tag,
2945	},
2946	.positionals = .{
2947	.body = .{ .instructions = block_body.toOwnedSlice() },
2948	},
2949	.kw_args = .{},
2950	};
2951
2952	break :blk &new_inst.base;
2953	},
2954
2955	.loop => blk: {
2956	const old_inst = inst.castTag(.loop).?;
2957	const new_inst = try self.arena.allocator.create(Inst.Loop);
2958
2959	try self.loop_table.put(old_inst, new_inst);
2960
2961	var loop_body = std.ArrayList(*Inst).init(self.allocator);
2962	defer loop_body.deinit();
2963
2964	try self.emitBody(old_inst.body, inst_table, &loop_body);
2965
2966	new_inst.* = .{
2967	.base = .{
2968	.src = inst.src,
2969	.tag = Inst.Loop.base_tag,
2970	},
2971	.positionals = .{
2972	.body = .{ .instructions = loop_body.toOwnedSlice() },
2973	},
2974	.kw_args = .{},
2975	};
2976
2977	break :blk &new_inst.base;
2978	},
2979
2980	.brvoid => blk: {
2981	const old_inst = inst.cast(ir.Inst.BrVoid).?;
2982	const new_block = self.block_table.get(old_inst.block).?;
2983	const new_inst = try self.arena.allocator.create(Inst.BreakVoid);
2984	new_inst.* = .{
2985	.base = .{
2986	.src = inst.src,
2987	.tag = Inst.BreakVoid.base_tag,
2988	},
2989	.positionals = .{
2990	.block = new_block,
2991	},
2992	.kw_args = .{},
2993	};
2994	break :blk &new_inst.base;
2995	},
2996
2997	.br => blk: {
2998	const old_inst = inst.castTag(.br).?;
2999	const new_block = self.block_table.get(old_inst.block).?;
3000	const new_inst = try self.arena.allocator.create(Inst.Break);
3001	new_inst.* = .{
3002	.base = .{
3003	.src = inst.src,
3004	.tag = Inst.Break.base_tag,
3005	},
3006	.positionals = .{
3007	.block = new_block,
3008	.operand = try self.resolveInst(new_body, old_inst.operand),
3009	},
3010	.kw_args = .{},
3011	};
3012	break :blk &new_inst.base;
3013	},
3014
3015	.call => blk: {
3016	const old_inst = inst.castTag(.call).?;
3017	const new_inst = try self.arena.allocator.create(Inst.Call);
3018
3019	const args = try self.arena.allocator.alloc(*Inst, old_inst.args.len);
3020	for (args) \|*elem, i\| {
3021	elem.* = try self.resolveInst(new_body, old_inst.args[i]);
3022	}
3023	new_inst.* = .{
3024	.base = .{
3025	.src = inst.src,
3026	.tag = Inst.Call.base_tag,
3027	},
3028	.positionals = .{
3029	.func = try self.resolveInst(new_body, old_inst.func),
3030	.args = args,
3031	},
3032	.kw_args = .{},
3033	};
3034	break :blk &new_inst.base;
3035	},
3036
3037	.assembly => blk: {
3038	const old_inst = inst.castTag(.assembly).?;
3039	const new_inst = try self.arena.allocator.create(Inst.Asm);
3040
3041	const inputs = try self.arena.allocator.alloc(*Inst, old_inst.inputs.len);
3042	for (inputs) \|*elem, i\| {
3043	elem.* = (try self.emitStringLiteral(inst.src, old_inst.inputs[i])).inst;
3044	}
3045
3046	const clobbers = try self.arena.allocator.alloc(*Inst, old_inst.clobbers.len);
3047	for (clobbers) \|*elem, i\| {
3048	elem.* = (try self.emitStringLiteral(inst.src, old_inst.clobbers[i])).inst;
3049	}
3050
3051	const args = try self.arena.allocator.alloc(*Inst, old_inst.args.len);
3052	for (args) \|*elem, i\| {
3053	elem.* = try self.resolveInst(new_body, old_inst.args[i]);
3054	}
3055
3056	new_inst.* = .{
3057	.base = .{
3058	.src = inst.src,
3059	.tag = Inst.Asm.base_tag,
3060	},
3061	.positionals = .{
3062	.asm_source = (try self.emitStringLiteral(inst.src, old_inst.asm_source)).inst,
3063	.return_type = (try self.emitType(inst.src, inst.ty)).inst,
3064	},
3065	.kw_args = .{
3066	.@"volatile" = old_inst.is_volatile,
3067	.output = if (old_inst.output) \|o\|
3068	(try self.emitStringLiteral(inst.src, o)).inst
3069	else
3070	null,
3071	.inputs = inputs,
3072	.clobbers = clobbers,
3073	.args = args,
3074	},
3075	};
3076	break :blk &new_inst.base;
3077	},
3078
3079	.condbr => blk: {
3080	const old_inst = inst.castTag(.condbr).?;
3081
3082	var then_body = std.ArrayList(*Inst).init(self.allocator);
3083	var else_body = std.ArrayList(*Inst).init(self.allocator);
3084
3085	defer then_body.deinit();
3086	defer else_body.deinit();
3087
3088	const then_deaths = try self.arena.allocator.alloc(*Inst, old_inst.thenDeaths().len);
3089	const else_deaths = try self.arena.allocator.alloc(*Inst, old_inst.elseDeaths().len);
3090
3091	for (old_inst.thenDeaths()) \|death, i\| {
3092	then_deaths[i] = try self.resolveInst(new_body, death);
3093	}
3094	for (old_inst.elseDeaths()) \|death, i\| {
3095	else_deaths[i] = try self.resolveInst(new_body, death);
3096	}
3097
3098	try self.emitBody(old_inst.then_body, inst_table, &then_body);
3099	try self.emitBody(old_inst.else_body, inst_table, &else_body);
3100
3101	const new_inst = try self.arena.allocator.create(Inst.CondBr);
3102
3103	try self.body_metadata.put(&new_inst.positionals.then_body, .{ .deaths = then_deaths });
3104	try self.body_metadata.put(&new_inst.positionals.else_body, .{ .deaths = else_deaths });
3105
3106	new_inst.* = .{
3107	.base = .{
3108	.src = inst.src,
3109	.tag = Inst.CondBr.base_tag,
3110	},
3111	.positionals = .{
3112	.condition = try self.resolveInst(new_body, old_inst.condition),
3113	.then_body = .{ .instructions = then_body.toOwnedSlice() },
3114	.else_body = .{ .instructions = else_body.toOwnedSlice() },
3115	},
3116	.kw_args = .{},
3117	};
3118	break :blk &new_inst.base;
3119	},
3120	.switchbr => blk: {
3121	const old_inst = inst.castTag(.switchbr).?;
3122	const cases = try self.arena.allocator.alloc(Inst.SwitchBr.Case, old_inst.cases.len);
3123	const new_inst = try self.arena.allocator.create(Inst.SwitchBr);
3124	new_inst.* = .{
3125	.base = .{
3126	.src = inst.src,
3127	.tag = Inst.SwitchBr.base_tag,
3128	},
3129	.positionals = .{
3130	.target_ptr = try self.resolveInst(new_body, old_inst.target_ptr),
3131	.cases = cases,
3132	.items = &[_]*Inst{}, // TODO this should actually be populated
3133	.else_body = undefined, // populated below
3134	},
3135	.kw_args = .{},
3136	};
3137
3138	var body_tmp = std.ArrayList(*Inst).init(self.allocator);
3139	defer body_tmp.deinit();
3140
3141	for (old_inst.cases) \|*case, i\| {
3142	body_tmp.items.len = 0;
3143
3144	const case_deaths = try self.arena.allocator.alloc(*Inst, old_inst.caseDeaths(i).len);
3145	for (old_inst.caseDeaths(i)) \|death, j\| {
3146	case_deaths[j] = try self.resolveInst(new_body, death);
3147	}
3148	try self.body_metadata.put(&cases[i].body, .{ .deaths = case_deaths });
3149
3150	try self.emitBody(case.body, inst_table, &body_tmp);
3151	const item = (try self.emitTypedValue(inst.src, .{
3152	.ty = old_inst.target_ptr.ty.elemType(),
3153	.val = case.item,
3154	})).inst;
3155
3156	cases[i] = .{
3157	.item = item,
3158	.body = .{ .instructions = try self.arena.allocator.dupe(*Inst, body_tmp.items) },
3159	};
3160	}
3161	{ // else
3162	const else_deaths = try self.arena.allocator.alloc(*Inst, old_inst.elseDeaths().len);
3163	for (old_inst.elseDeaths()) \|death, j\| {
3164	else_deaths[j] = try self.resolveInst(new_body, death);
3165	}
3166	try self.body_metadata.put(&new_inst.positionals.else_body, .{ .deaths = else_deaths });
3167
3168	body_tmp.items.len = 0;
3169	try self.emitBody(old_inst.else_body, inst_table, &body_tmp);
3170	new_inst.positionals.else_body = .{
3171	.instructions = try self.arena.allocator.dupe(*Inst, body_tmp.items),
3172	};
3173	}
3174
3175	break :blk &new_inst.base;
3176	},
3177	.varptr => @panic("TODO"),
3178	};
3179	try self.metadata.put(new_inst, .{
3180	.deaths = inst.deaths,
3181	.addr = @ptrToInt(inst),
3182	});
3183	try instructions.append(new_inst);
3184	try inst_table.put(inst, new_inst);
3185	}
3186	}
3187
3188	fn emitType(self: EmitZIR, src: usize, ty: Type) Allocator.Error!Decl {
3189	switch (ty.tag()) {
3190	.i8 => return self.emitPrimitive(src, .i8),
3191	.u8 => return self.emitPrimitive(src, .u8),
3192	.i16 => return self.emitPrimitive(src, .i16),
3193	.u16 => return self.emitPrimitive(src, .u16),
3194	.i32 => return self.emitPrimitive(src, .i32),
3195	.u32 => return self.emitPrimitive(src, .u32),
3196	.i64 => return self.emitPrimitive(src, .i64),
3197	.u64 => return self.emitPrimitive(src, .u64),
3198	.isize => return self.emitPrimitive(src, .isize),
3199	.usize => return self.emitPrimitive(src, .usize),
3200	.c_short => return self.emitPrimitive(src, .c_short),
3201	.c_ushort => return self.emitPrimitive(src, .c_ushort),
3202	.c_int => return self.emitPrimitive(src, .c_int),
3203	.c_uint => return self.emitPrimitive(src, .c_uint),
3204	.c_long => return self.emitPrimitive(src, .c_long),
3205	.c_ulong => return self.emitPrimitive(src, .c_ulong),
3206	.c_longlong => return self.emitPrimitive(src, .c_longlong),
3207	.c_ulonglong => return self.emitPrimitive(src, .c_ulonglong),
3208	.c_longdouble => return self.emitPrimitive(src, .c_longdouble),
3209	.c_void => return self.emitPrimitive(src, .c_void),
3210	.f16 => return self.emitPrimitive(src, .f16),
3211	.f32 => return self.emitPrimitive(src, .f32),
3212	.f64 => return self.emitPrimitive(src, .f64),
3213	.f128 => return self.emitPrimitive(src, .f128),
3214	.anyerror => return self.emitPrimitive(src, .anyerror),
3215	else => switch (ty.zigTypeTag()) {
3216	.Bool => return self.emitPrimitive(src, .bool),
3217	.Void => return self.emitPrimitive(src, .void),
3218	.NoReturn => return self.emitPrimitive(src, .noreturn),
3219	.Type => return self.emitPrimitive(src, .type),
3220	.ComptimeInt => return self.emitPrimitive(src, .comptime_int),
3221	.ComptimeFloat => return self.emitPrimitive(src, .comptime_float),
3222	.Fn => {
3223	const param_types = try self.allocator.alloc(Type, ty.fnParamLen());
3224	defer self.allocator.free(param_types);
3225
3226	ty.fnParamTypes(param_types);
3227	const emitted_params = try self.arena.allocator.alloc(*Inst, param_types.len);
3228	for (param_types) \|param_type, i\| {
3229	emitted_params[i] = (try self.emitType(src, param_type)).inst;
3230	}
3231
3232	const fntype_inst = try self.arena.allocator.create(Inst.FnType);
3233	fntype_inst.* = .{
3234	.base = .{
3235	.src = src,
3236	.tag = Inst.FnType.base_tag,
3237	},
3238	.positionals = .{
3239	.param_types = emitted_params,
3240	.return_type = (try self.emitType(src, ty.fnReturnType())).inst,
3241	},
3242	.kw_args = .{
3243	.cc = ty.fnCallingConvention(),
3244	},
3245	};
3246	return self.emitUnnamedDecl(&fntype_inst.base);
3247	},
3248	.Int => {
3249	const info = ty.intInfo(self.old_module.getTarget());
3250	const signed = try self.emitPrimitive(src, switch (info.signedness) {
3251	.signed => .@"true",
3252	.unsigned => .@"false",
3253	});
3254	const bits_val = try Value.Tag.int_u64.create(&self.arena.allocator, info.bits);
3255	const bits = try self.emitComptimeIntVal(src, bits_val);
3256	const inttype_inst = try self.arena.allocator.create(Inst.IntType);
3257	inttype_inst.* = .{
3258	.base = .{
3259	.src = src,
3260	.tag = Inst.IntType.base_tag,
3261	},
3262	.positionals = .{
3263	.signed = signed.inst,
3264	.bits = bits.inst,
3265	},
3266	.kw_args = .{},
3267	};
3268	return self.emitUnnamedDecl(&inttype_inst.base);
3269	},
3270	.Pointer => {
3271	if (ty.isSinglePointer()) {
3272	const inst = try self.arena.allocator.create(Inst.UnOp);
3273	const tag: Inst.Tag = if (ty.isConstPtr()) .single_const_ptr_type else .single_mut_ptr_type;
3274	inst.* = .{
3275	.base = .{
3276	.src = src,
3277	.tag = tag,
3278	},
3279	.positionals = .{
3280	.operand = (try self.emitType(src, ty.elemType())).inst,
3281	},
3282	.kw_args = .{},
3283	};
3284	return self.emitUnnamedDecl(&inst.base);
3285	} else {
3286	std.debug.panic("TODO implement emitType for {}", .{ty});
3287	}
3288	},
3289	.Optional => {
3290	var buf: Type.Payload.ElemType = undefined;
3291	const inst = try self.arena.allocator.create(Inst.UnOp);
3292	inst.* = .{
3293	.base = .{
3294	.src = src,
3295	.tag = .optional_type,
3296	},
3297	.positionals = .{
3298	.operand = (try self.emitType(src, ty.optionalChild(&buf))).inst,
3299	},
3300	.kw_args = .{},
3301	};
3302	return self.emitUnnamedDecl(&inst.base);
3303	},
3304	.Array => {
3305	var len_pl = Value.Payload.U64{
3306	.base = .{ .tag = .int_u64 },
3307	.data = ty.arrayLen(),
3308	};
3309	const len = Value.initPayload(&len_pl.base);
3310
3311	const inst = if (ty.sentinel()) \|sentinel\| blk: {
3312	const inst = try self.arena.allocator.create(Inst.ArrayTypeSentinel);
3313	inst.* = .{
3314	.base = .{
3315	.src = src,
3316	.tag = .array_type,
3317	},
3318	.positionals = .{
3319	.len = (try self.emitTypedValue(src, .{
3320	.ty = Type.initTag(.usize),
3321	.val = len,
3322	})).inst,
3323	.sentinel = (try self.emitTypedValue(src, .{
3324	.ty = ty.elemType(),
3325	.val = sentinel,
3326	})).inst,
3327	.elem_type = (try self.emitType(src, ty.elemType())).inst,
3328	},
3329	.kw_args = .{},
3330	};
3331	break :blk &inst.base;
3332	} else blk: {
3333	const inst = try self.arena.allocator.create(Inst.BinOp);
3334	inst.* = .{
3335	.base = .{
3336	.src = src,
3337	.tag = .array_type,
3338	},
3339	.positionals = .{
3340	.lhs = (try self.emitTypedValue(src, .{
3341	.ty = Type.initTag(.usize),
3342	.val = len,
3343	})).inst,
3344	.rhs = (try self.emitType(src, ty.elemType())).inst,
3345	},
3346	.kw_args = .{},
3347	};
3348	break :blk &inst.base;
3349	};
3350	return self.emitUnnamedDecl(inst);
3351	},
3352	else => std.debug.panic("TODO implement emitType for {}", .{ty}),
3353	},
3354	}
3355	}
3356
3357	fn autoName(self: *EmitZIR) ![]u8 {
3358	while (true) {
3359	const proposed_name = try std.fmt.allocPrint(&self.arena.allocator, "unnamed${d}", .{self.next_auto_name});
3360	self.next_auto_name += 1;
3361	const gop = try self.names.getOrPut(proposed_name);
3362	if (!gop.found_existing) {
3363	gop.entry.value = {};
3364	return proposed_name;
3365	}
3366	}
3367	}
3368
3369	fn emitPrimitive(self: EmitZIR, src: usize, tag: Inst.Primitive.Builtin) !Decl {
3370	const gop = try self.primitive_table.getOrPut(tag);
3371	if (!gop.found_existing) {
3372	const primitive_inst = try self.arena.allocator.create(Inst.Primitive);
3373	primitive_inst.* = .{
3374	.base = .{
3375	.src = src,
3376	.tag = Inst.Primitive.base_tag,
3377	},
3378	.positionals = .{
3379	.tag = tag,
3380	},
3381	.kw_args = .{},
3382	};
3383	gop.entry.value = try self.emitUnnamedDecl(&primitive_inst.base);
3384	}
3385	return gop.entry.value;
3386	}
3387
3388	fn emitStringLiteral(self: EmitZIR, src: usize, str: []const u8) !Decl {
3389	const str_inst = try self.arena.allocator.create(Inst.Str);
3390	str_inst.* = .{
3391	.base = .{
3392	.src = src,
3393	.tag = Inst.Str.base_tag,
3394	},
3395	.positionals = .{
3396	.bytes = str,
3397	},
3398	.kw_args = .{},
3399	};
3400	return self.emitUnnamedDecl(&str_inst.base);
3401	}
3402
3403	fn emitUnnamedDecl(self: EmitZIR, inst: Inst) !*Decl {
3404	const decl = try self.arena.allocator.create(Decl);
3405	decl.* = .{
3406	.name = try self.autoName(),
3407	.contents_hash = undefined,
3408	.inst = inst,
3409	};
3410	try self.decls.append(self.allocator, decl);
3411	return decl;
3412	}
3413	};
3414
3415	/// For debugging purposes, like dumpFn but for unanalyzed zir blocks	1859	/// For debugging purposes, like dumpFn but for unanalyzed zir blocks
3416	pub fn dumpZir(allocator: Allocator, kind: []const u8, decl_name: [:0]const u8, instructions: []*Inst) !void {	1860	pub fn dumpZir(allocator: Allocator, kind: []const u8, decl_name: [:0]const u8, instructions: []*Inst) !void {
3417	var fib = std.heap.FixedBufferAllocator.init(&[_]u8{});	1861	var fib = std.heap.FixedBufferAllocator.init(&[_]u8{});
3418	var module = Module{	1862	var module = Module{
3419	.decls = &[_]*Decl{},	1863	.decls = &[_]*Module.Decl{},
3420	.arena = std.heap.ArenaAllocator.init(&fib.allocator),	1864	.arena = std.heap.ArenaAllocator.init(&fib.allocator),
3421	.metadata = std.AutoHashMap(*Inst, Module.MetaData).init(&fib.allocator),	1865	.metadata = std.AutoHashMap(*Inst, Module.MetaData).init(&fib.allocator),
3422	.body_metadata = std.AutoHashMap(*Module.Body, Module.BodyMetaData).init(&fib.allocator),	1866	.body_metadata = std.AutoHashMap(*Body, Module.BodyMetaData).init(&fib.allocator),
3423	};	1867	};
3424	var write = Writer{	1868	var write = Writer{
3425	.module = &module,	1869	.module = &module,

src/zir_sema.zig+47-132

...	@@ -63,7 +63,6 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!	...	@@ -63,7 +63,6 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!
63	.declref => return analyzeInstDeclRef(mod, scope, old_inst.castTag(.declref).?),	63	.declref => return analyzeInstDeclRef(mod, scope, old_inst.castTag(.declref).?),
64	.declref_str => return analyzeInstDeclRefStr(mod, scope, old_inst.castTag(.declref_str).?),	64	.declref_str => return analyzeInstDeclRefStr(mod, scope, old_inst.castTag(.declref_str).?),
65	.declval => return analyzeInstDeclVal(mod, scope, old_inst.castTag(.declval).?),	65	.declval => return analyzeInstDeclVal(mod, scope, old_inst.castTag(.declval).?),
66	.declval_in_module => return analyzeInstDeclValInModule(mod, scope, old_inst.castTag(.declval_in_module).?),
67	.ensure_result_used => return analyzeInstEnsureResultUsed(mod, scope, old_inst.castTag(.ensure_result_used).?),	66	.ensure_result_used => return analyzeInstEnsureResultUsed(mod, scope, old_inst.castTag(.ensure_result_used).?),
68	.ensure_result_non_error => return analyzeInstEnsureResultNonError(mod, scope, old_inst.castTag(.ensure_result_non_error).?),	67	.ensure_result_non_error => return analyzeInstEnsureResultNonError(mod, scope, old_inst.castTag(.ensure_result_non_error).?),
69	.ensure_indexable => return analyzeInstEnsureIndexable(mod, scope, old_inst.castTag(.ensure_indexable).?),	68	.ensure_indexable => return analyzeInstEnsureIndexable(mod, scope, old_inst.castTag(.ensure_indexable).?),
...	@@ -166,7 +165,7 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!	...	@@ -166,7 +165,7 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!
166	}	165	}
167	}	166	}
168		167
169	pub fn analyzeBody(mod: Module, block: Scope.Block, body: zir.Module.Body) !void {	168	pub fn analyzeBody(mod: Module, block: Scope.Block, body: zir.Body) !void {
170	const tracy = trace(@src());	169	const tracy = trace(@src());
171	defer tracy.end();	170	defer tracy.end();
172		171
...	@@ -183,7 +182,7 @@ pub fn analyzeBodyValueAsType(	...	@@ -183,7 +182,7 @@ pub fn analyzeBodyValueAsType(
183	mod: *Module,	182	mod: *Module,
184	block_scope: *Scope.Block,	183	block_scope: *Scope.Block,
185	zir_result_inst: *zir.Inst,	184	zir_result_inst: *zir.Inst,
186	body: zir.Module.Body,	185	body: zir.Body,
187	) !Type {	186	) !Type {
188	try analyzeBody(mod, block_scope, body);	187	try analyzeBody(mod, block_scope, body);
189	const result_inst = block_scope.inst_table.get(zir_result_inst).?;	188	const result_inst = block_scope.inst_table.get(zir_result_inst).?;
...	@@ -191,84 +190,6 @@ pub fn analyzeBodyValueAsType(	...	@@ -191,84 +190,6 @@ pub fn analyzeBodyValueAsType(
191	return val.toType(block_scope.base.arena());	190	return val.toType(block_scope.base.arena());
192	}	191	}
193		192
194	pub fn analyzeZirDecl(mod: Module, decl: Decl, src_decl: *zir.Decl) InnerError!bool {
195	var decl_scope: Scope.DeclAnalysis = .{
196	.decl = decl,
197	.arena = std.heap.ArenaAllocator.init(mod.gpa),
198	};
199	errdefer decl_scope.arena.deinit();
200
201	decl.analysis = .in_progress;
202
203	const typed_value = try analyzeConstInst(mod, &decl_scope.base, src_decl.inst);
204	const arena_state = try decl_scope.arena.allocator.create(std.heap.ArenaAllocator.State);
205
206	var prev_type_has_bits = false;
207	var type_changed = true;
208
209	if (decl.typedValueManaged()) \|tvm\| {
210	prev_type_has_bits = tvm.typed_value.ty.hasCodeGenBits();
211	type_changed = !tvm.typed_value.ty.eql(typed_value.ty);
212
213	tvm.deinit(mod.gpa);
214	}
215
216	arena_state.* = decl_scope.arena.state;
217	decl.typed_value = .{
218	.most_recent = .{
219	.typed_value = typed_value,
220	.arena = arena_state,
221	},
222	};
223	decl.analysis = .complete;
224	decl.generation = mod.generation;
225	if (typed_value.ty.hasCodeGenBits()) {
226	// We don't fully codegen the decl until later, but we do need to reserve a global
227	// offset table index for it. This allows us to codegen decls out of dependency order,
228	// increasing how many computations can be done in parallel.
229	try mod.comp.bin_file.allocateDeclIndexes(decl);
230	try mod.comp.work_queue.writeItem(.{ .codegen_decl = decl });
231	} else if (prev_type_has_bits) {
232	mod.comp.bin_file.freeDecl(decl);
233	}
234
235	return type_changed;
236	}
237
238	pub fn resolveZirDecl(mod: Module, scope: Scope, src_decl: zir.Decl) InnerError!Decl {
239	const zir_module = mod.root_scope.cast(Scope.ZIRModule).?;
240	const entry = zir_module.contents.module.findDecl(src_decl.name).?;
241	return resolveZirDeclHavingIndex(mod, scope, src_decl, entry.index);
242	}
243
244	fn resolveZirDeclHavingIndex(mod: Module, scope: Scope, src_decl: zir.Decl, src_index: usize) InnerError!Decl {
245	const name_hash = scope.namespace().fullyQualifiedNameHash(src_decl.name);
246	const decl = mod.decl_table.get(name_hash).?;
247	decl.src_index = src_index;
248	try mod.ensureDeclAnalyzed(decl);
249	return decl;
250	}
251
252	/// Declares a dependency on the decl.
253	fn resolveCompleteZirDecl(mod: Module, scope: Scope, src_decl: zir.Decl) InnerError!Decl {
254	const decl = try resolveZirDecl(mod, scope, src_decl);
255	switch (decl.analysis) {
256	.unreferenced => unreachable,
257	.in_progress => unreachable,
258	.outdated => unreachable,
259
260	.dependency_failure,
261	.sema_failure,
262	.sema_failure_retryable,
263	.codegen_failure,
264	.codegen_failure_retryable,
265	=> return error.AnalysisFail,
266
267	.complete => {},
268	}
269	return decl;
270	}
271
272	pub fn resolveInst(mod: Module, scope: Scope, zir_inst: zir.Inst) InnerError!Inst {	193	pub fn resolveInst(mod: Module, scope: Scope, zir_inst: zir.Inst) InnerError!Inst {
273	const block = scope.cast(Scope.Block).?;	194	const block = scope.cast(Scope.Block).?;
274	return block.inst_table.get(zir_inst).?; // Instruction does not dominate all uses!	195	return block.inst_table.get(zir_inst).?; // Instruction does not dominate all uses!
...	@@ -640,22 +561,28 @@ fn analyzeInstCompileError(mod: Module, scope: Scope, inst: *zir.Inst.UnOp) In	...	@@ -640,22 +561,28 @@ fn analyzeInstCompileError(mod: Module, scope: Scope, inst: *zir.Inst.UnOp) In
640	}	561	}
641		562
642	fn analyzeInstCompileLog(mod: Module, scope: Scope, inst: zir.Inst.CompileLog) InnerError!Inst {	563	fn analyzeInstCompileLog(mod: Module, scope: Scope, inst: zir.Inst.CompileLog) InnerError!Inst {
643	std.debug.print("\| ", .{});	564	var managed = mod.compile_log_text.toManaged(mod.gpa);
644	for (inst.positionals.to_log) \|item, i\| {	565	defer mod.compile_log_text = managed.moveToUnmanaged();
645	const to_log = try resolveInst(mod, scope, item);	566	const writer = managed.writer();
646	if (to_log.value()) \|val\| {	567
647	std.debug.print("{}", .{val});	568	for (inst.positionals.to_log) \|arg_inst, i\| {
		569	if (i != 0) try writer.print(", ", .{});
		570
		571	const arg = try resolveInst(mod, scope, arg_inst);
		572	if (arg.value()) \|val\| {
		573	try writer.print("@as({}, {})", .{ arg.ty, val });
648	} else {	574	} else {
649	std.debug.print("(runtime value)", .{});	575	try writer.print("@as({}, [runtime value])", .{arg.ty});
650	}	576	}
651	if (i != inst.positionals.to_log.len - 1) std.debug.print(", ", .{});
652	}	577	}
653	std.debug.print("\n", .{});	578	try writer.print("\n", .{});
654	if (!inst.kw_args.seen) {
655		579
656	// so that we do not give multiple compile errors if it gets evaled twice	580	const gop = try mod.compile_log_decls.getOrPut(mod.gpa, scope.ownerDecl().?);
657	inst.kw_args.seen = true;	581	if (!gop.found_existing) {
658	try mod.failCompileLog(scope, inst.base.src);	582	gop.entry.value = .{
		583	.file_scope = scope.getFileScope(),
		584	.byte_offset = inst.base.src,
		585	};
659	}	586	}
660	return mod.constVoid(scope, inst.base.src);	587	return mod.constVoid(scope, inst.base.src);
661	}	588	}
...	@@ -705,7 +632,8 @@ fn analyzeInstLoop(mod: Module, scope: Scope, inst: *zir.Inst.Loop) InnerError	...	@@ -705,7 +632,8 @@ fn analyzeInstLoop(mod: Module, scope: Scope, inst: *zir.Inst.Loop) InnerError
705	.parent = parent_block,	632	.parent = parent_block,
706	.inst_table = parent_block.inst_table,	633	.inst_table = parent_block.inst_table,
707	.func = parent_block.func,	634	.func = parent_block.func,
708	.decl = parent_block.decl,	635	.owner_decl = parent_block.owner_decl,
		636	.src_decl = parent_block.src_decl,
709	.instructions = .{},	637	.instructions = .{},
710	.arena = parent_block.arena,	638	.arena = parent_block.arena,
711	.inlining = parent_block.inlining,	639	.inlining = parent_block.inlining,
...	@@ -732,7 +660,8 @@ fn analyzeInstBlockFlat(mod: Module, scope: Scope, inst: *zir.Inst.Block, is_c	...	@@ -732,7 +660,8 @@ fn analyzeInstBlockFlat(mod: Module, scope: Scope, inst: *zir.Inst.Block, is_c
732	.parent = parent_block,	660	.parent = parent_block,
733	.inst_table = parent_block.inst_table,	661	.inst_table = parent_block.inst_table,
734	.func = parent_block.func,	662	.func = parent_block.func,
735	.decl = parent_block.decl,	663	.owner_decl = parent_block.owner_decl,
		664	.src_decl = parent_block.src_decl,
736	.instructions = .{},	665	.instructions = .{},
737	.arena = parent_block.arena,	666	.arena = parent_block.arena,
738	.label = null,	667	.label = null,
...	@@ -744,13 +673,14 @@ fn analyzeInstBlockFlat(mod: Module, scope: Scope, inst: *zir.Inst.Block, is_c	...	@@ -744,13 +673,14 @@ fn analyzeInstBlockFlat(mod: Module, scope: Scope, inst: *zir.Inst.Block, is_c
744		673
745	try analyzeBody(mod, &child_block, inst.positionals.body);	674	try analyzeBody(mod, &child_block, inst.positionals.body);
746		675
747	try parent_block.instructions.appendSlice(mod.gpa, child_block.instructions.items);	676	// Move the analyzed instructions into the parent block arena.
748		677	const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items);
749	// comptime blocks won't generate any runtime values	678	try parent_block.instructions.appendSlice(mod.gpa, copied_instructions);
750	if (child_block.instructions.items.len == 0)
751	return mod.constVoid(scope, inst.base.src);
752		679
753	return parent_block.instructions.items[parent_block.instructions.items.len - 1];	680	// The result of a flat block is the last instruction.
		681	const zir_inst_list = inst.positionals.body.instructions;
		682	const last_zir_inst = zir_inst_list[zir_inst_list.len - 1];
		683	return resolveInst(mod, scope, last_zir_inst);
754	}	684	}
755		685
756	fn analyzeInstBlock(mod: Module, scope: Scope, inst: zir.Inst.Block, is_comptime: bool) InnerError!Inst {	686	fn analyzeInstBlock(mod: Module, scope: Scope, inst: zir.Inst.Block, is_comptime: bool) InnerError!Inst {
...	@@ -775,7 +705,8 @@ fn analyzeInstBlock(mod: Module, scope: Scope, inst: *zir.Inst.Block, is_compt	...	@@ -775,7 +705,8 @@ fn analyzeInstBlock(mod: Module, scope: Scope, inst: *zir.Inst.Block, is_compt
775	.parent = parent_block,	705	.parent = parent_block,
776	.inst_table = parent_block.inst_table,	706	.inst_table = parent_block.inst_table,
777	.func = parent_block.func,	707	.func = parent_block.func,
778	.decl = parent_block.decl,	708	.owner_decl = parent_block.owner_decl,
		709	.src_decl = parent_block.src_decl,
779	.instructions = .{},	710	.instructions = .{},
780	.arena = parent_block.arena,	711	.arena = parent_block.arena,
781	// TODO @as here is working around a stage1 miscompilation bug :(	712	// TODO @as here is working around a stage1 miscompilation bug :(
...	@@ -890,22 +821,15 @@ fn analyzeInstDeclRefStr(mod: Module, scope: Scope, inst: *zir.Inst.DeclRefStr	...	@@ -890,22 +821,15 @@ fn analyzeInstDeclRefStr(mod: Module, scope: Scope, inst: *zir.Inst.DeclRefStr
890	fn analyzeInstDeclRef(mod: Module, scope: Scope, inst: zir.Inst.DeclRef) InnerError!Inst {	821	fn analyzeInstDeclRef(mod: Module, scope: Scope, inst: zir.Inst.DeclRef) InnerError!Inst {
891	const tracy = trace(@src());	822	const tracy = trace(@src());
892	defer tracy.end();	823	defer tracy.end();
893	return mod.analyzeDeclRefByName(scope, inst.base.src, inst.positionals.name);	824	return mod.analyzeDeclRef(scope, inst.base.src, inst.positionals.decl);
894	}	825	}
895		826
896	fn analyzeInstDeclVal(mod: Module, scope: Scope, inst: zir.Inst.DeclVal) InnerError!Inst {	827	fn analyzeInstDeclVal(mod: Module, scope: Scope, inst: zir.Inst.DeclVal) InnerError!Inst {
897	const tracy = trace(@src());	828	const tracy = trace(@src());
898	defer tracy.end();	829	defer tracy.end();
899	const decl = try analyzeDeclVal(mod, scope, inst);	830	const decl_ref = try mod.analyzeDeclRef(scope, inst.base.src, inst.positionals.decl);
900	const ptr = try mod.analyzeDeclRef(scope, inst.base.src, decl);	831	// TODO look into avoiding the call to analyzeDeref here
901	return mod.analyzeDeref(scope, inst.base.src, ptr, inst.base.src);	832	return mod.analyzeDeref(scope, inst.base.src, decl_ref, inst.base.src);
902	}
903
904	fn analyzeInstDeclValInModule(mod: Module, scope: Scope, inst: zir.Inst.DeclValInModule) InnerError!Inst {
905	const tracy = trace(@src());
906	defer tracy.end();
907	const decl = inst.positionals.decl;
908	return mod.analyzeDeclRef(scope, inst.base.src, decl);
909	}	833	}
910		834
911	fn analyzeInstCall(mod: Module, scope: Scope, inst: zir.Inst.Call) InnerError!Inst {	835	fn analyzeInstCall(mod: Module, scope: Scope, inst: zir.Inst.Call) InnerError!Inst {
...	@@ -1032,9 +956,8 @@ fn analyzeInstCall(mod: Module, scope: Scope, inst: *zir.Inst.Call) InnerError	...	@@ -1032,9 +956,8 @@ fn analyzeInstCall(mod: Module, scope: Scope, inst: *zir.Inst.Call) InnerError
1032	.parent = null,	956	.parent = null,
1033	.inst_table = &inst_table,	957	.inst_table = &inst_table,
1034	.func = module_fn,	958	.func = module_fn,
1035	// Note that we pass the caller's Decl, not the callee. This causes	959	.owner_decl = scope.ownerDecl().?,
1036	// compile errors to be attached (correctly) to the caller's Decl.	960	.src_decl = module_fn.owner_decl,
1037	.decl = scope.decl().?,
1038	.instructions = .{},	961	.instructions = .{},
1039	.arena = scope.arena(),	962	.arena = scope.arena(),
1040	.label = null,	963	.label = null,
...	@@ -1069,7 +992,7 @@ fn analyzeInstFn(mod: Module, scope: Scope, fn_inst: *zir.Inst.Fn) InnerError!	...	@@ -1069,7 +992,7 @@ fn analyzeInstFn(mod: Module, scope: Scope, fn_inst: *zir.Inst.Fn) InnerError!
1069	.state = if (fn_inst.kw_args.is_inline) .inline_only else .queued,	992	.state = if (fn_inst.kw_args.is_inline) .inline_only else .queued,
1070	.zir = fn_inst.positionals.body,	993	.zir = fn_inst.positionals.body,
1071	.body = undefined,	994	.body = undefined,
1072	.owner_decl = scope.decl().?,	995	.owner_decl = scope.ownerDecl().?,
1073	};	996	};
1074	return mod.constInst(scope, fn_inst.base.src, .{	997	return mod.constInst(scope, fn_inst.base.src, .{
1075	.ty = fn_type,	998	.ty = fn_type,
...	@@ -1391,7 +1314,7 @@ fn analyzeInstFieldPtr(mod: Module, scope: Scope, fieldptr: *zir.Inst.FieldPtr	...	@@ -1391,7 +1314,7 @@ fn analyzeInstFieldPtr(mod: Module, scope: Scope, fieldptr: *zir.Inst.FieldPtr
1391	return mod.analyzeDeclRef(scope, fieldptr.base.src, decl);	1314	return mod.analyzeDeclRef(scope, fieldptr.base.src, decl);
1392	}	1315	}
1393		1316
1394	if (&container_scope.file_scope.base == mod.root_scope) {	1317	if (container_scope.file_scope == mod.root_scope) {
1395	return mod.fail(scope, fieldptr.base.src, "root source file has no member called '{s}'", .{field_name});	1318	return mod.fail(scope, fieldptr.base.src, "root source file has no member called '{s}'", .{field_name});
1396	} else {	1319	} else {
1397	return mod.fail(scope, fieldptr.base.src, "container '{}' has no member called '{s}'", .{ child_type, field_name });	1320	return mod.fail(scope, fieldptr.base.src, "container '{}' has no member called '{s}'", .{ child_type, field_name });
...	@@ -1606,7 +1529,8 @@ fn analyzeInstSwitchBr(mod: Module, scope: Scope, inst: *zir.Inst.SwitchBr) In	...	@@ -1606,7 +1529,8 @@ fn analyzeInstSwitchBr(mod: Module, scope: Scope, inst: *zir.Inst.SwitchBr) In
1606	.parent = parent_block,	1529	.parent = parent_block,
1607	.inst_table = parent_block.inst_table,	1530	.inst_table = parent_block.inst_table,
1608	.func = parent_block.func,	1531	.func = parent_block.func,
1609	.decl = parent_block.decl,	1532	.owner_decl = parent_block.owner_decl,
		1533	.src_decl = parent_block.src_decl,
1610	.instructions = .{},	1534	.instructions = .{},
1611	.arena = parent_block.arena,	1535	.arena = parent_block.arena,
1612	.inlining = parent_block.inlining,	1536	.inlining = parent_block.inlining,
...	@@ -2182,7 +2106,8 @@ fn analyzeInstCondBr(mod: Module, scope: Scope, inst: *zir.Inst.CondBr) InnerE	...	@@ -2182,7 +2106,8 @@ fn analyzeInstCondBr(mod: Module, scope: Scope, inst: *zir.Inst.CondBr) InnerE
2182	.parent = parent_block,	2106	.parent = parent_block,
2183	.inst_table = parent_block.inst_table,	2107	.inst_table = parent_block.inst_table,
2184	.func = parent_block.func,	2108	.func = parent_block.func,
2185	.decl = parent_block.decl,	2109	.owner_decl = parent_block.owner_decl,
		2110	.src_decl = parent_block.src_decl,
2186	.instructions = .{},	2111	.instructions = .{},
2187	.arena = parent_block.arena,	2112	.arena = parent_block.arena,
2188	.inlining = parent_block.inlining,	2113	.inlining = parent_block.inlining,
...	@@ -2196,7 +2121,8 @@ fn analyzeInstCondBr(mod: Module, scope: Scope, inst: *zir.Inst.CondBr) InnerE	...	@@ -2196,7 +2121,8 @@ fn analyzeInstCondBr(mod: Module, scope: Scope, inst: *zir.Inst.CondBr) InnerE
2196	.parent = parent_block,	2121	.parent = parent_block,
2197	.inst_table = parent_block.inst_table,	2122	.inst_table = parent_block.inst_table,
2198	.func = parent_block.func,	2123	.func = parent_block.func,
2199	.decl = parent_block.decl,	2124	.owner_decl = parent_block.owner_decl,
		2125	.src_decl = parent_block.src_decl,
2200	.instructions = .{},	2126	.instructions = .{},
2201	.arena = parent_block.arena,	2127	.arena = parent_block.arena,
2202	.inlining = parent_block.inlining,	2128	.inlining = parent_block.inlining,
...	@@ -2294,17 +2220,6 @@ fn analyzeBreak(	...	@@ -2294,17 +2220,6 @@ fn analyzeBreak(
2294	} else unreachable;	2220	} else unreachable;
2295	}	2221	}
2296		2222
2297	fn analyzeDeclVal(mod: Module, scope: Scope, inst: zir.Inst.DeclVal) InnerError!Decl {
2298	const decl_name = inst.positionals.name;
2299	const zir_module = scope.namespace().cast(Scope.ZIRModule).?;
2300	const src_decl = zir_module.contents.module.findDecl(decl_name) orelse
2301	return mod.fail(scope, inst.base.src, "use of undeclared identifier '{s}'", .{decl_name});
2302
2303	const decl = try resolveCompleteZirDecl(mod, scope, src_decl.decl);
2304
2305	return decl;
2306	}
2307
2308	fn analyzeInstSimplePtrType(mod: Module, scope: Scope, inst: zir.Inst.UnOp, mutable: bool, size: std.builtin.TypeInfo.Pointer.Size) InnerError!Inst {	2223	fn analyzeInstSimplePtrType(mod: Module, scope: Scope, inst: zir.Inst.UnOp, mutable: bool, size: std.builtin.TypeInfo.Pointer.Size) InnerError!Inst {
2309	const tracy = trace(@src());	2224	const tracy = trace(@src());
2310	defer tracy.end();	2225	defer tracy.end();

test/stage2/test.zig+42-20

...	@@ -36,7 +36,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -36,7 +36,7 @@ pub fn addCases(ctx: *TestContext) !void {
36	{	36	{
37	var case = ctx.exe("hello world with updates", linux_x64);	37	var case = ctx.exe("hello world with updates", linux_x64);
38		38
39	case.addError("", &[_][]const u8{"no entry point found"});	39	case.addError("", &[_][]const u8{"error: no entry point found"});
40		40
41	// Incorrect return type	41	// Incorrect return type
42	case.addError(	42	case.addError(
...	@@ -147,7 +147,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -147,7 +147,7 @@ pub fn addCases(ctx: *TestContext) !void {
147		147
148	{	148	{
149	var case = ctx.exe("hello world with updates", macosx_x64);	149	var case = ctx.exe("hello world with updates", macosx_x64);
150	case.addError("", &[_][]const u8{"no entry point found"});	150	case.addError("", &[_][]const u8{"error: no entry point found"});
151		151
152	// Incorrect return type	152	// Incorrect return type
153	case.addError(	153	case.addError(
...	@@ -1243,24 +1243,46 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1243,24 +1243,46 @@ pub fn addCases(ctx: *TestContext) !void {
1243	\\}	1243	\\}
1244	, &[_][]const u8{":3:9: error: redefinition of 'testing'"});	1244	, &[_][]const u8{":3:9: error: redefinition of 'testing'"});
1245	}	1245	}
1246	ctx.compileError("compileLog", linux_x64,	1246
1247	\\export fn _start() noreturn {	1247	{
1248	\\ const b = true;	1248	// TODO make the test harness support checking the compile log output too
1249	\\ var f: u32 = 1;	1249	var case = ctx.obj("@compileLog", linux_x64);
1250	\\ @compileLog(b, 20, f, x);	1250	// The other compile error prevents emission of a "found compile log" statement.
1251	\\ @compileLog(1000);	1251	case.addError(
1252	\\ var bruh: usize = true;	1252	\\export fn _start() noreturn {
1253	\\ unreachable;	1253	\\ const b = true;
1254	\\}	1254	\\ var f: u32 = 1;
1255	\\fn x() void {}	1255	\\ @compileLog(b, 20, f, x);
1256	, &[_][]const u8{	1256	\\ @compileLog(1000);
1257	":4:3: error: found compile log statement",	1257	\\ var bruh: usize = true;
1258	":5:3: error: found compile log statement",	1258	\\ unreachable;
1259	":6:21: error: expected usize, found bool",	1259	\\}
1260	});	1260	\\export fn other() void {
1261	// TODO if this is here it invalidates the compile error checker:	1261	\\ @compileLog(1234);
1262	// "\| true, 20, (runtime value), (function)"	1262	\\}
1263	// "\| 1000"	1263	\\fn x() void {}
		1264	, &[_][]const u8{
		1265	":6:23: error: expected usize, found bool",
		1266	});
		1267
		1268	// Now only compile log statements remain. One per Decl.
		1269	case.addError(
		1270	\\export fn _start() noreturn {
		1271	\\ const b = true;
		1272	\\ var f: u32 = 1;
		1273	\\ @compileLog(b, 20, f, x);
		1274	\\ @compileLog(1000);
		1275	\\ unreachable;
		1276	\\}
		1277	\\export fn other() void {
		1278	\\ @compileLog(1234);
		1279	\\}
		1280	\\fn x() void {}
		1281	, &[_][]const u8{
		1282	":11:8: error: found compile log statement",
		1283	":4:5: note: also here",
		1284	});
		1285	}
1264		1286
1265	{	1287	{
1266	var case = ctx.obj("extern variable has no type", linux_x64);	1288	var case = ctx.obj("extern variable has no type", linux_x64);

...	@@ -670,7 +670,7 @@ pub fn updateDecl(self: Coff, module: Module, decl: *Module.Decl) !void {	...	@@ -670,7 +670,7 @@ pub fn updateDecl(self: Coff, module: Module, decl: *Module.Decl) !void {
670	var code_buffer = std.ArrayList(u8).init(self.base.allocator);	670	var code_buffer = std.ArrayList(u8).init(self.base.allocator);
671	defer code_buffer.deinit();	671	defer code_buffer.deinit();
672		672
673	const res = try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .none);	673	const res = try codegen.generateSymbol(&self.base, decl.srcLoc(), typed_value, &code_buffer, .none);
674	const code = switch (res) {	674	const code = switch (res) {
675	.externally_managed => \|x\| x,	675	.externally_managed => \|x\| x,
676	.appended => code_buffer.items,	676	.appended => code_buffer.items,
...	@@ -732,7 +732,7 @@ pub fn updateDeclExports(self: Coff, module: Module, decl: *const Module.Decl,	...	@@ -732,7 +732,7 @@ pub fn updateDeclExports(self: Coff, module: Module, decl: *const Module.Decl,
732	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);	732	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
733	module.failed_exports.putAssumeCapacityNoClobber(	733	module.failed_exports.putAssumeCapacityNoClobber(
734	exp,	734	exp,
735	try Compilation.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: ExportOptions.section", .{}),	735	try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: ExportOptions.section", .{}),
736	);	736	);
737	continue;	737	continue;
738	}	738	}
...	@@ -743,7 +743,7 @@ pub fn updateDeclExports(self: Coff, module: Module, decl: *const Module.Decl,	...	@@ -743,7 +743,7 @@ pub fn updateDeclExports(self: Coff, module: Module, decl: *const Module.Decl,
743	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);	743	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
744	module.failed_exports.putAssumeCapacityNoClobber(	744	module.failed_exports.putAssumeCapacityNoClobber(
745	exp,	745	exp,
746	try Compilation.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: Exports other than '_start'", .{}),	746	try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: Exports other than '_start'", .{}),
747	);	747	);
748	continue;	748	continue;
749	}	749	}

...	@@ -1148,7 +1148,7 @@ pub fn updateDecl(self: MachO, module: Module, decl: *Module.Decl) !void {	...	@@ -1148,7 +1148,7 @@ pub fn updateDecl(self: MachO, module: Module, decl: *Module.Decl) !void {
1148	}	1148	}
1149		1149
1150	const res = if (debug_buffers) \|*dbg\|	1150	const res = if (debug_buffers) \|*dbg\|
1151	try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .{	1151	try codegen.generateSymbol(&self.base, decl.srcLoc(), typed_value, &code_buffer, .{
1152	.dwarf = .{	1152	.dwarf = .{
1153	.dbg_line = &dbg.dbg_line_buffer,	1153	.dbg_line = &dbg.dbg_line_buffer,
1154	.dbg_info = &dbg.dbg_info_buffer,	1154	.dbg_info = &dbg.dbg_info_buffer,
...	@@ -1156,7 +1156,7 @@ pub fn updateDecl(self: MachO, module: Module, decl: *Module.Decl) !void {	...	@@ -1156,7 +1156,7 @@ pub fn updateDecl(self: MachO, module: Module, decl: *Module.Decl) !void {
1156	},	1156	},
1157	})	1157	})
1158	else	1158	else
1159	try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .none);	1159	try codegen.generateSymbol(&self.base, decl.srcLoc(), typed_value, &code_buffer, .none);
1160		1160
1161	const code = switch (res) {	1161	const code = switch (res) {
1162	.externally_managed => \|x\| x,	1162	.externally_managed => \|x\| x,
...	@@ -1316,7 +1316,7 @@ pub fn updateDeclExports(	...	@@ -1316,7 +1316,7 @@ pub fn updateDeclExports(
1316	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);	1316	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
1317	module.failed_exports.putAssumeCapacityNoClobber(	1317	module.failed_exports.putAssumeCapacityNoClobber(
1318	exp,	1318	exp,
1319	try Compilation.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: ExportOptions.section", .{}),	1319	try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: ExportOptions.section", .{}),
1320	);	1320	);
1321	continue;	1321	continue;
1322	}	1322	}
...	@@ -1334,7 +1334,7 @@ pub fn updateDeclExports(	...	@@ -1334,7 +1334,7 @@ pub fn updateDeclExports(
1334	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);	1334	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
1335	module.failed_exports.putAssumeCapacityNoClobber(	1335	module.failed_exports.putAssumeCapacityNoClobber(
1336	exp,	1336	exp,
1337	try Compilation.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),	1337	try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: GlobalLinkage.LinkOnce", .{}),
1338	);	1338	);
1339	continue;	1339	continue;
1340	},	1340	},