Stage2 whole file astgen

BRANCH_TODO

@@ -0,0 +1,67 @@
+ * structs, unions, enums, etc get weird names such as "Point__anon_22" rather
+   than "Point".
+ * get stage2 tests passing
+ * modify stage2 tests so that only 1 uses _start and the rest use
+   pub fn main
+ * modify stage2 CBE tests so that only 1 uses pub export main and the
+   rest use pub fn main
+
+ * get the test runner and `zig test` working
+ * get behavior tests passing for stage2
+
+ * use a hash map for instructions because the array is too big
+   - no, actually modify the Zir.Inst.Ref strategy so that each decl gets
+     their indexes starting at 0 so that we can use an array to store Sema
+     results rather than a map.
+
+ * keep track of file dependencies/dependants
+ * unload files from memory when a dependency is dropped
+
+ * implement the new AstGen compile errors
+
+ * get rid of failed_root_src_file
+ * get rid of Scope.DeclRef
+ * get rid of NameHash
+ * handle decl collision with usingnamespace
+ * the decl doing the looking up needs to create a decl dependency
+   on each usingnamespace decl
+ * handle usingnamespace cycles
+
+ * compile error for return inside defer expression
+
+ * when block has noreturn statement
+   - avoid emitting defers
+   - compile error for unreachable code
+
+ * detect `return error.Foo` and emit ZIR that unconditionally generates errdefers
+ * `return`: check return operand and generate errdefers if necessary
+
+ * have failed_trees and just put the file in there
+   - this way we can emit all the parse errors not just the first one
+   - but maybe we want just the first one?
+
+ * need a var decl zir instruction which includes the name because we need to do the
+   compile error for a local shadowing a decl with Sema looking up the decl name.
+   - this means LocalVal and LocalPtr should use the string table
+
+ * sort compile errors before presenting them to eliminate nondeterministic error reporting
+
+ * when handling decls, catch the error and continue, so that
+   AstGen can report more than one compile error.
+
+ * AstGen: add result location pointers to function calls
+ * nested function decl: how to refer to params?
+
+ * fix the commented out behavior test regarding function alignment
+   - not sure why this happened, it's stage1 code??
+   - search the behavior test diff for "TODO"
+
+ * memory efficiency: add another representation for structs which use
+   natural alignment for fields and do not have any comptime fields. this
+   will save 16 bytes per struct field in the compilation.
+
+ * extern "foo" for vars
+
+ * use ZIR memory for decl names where possible and also for keys
+   - this will require more sophisticated changelist detection which does some
+     pre-emptive deletion of decls from the parent namespace

CMakeLists.txt

@@ -594,7 +594,7 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/src/type.zig"
     "${CMAKE_SOURCE_DIR}/src/value.zig"
     "${CMAKE_SOURCE_DIR}/src/windows_sdk.zig"
-    "${CMAKE_SOURCE_DIR}/src/zir.zig"
+    "${CMAKE_SOURCE_DIR}/src/Zir.zig"
     "${CMAKE_SOURCE_DIR}/src/Sema.zig"
 )
 

build.zig

@@ -1,5 +1,5 @@
-const builtin = @import("builtin");
 const std = @import("std");
+const builtin = std.builtin;
 const Builder = std.build.Builder;
 const tests = @import("test/tests.zig");
 const BufMap = std.BufMap;
@@ -54,6 +54,7 @@ pub fn build(b: *Builder) !void {
     const skip_compile_errors = b.option(bool, "skip-compile-errors", "Main test suite skips compile error tests") orelse false;
     const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;
     const skip_stage2_tests = b.option(bool, "skip-stage2-tests", "Main test suite skips self-hosted compiler tests") orelse false;
+    const skip_install_lib_files = b.option(bool, "skip-install-lib-files", "Do not copy lib/ files to installation prefix") orelse false;
 
     const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
     const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false;
@@ -62,19 +63,21 @@ pub fn build(b: *Builder) !void {
     const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
     const config_h_path_option = b.option([]const u8, "config_h", "Path to the generated config.h");
 
-    b.installDirectory(InstallDirectoryOptions{
-        .source_dir = "lib",
-        .install_dir = .Lib,
-        .install_subdir = "zig",
-        .exclude_extensions = &[_][]const u8{
-            "test.zig",
-            "README.md",
-            ".z.0",
-            ".z.9",
-            ".gz",
-            "rfc1951.txt",
-        },
-    });
+    if (!skip_install_lib_files) {
+        b.installDirectory(InstallDirectoryOptions{
+            .source_dir = "lib",
+            .install_dir = .Lib,
+            .install_subdir = "zig",
+            .exclude_extensions = &[_][]const u8{
+                "test.zig",
+                "README.md",
+                ".z.0",
+                ".z.9",
+                ".gz",
+                "rfc1951.txt",
+            },
+        });
+    }
 
     if (only_install_lib_files)
         return;
@@ -83,6 +86,12 @@ pub fn build(b: *Builder) !void {
     const link_libc = b.option(bool, "force-link-libc", "Force self-hosted compiler to link libc") orelse enable_llvm;
     const strip = b.option(bool, "strip", "Omit debug information") orelse false;
 
+    const mem_leak_frames: u32 = b.option(u32, "mem-leak-frames", "How many stack frames to print when a memory leak occurs. Tests get 2x this amount.") orelse blk: {
+        if (strip) break :blk @as(u32, 0);
+        if (mode != .Debug) break :blk 0;
+        break :blk 4;
+    };
+
     const main_file = if (is_stage1) "src/stage1.zig" else "src/main.zig";
 
     var exe = b.addExecutable("zig", main_file);
@@ -93,6 +102,7 @@ pub fn build(b: *Builder) !void {
     toolchain_step.dependOn(&exe.step);
     b.default_step.dependOn(&exe.step);
 
+    exe.addBuildOption(u32, "mem_leak_frames", mem_leak_frames);
     exe.addBuildOption(bool, "skip_non_native", skip_non_native);
     exe.addBuildOption(bool, "have_llvm", enable_llvm);
     if (enable_llvm) {
@@ -227,6 +237,7 @@ pub fn build(b: *Builder) !void {
     test_stage2.addBuildOption(bool, "enable_qemu", is_qemu_enabled);
     test_stage2.addBuildOption(bool, "enable_wine", is_wine_enabled);
     test_stage2.addBuildOption(bool, "enable_wasmtime", is_wasmtime_enabled);
+    test_stage2.addBuildOption(u32, "mem_leak_frames", mem_leak_frames * 2);
     test_stage2.addBuildOption(?[]const u8, "glibc_multi_install_dir", glibc_multi_dir);
     test_stage2.addBuildOption([]const u8, "version", version);
 
@@ -262,7 +273,7 @@ pub fn build(b: *Builder) !void {
     fmt_step.dependOn(&fmt_build_zig.step);
 
     // TODO for the moment, skip wasm32-wasi until bugs are sorted out.
-    toolchain_step.dependOn(tests.addPkgTests(b, test_filter, "test/stage1/behavior.zig", "behavior", "Run the behavior tests", modes, false, skip_non_native, skip_libc, is_wine_enabled, is_qemu_enabled, is_wasmtime_enabled, glibc_multi_dir));
+    toolchain_step.dependOn(tests.addPkgTests(b, test_filter, "test/behavior.zig", "behavior", "Run the behavior tests", modes, false, skip_non_native, skip_libc, is_wine_enabled, is_qemu_enabled, is_wasmtime_enabled, glibc_multi_dir));
 
     toolchain_step.dependOn(tests.addPkgTests(b, test_filter, "lib/std/special/compiler_rt.zig", "compiler-rt", "Run the compiler_rt tests", modes, true, skip_non_native, true, is_wine_enabled, is_qemu_enabled, is_wasmtime_enabled, glibc_multi_dir));
     toolchain_step.dependOn(tests.addPkgTests(b, test_filter, "lib/std/special/c.zig", "minilibc", "Run the mini libc tests", modes, true, skip_non_native, true, is_wine_enabled, is_qemu_enabled, is_wasmtime_enabled, glibc_multi_dir));

doc/langref.html.in

@@ -2588,7 +2588,7 @@ test "default struct initialization fields" {
         exactly their bit width.
         </li>
         <li>{#syntax#}bool{#endsyntax#} fields use exactly 1 bit.</li>
-        <li>A {#link|packed enum#} field uses exactly the bit width of its integer tag type.</li>
+        <li>An {#link|enum#} field uses exactly the bit width of its integer tag type.</li>
         <li>A {#link|packed union#} field uses exactly the bit width of the union field with
         the largest bit width.</li>
         <li>Non-ABI-aligned fields are packed into the smallest possible
@@ -3014,25 +3014,6 @@ export fn entry(foo: Foo) void { }
       {#code_end#}
       {#header_close#}
 
-      {#header_open|packed enum#}
-      <p>By default, the size of enums is not guaranteed.</p>
-      <p>{#syntax#}packed enum{#endsyntax#} causes the size of the enum to be the same as the size of the
-      integer tag type of the enum:</p>
-      {#code_begin|test#}
-const std = @import("std");
-
-test "packed enum" {
-    const Number = packed enum(u8) {
-        one,
-        two,
-        three,
-    };
-    std.testing.expect(@sizeOf(Number) == @sizeOf(u8));
-}
-      {#code_end#}
-      <p>This makes the enum eligible to be in a {#link|packed struct#}.</p>
-      {#header_close#}
-
       {#header_open|Enum Literals#}
       <p>
       Enum literals allow specifying the name of an enum field without specifying the enum type:

lib/std/Thread/AutoResetEvent.zig

@@ -32,7 +32,7 @@
 state: usize = UNSET,
 
 const std = @import("../std.zig");
-const builtin = @import("builtin");
+const builtin = std.builtin;
 const testing = std.testing;
 const assert = std.debug.assert;
 const StaticResetEvent = std.Thread.StaticResetEvent;

lib/std/Thread/StaticResetEvent.zig

@@ -262,7 +262,7 @@ pub const AtomicEvent = struct {
                     while (true) {
                         if (waiting == WAKE) {
                             rc = windows.ntdll.NtWaitForKeyedEvent(handle, key, windows.FALSE, null);
-                            assert(rc == .WAIT_0);
+                            assert(rc == windows.NTSTATUS.WAIT_0);
                             break;
                         } else {
                             waiting = @cmpxchgWeak(u32, waiters, waiting, waiting - WAIT, .Acquire, .Monotonic) orelse break;
@@ -271,7 +271,7 @@ pub const AtomicEvent = struct {
                     }
                     return error.TimedOut;
                 },
-                .WAIT_0 => {},
+                windows.NTSTATUS.WAIT_0 => {},
                 else => unreachable,
             }
         }

lib/std/array_hash_map.zig

@@ -14,7 +14,7 @@ const trait = meta.trait;
 const autoHash = std.hash.autoHash;
 const Wyhash = std.hash.Wyhash;
 const Allocator = mem.Allocator;
-const builtin = @import("builtin");
+const builtin = std.builtin;
 const hash_map = @This();
 
 pub fn AutoArrayHashMap(comptime K: type, comptime V: type) type {
@@ -158,10 +158,20 @@ pub fn ArrayHashMap(
             return self.unmanaged.getOrPutValue(self.allocator, key, value);
         }
 
+        /// Deprecated: call `ensureUnusedCapacity` or `ensureTotalCapacity`.
+        pub const ensureCapacity = ensureTotalCapacity;
+
         /// Increases capacity, guaranteeing that insertions up until the
         /// `expected_count` will not cause an allocation, and therefore cannot fail.
-        pub fn ensureCapacity(self: *Self, new_capacity: usize) !void {
-            return self.unmanaged.ensureCapacity(self.allocator, new_capacity);
+        pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
+            return self.unmanaged.ensureTotalCapacity(self.allocator, new_capacity);
+        }
+
+        /// Increases capacity, guaranteeing that insertions up until
+        /// `additional_count` **more** items will not cause an allocation, and
+        /// therefore cannot fail.
+        pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void {
+            return self.unmanaged.ensureUnusedCapacity(self.allocator, additional_count);
         }
 
         /// Returns the number of total elements which may be present before it is
@@ -472,10 +482,13 @@ pub fn ArrayHashMapUnmanaged(
             return res.entry;
         }
 
+        /// Deprecated: call `ensureUnusedCapacity` or `ensureTotalCapacity`.
+        pub const ensureCapacity = ensureTotalCapacity;
+
         /// Increases capacity, guaranteeing that insertions up until the
         /// `expected_count` will not cause an allocation, and therefore cannot fail.
-        pub fn ensureCapacity(self: *Self, allocator: *Allocator, new_capacity: usize) !void {
-            try self.entries.ensureCapacity(allocator, new_capacity);
+        pub fn ensureTotalCapacity(self: *Self, allocator: *Allocator, new_capacity: usize) !void {
+            try self.entries.ensureTotalCapacity(allocator, new_capacity);
             if (new_capacity <= linear_scan_max) return;
 
             // Ensure that the indexes will be at most 60% full if
@@ -501,6 +514,17 @@ pub fn ArrayHashMapUnmanaged(
             }
         }
 
+        /// Increases capacity, guaranteeing that insertions up until
+        /// `additional_count` **more** items will not cause an allocation, and
+        /// therefore cannot fail.
+        pub fn ensureUnusedCapacity(
+            self: *Self,
+            allocator: *Allocator,
+            additional_capacity: usize,
+        ) !void {
+            return self.ensureTotalCapacity(allocator, self.count() + additional_capacity);
+        }
+
         /// Returns the number of total elements which may be present before it is
         /// no longer guaranteed that no allocations will be performed.
         pub fn capacity(self: Self) usize {
@@ -1310,7 +1334,7 @@ test "reIndex" {
 }
 
 test "fromOwnedArrayList" {
-    comptime const array_hash_map_type = AutoArrayHashMap(i32, i32);
+    const array_hash_map_type = AutoArrayHashMap(i32, i32);
     var al = std.ArrayListUnmanaged(array_hash_map_type.Entry){};
     const hash = getAutoHashFn(i32);