astgen: fix remaining compile errors

Now it builds and what remains in this branch is:
 * fix the stage2 compiler regressions from this branch
 * finish the rest of zig fmt test cases, get them passing
 * Merge in Vexu's translate-c AST branch & fix translate-c regressions

6 files changed, 37 insertions, 32 deletions

diff --git a/src/astgen.zig b/src/astgen.zig
index 3e5d63796f..468156e7a9 100644
--- a/src/astgen.zig
+++ b/src/astgen.zig
@@ -381,7 +381,7 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
             return addZIRNoOp(mod, scope, src, .unreachable_safe);
         },
         .@"return" => return ret(mod, scope, node),
-        .field_access => return field(mod, scope, rl, node),
+        .field_access => return fieldAccess(mod, scope, rl, node),
         .float_literal => return floatLiteral(mod, scope, rl, node),
 
         .if_simple => return ifExpr(mod, scope, rl, tree.ifSimple(node)),
@@ -1423,17 +1423,17 @@ fn arrayTypeSentinel(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.
 fn containerField(
     mod: *Module,
     scope: *Scope,
-    node: *ast.Node.ContainerField,
+    field: ast.full.ContainerField,
 ) InnerError!*zir.Inst {
     const tree = scope.tree();
     const token_starts = tree.tokens.items(.start);
 
-    const src = token_starts[tree.firstToken(node)];
-    const name = try mod.identifierTokenString(scope, node.name_token);
+    const src = token_starts[field.ast.name_token];
+    const name = try mod.identifierTokenString(scope, field.ast.name_token);
 
-    if (node.comptime_token == null and node.value_expr == null and node.align_expr == null) {
-        if (node.type_expr) |some| {
-            const ty = try typeExpr(mod, scope, some);
+    if (field.comptime_token == null and field.ast.value_expr == 0 and field.ast.align_expr == 0) {
+        if (field.ast.type_expr != 0) {
+            const ty = try typeExpr(mod, scope, field.ast.type_expr);
             return addZIRInst(mod, scope, src, zir.Inst.ContainerFieldTyped, .{
                 .bytes = name,
                 .ty = ty,
@@ -1445,9 +1445,11 @@ fn containerField(
         }
     }
 
-    const ty = if (node.type_expr) |some| try typeExpr(mod, scope, some) else null;
-    const alignment = if (node.align_expr) |some| try expr(mod, scope, .none, some) else null;
-    const init = if (node.value_expr) |some| try expr(mod, scope, .none, some) else null;
+    const ty = if (field.ast.type_expr != 0) try typeExpr(mod, scope, field.ast.type_expr) else null;
+    // TODO result location should be alignment type
+    const alignment = if (field.ast.align_expr != 0) try expr(mod, scope, .none, field.ast.align_expr) else null;
+    // TODO result location should be the field type
+    const init = if (field.ast.value_expr != 0) try expr(mod, scope, .none, field.ast.value_expr) else null;
 
     return addZIRInst(mod, scope, src, zir.Inst.ContainerField, .{
         .bytes = name,
@@ -1455,7 +1457,7 @@ fn containerField(
         .ty = ty,
         .init = init,
         .alignment = alignment,
-        .is_comptime = node.comptime_token != null,
+        .is_comptime = field.comptime_token != null,
     });
 }
 
@@ -1485,12 +1487,15 @@ fn containerDecl(
     defer fields.deinit();
 
     for (container_decl.ast.members) |member| {
-        switch (node_tags[member]) {
-            .container_field_init, .container_field_align, .container_field => {
-                try fields.append(try containerField(mod, &gen_scope.base, member));
-            },
+        // TODO just handle these cases differently since they end up with different ZIR
+        // instructions anyway. It will be simpler & have fewer branches.
+        const field = switch (node_tags[member]) {
+            .container_field_init => try containerField(mod, &gen_scope.base, tree.containerFieldInit(member)),
+            .container_field_align => try containerField(mod, &gen_scope.base, tree.containerFieldAlign(member)),
+            .container_field => try containerField(mod, &gen_scope.base, tree.containerField(member)),
             else => continue,
-        }
+        };
+        try fields.append(field);
     }
 
     var decl_arena = std.heap.ArenaAllocator.init(mod.gpa);
@@ -1847,7 +1852,7 @@ fn tokenIdentEql(mod: *Module, scope: *Scope, token1: ast.TokenIndex, token2: as
     return mem.eql(u8, ident_name_1, ident_name_2);
 }
 
-pub fn field(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!*zir.Inst {
+pub fn fieldAccess(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!*zir.Inst {
     const tree = scope.tree();
     const token_starts = tree.tokens.items(.start);
     const main_tokens = tree.nodes.items(.main_token);
@@ -3269,7 +3274,7 @@ fn asRlPtr(
     rl: ResultLoc,
     src: usize,
     result_ptr: *zir.Inst,
-    operand_node: *ast.Node,
+    operand_node: ast.Node.Index,
     dest_type: *zir.Inst,
 ) InnerError!*zir.Inst {
     // Detect whether this expr() call goes into rvalue() to store the result into the
diff --git a/src/link.zig b/src/link.zig
index 3d0a54f416..0a4cde0284 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -550,11 +550,11 @@ pub const File = struct {
                 id_symlink_basename,
                 &prev_digest_buf,
             ) catch |err| b: {
-                log.debug("archive new_digest={} readFile error: {s}", .{ digest, @errorName(err) });
+                log.debug("archive new_digest={x} readFile error: {s}", .{ digest, @errorName(err) });
                 break :b prev_digest_buf[0..0];
             };
             if (mem.eql(u8, prev_digest, &digest)) {
-                log.debug("archive digest={} match - skipping invocation", .{digest});
+                log.debug("archive digest={x} match - skipping invocation", .{digest});
                 base.lock = man.toOwnedLock();
                 return;
             }
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 0dfa3d54a1..2eee19b4f6 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -892,17 +892,17 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
             id_symlink_basename,
             &prev_digest_buf,
         ) catch |err| blk: {
-            log.debug("COFF LLD new_digest={} error: {s}", .{ digest, @errorName(err) });
+            log.debug("COFF LLD new_digest={x} error: {s}", .{ digest, @errorName(err) });
             // Handle this as a cache miss.
             break :blk prev_digest_buf[0..0];
         };
         if (mem.eql(u8, prev_digest, &digest)) {
-            log.debug("COFF LLD digest={} match - skipping invocation", .{digest});
+            log.debug("COFF LLD digest={x} match - skipping invocation", .{digest});
             // Hot diggity dog! The output binary is already there.
             self.base.lock = man.toOwnedLock();
             return;
         }
-        log.debug("COFF LLD prev_digest={} new_digest={}", .{ prev_digest, digest });
+        log.debug("COFF LLD prev_digest={x} new_digest={x}", .{ prev_digest, digest });
 
         // We are about to change the output file to be different, so we invalidate the build hash now.
         directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index f92c585cd5..1a015ba0c2 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1365,17 +1365,17 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
             id_symlink_basename,
             &prev_digest_buf,
         ) catch |err| blk: {
-            log.debug("ELF LLD new_digest={} error: {s}", .{ digest, @errorName(err) });
+            log.debug("ELF LLD new_digest={x} error: {s}", .{ digest, @errorName(err) });
             // Handle this as a cache miss.
             break :blk prev_digest_buf[0..0];
         };
         if (mem.eql(u8, prev_digest, &digest)) {
-            log.debug("ELF LLD digest={} match - skipping invocation", .{digest});
+            log.debug("ELF LLD digest={x} match - skipping invocation", .{digest});
             // Hot diggity dog! The output binary is already there.
             self.base.lock = man.toOwnedLock();
             return;
         }
-        log.debug("ELF LLD prev_digest={} new_digest={}", .{ prev_digest, digest });
+        log.debug("ELF LLD prev_digest={x} new_digest={x}", .{ prev_digest, digest });
 
         // We are about to change the output file to be different, so we invalidate the build hash now.
         directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index fd1c53cb67..139a9b8940 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -556,17 +556,17 @@ fn linkWithLLD(self: *MachO, comp: *Compilation) !void {
             id_symlink_basename,
             &prev_digest_buf,
         ) catch |err| blk: {
-            log.debug("MachO LLD new_digest={} error: {s}", .{ digest, @errorName(err) });
+            log.debug("MachO LLD new_digest={x} error: {s}", .{ digest, @errorName(err) });
             // Handle this as a cache miss.
             break :blk prev_digest_buf[0..0];
         };
         if (mem.eql(u8, prev_digest, &digest)) {
-            log.debug("MachO LLD digest={} match - skipping invocation", .{digest});
+            log.debug("MachO LLD digest={x} match - skipping invocation", .{digest});
             // Hot diggity dog! The output binary is already there.
             self.base.lock = man.toOwnedLock();
             return;
         }
-        log.debug("MachO LLD prev_digest={} new_digest={}", .{ prev_digest, digest });
+        log.debug("MachO LLD prev_digest={x} new_digest={x}", .{ prev_digest, digest });
 
         // We are about to change the output file to be different, so we invalidate the build hash now.
         directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 547ab2a012..cafd17cd2c 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -333,17 +333,17 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation) !void {
             id_symlink_basename,
             &prev_digest_buf,
         ) catch |err| blk: {
-            log.debug("WASM LLD new_digest={} error: {s}", .{ digest, @errorName(err) });
+            log.debug("WASM LLD new_digest={x} error: {s}", .{ digest, @errorName(err) });
             // Handle this as a cache miss.
             break :blk prev_digest_buf[0..0];
         };
         if (mem.eql(u8, prev_digest, &digest)) {
-            log.debug("WASM LLD digest={} match - skipping invocation", .{digest});
+            log.debug("WASM LLD digest={x} match - skipping invocation", .{digest});
             // Hot diggity dog! The output binary is already there.
             self.base.lock = man.toOwnedLock();
             return;
         }
-        log.debug("WASM LLD prev_digest={} new_digest={}", .{ prev_digest, digest });
+        log.debug("WASM LLD prev_digest={x} new_digest={x}", .{ prev_digest, digest });
 
         // We are about to change the output file to be different, so we invalidate the build hash now.
         directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {