Merge branch 'master' into zen_stdlib

ci/travis_linux_script

@@ -19,5 +19,5 @@ if [ "${TRAVIS_PULL_REQUEST}" = "false" ]; then
   echo "secret_key = $AWS_SECRET_ACCESS_KEY" >> ~/.s3cfg
   s3cmd put -P $TRAVIS_BUILD_DIR/artifacts/* s3://ziglang.org/builds/
   touch empty
-  s3cmd put -P empty s3://ziglang.org/builds/zig-linux-x86_64-$TRAVIS_BRANCH.tar.xz --add-header=x-amz-website-redirect-location:/builds/$(ls $TRAVIS_BUILD_DIR/artifacts)
+  s3cmd put -P empty s3://ziglang.org/builds/zig-linux-x86_64-$TRAVIS_BRANCH.tar.xz --add-header="Cache-Control: max-age=0, must-revalidate" --add-header=x-amz-website-redirect-location:/builds/$(ls $TRAVIS_BUILD_DIR/artifacts)
 fi

deps/lld/ELF/MarkLive.cpp

@@ -301,6 +301,15 @@ template <class ELFT> void elf::markLive() {
   // Follow the graph to mark all live sections.
   doGcSections<ELFT>();
 
+  // If all references to a DSO happen to be weak, the DSO is removed from
+  // DT_NEEDED, which creates dangling shared symbols to non-existent DSO.
+  // We'll replace such symbols with undefined ones to fix it.
+  for (Symbol *Sym : Symtab->getSymbols())
+    if (auto *S = dyn_cast<SharedSymbol>(Sym))
+      if (S->isWeak() && !S->getFile<ELFT>().IsNeeded)
+        replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_WEAK, S->StOther,
+                                 S->Type);
+
   // Report garbage-collected sections.
   if (Config->PrintGcSections)
     for (InputSectionBase *Sec : InputSections)

src-self-hosted/arg.zig

@@ -0,0 +1,284 @@
+const std = @import("std");
+const debug = std.debug;
+const mem = std.mem;
+
+const Allocator = mem.Allocator;
+const ArrayList = std.ArrayList;
+const HashMap = std.HashMap;
+
+fn trimStart(slice: []const u8, ch: u8) []const u8 {
+    var i: usize = 0;
+    for (slice) |b| {
+        if (b != '-') break;
+        i += 1;
+    }
+
+    return slice[i..];
+}
+
+fn argInAllowedSet(maybe_set: ?[]const []const u8, arg: []const u8) bool {
+    if (maybe_set) |set| {
+        for (set) |possible| {
+            if (mem.eql(u8, arg, possible)) {
+                return true;
+            }
+        }
+        return false;
+    } else {
+        return true;
+    }
+}
+
+// Modifies the current argument index during iteration
+fn readFlagArguments(allocator: &Allocator, args: []const []const u8, required: usize,
+                     allowed_set: ?[]const []const u8, index: &usize) !FlagArg {
+
+    switch (required) {
+        0 => return FlagArg { .None = undefined },  // TODO: Required to force non-tag but value?
+        1 => {
+            if (*index + 1 >= args.len) {
+                return error.MissingFlagArguments;
+            }
+
+            *index += 1;
+            const arg = args[*index];
+
+            if (!argInAllowedSet(allowed_set, arg)) {
+                return error.ArgumentNotInAllowedSet;
+            }
+
+            return FlagArg { .Single = arg };
+        },
+        else => |needed| {
+            var extra = ArrayList([]const u8).init(allocator);
+            errdefer extra.deinit();
+
+            var j: usize = 0;
+            while (j < needed) : (j += 1) {
+                if (*index + 1 >= args.len) {
+                    return error.MissingFlagArguments;
+                }
+
+                *index += 1;
+                const arg = args[*index];
+
+                if (!argInAllowedSet(allowed_set, arg)) {
+                    return error.ArgumentNotInAllowedSet;
+                }
+
+                try extra.append(arg);
+            }
+
+            return FlagArg { .Many = extra };
+        },
+    }
+}
+
+const HashMapFlags = HashMap([]const u8, FlagArg, std.hash.Fnv1a_32.hash, mem.eql_slice_u8);
+
+// A store for querying found flags and positional arguments.
+pub const Args = struct {
+    flags: HashMapFlags,
+    positionals: ArrayList([]const u8),
+
+    pub fn parse(allocator: &Allocator, comptime spec: []const Flag, args: []const []const u8) !Args {
+        var parsed = Args {
+            .flags = HashMapFlags.init(allocator),
+            .positionals = ArrayList([]const u8).init(allocator),
+        };
+
+        var i: usize = 0;
+        next: while (i < args.len) : (i += 1) {
+            const arg = args[i];
+
+            if (arg.len != 0 and arg[0] == '-') {
+                // TODO: hashmap, although the linear scan is okay for small argument sets as is
+                for (spec) |flag| {
+                    if (mem.eql(u8, arg, flag.name)) {
+                        const flag_name_trimmed = trimStart(flag.name, '-');
+                        const flag_args = readFlagArguments(allocator, args, flag.required, flag.allowed_set, &i) catch |err| {
+                            switch (err) {
+                                error.ArgumentNotInAllowedSet => {
+                                    std.debug.warn("argument '{}' is invalid for flag '{}'\n", args[i], arg);
+                                    std.debug.warn("allowed options are ");
+                                    for (??flag.allowed_set) |possible| {
+                                        std.debug.warn("'{}' ", possible);
+                                    }
+                                    std.debug.warn("\n");
+                                },
+                                error.MissingFlagArguments => {
+                                    std.debug.warn("missing argument for flag: {}\n", arg);
+                                },
+                                else => {},
+                            }
+
+                            return err;
+                        };
+
+                        if (flag.mergable) {
+                            var prev =
+                                if (parsed.flags.get(flag_name_trimmed)) |entry|
+                                    entry.value.Many
+                                else
+                                    ArrayList([]const u8).init(allocator);
+
+                            // MergeN creation disallows 0 length flag entry (doesn't make sense)
+                            switch (flag_args) {
+                                FlagArg.None => unreachable,
+                                FlagArg.Single => |inner| try prev.append(inner),
+                                FlagArg.Many => |inner| try prev.appendSlice(inner.toSliceConst()),
+                            }
+
+                            _ = try parsed.flags.put(flag_name_trimmed, FlagArg { .Many = prev });
+                        } else {
+                            _ = try parsed.flags.put(flag_name_trimmed, flag_args);
+                        }
+
+                        continue :next;
+                    }
+                }
+
+                // TODO: Better errors with context, global error state and return is sufficient.
+                std.debug.warn("could not match flag: {}\n", arg);
+                return error.UnknownFlag;
+            } else {
+                try parsed.positionals.append(arg);
+            }
+        }
+
+        return parsed;
+    }
+
+    pub fn deinit(self: &Args) void {
+        self.flags.deinit();
+        self.positionals.deinit();
+    }
+
+    // e.g. --help
+    pub fn present(self: &Args, name: []const u8) bool {
+        return self.flags.contains(name);
+    }
+
+    // e.g. --name value
+    pub fn single(self: &Args, name: []const u8) ?[]const u8 {
+        if (self.flags.get(name)) |entry| {
+            switch (entry.value) {
+                FlagArg.Single => |inner| { return inner; },
+                else => @panic("attempted to retrieve flag with wrong type"),
+            }
+        } else {
+            return null;
+        }
+    }
+
+    // e.g. --names value1 value2 value3
+    pub fn many(self: &Args, name: []const u8) ?[]const []const u8 {
+        if (self.flags.get(name)) |entry| {
+            switch (entry.value) {
+                FlagArg.Many => |inner| { return inner.toSliceConst(); },
+                else => @panic("attempted to retrieve flag with wrong type"),
+            }
+        } else {
+            return null;
+        }
+    }
+};
+
+// Arguments for a flag. e.g. arg1, arg2 in `--command arg1 arg2`.
+const FlagArg = union(enum) {
+    None,
+    Single: []const u8,
+    Many: ArrayList([]const u8),
+};
+
+// Specification for how a flag should be parsed.
+pub const Flag = struct {
+    name: []const u8,
+    required: usize,
+    mergable: bool,
+    allowed_set: ?[]const []const u8,
+
+    pub fn Bool(comptime name: []const u8) Flag {
+        return ArgN(name, 0);
+    }
+
+    pub fn Arg1(comptime name: []const u8) Flag {
+        return ArgN(name, 1);
+    }
+
+    pub fn ArgN(comptime name: []const u8, comptime n: usize) Flag {
+        return Flag {
+            .name = name,
+            .required = n,
+            .mergable = false,
+            .allowed_set = null,
+        };
+    }
+
+    pub fn ArgMergeN(comptime name: []const u8, comptime n: usize) Flag {
+        if (n == 0) {
+            @compileError("n must be greater than 0");
+        }
+
+        return Flag {
+            .name = name,
+            .required = n,
+            .mergable = true,
+            .allowed_set = null,
+        };
+    }
+
+    pub fn Option(comptime name: []const u8, comptime set: []const []const u8) Flag {
+        return Flag {
+            .name = name,
+            .required = 1,
+            .mergable = false,
+            .allowed_set = set,
+        };
+    }
+};
+
+test "parse arguments" {
+    const spec1 = comptime []const Flag {
+        Flag.Bool("--help"),
+        Flag.Bool("--init"),
+        Flag.Arg1("--build-file"),
+        Flag.Option("--color", []const []const u8 { "on", "off", "auto" }),
+        Flag.ArgN("--pkg-begin", 2),
+        Flag.ArgMergeN("--object", 1),
+        Flag.ArgN("--library", 1),
+    };
+
+    const cliargs = []const []const u8 {
+        "build",
+        "--help",
+        "pos1",
+        "--build-file", "build.zig",
+        "--object", "obj1",
+        "--object", "obj2",
+        "--library", "lib1",
+        "--library", "lib2",
+        "--color", "on",
+        "pos2",
+    };
+
+    var args = try Args.parse(std.debug.global_allocator, spec1, cliargs);
+
+    debug.assert(args.present("help"));
+    debug.assert(!args.present("help2"));
+    debug.assert(!args.present("init"));
+
+    debug.assert(mem.eql(u8, ??args.single("build-file"), "build.zig"));
+    debug.assert(mem.eql(u8, ??args.single("color"), "on"));
+
+    const objects = ??args.many("object");
+    debug.assert(mem.eql(u8, objects[0], "obj1"));
+    debug.assert(mem.eql(u8, objects[1], "obj2"));
+
+    debug.assert(mem.eql(u8, ??args.single("library"), "lib2"));
+
+    const pos = args.positionals.toSliceConst();
+    debug.assert(mem.eql(u8, pos[0], "build"));
+    debug.assert(mem.eql(u8, pos[1], "pos1"));
+    debug.assert(mem.eql(u8, pos[2], "pos2"));
+}

src-self-hosted/introspect.zig

@@ -0,0 +1,57 @@
+// Introspection and determination of system libraries needed by zig.
+
+const std = @import("std");
+const mem = std.mem;
+const os = std.os;
+
+const warn = std.debug.warn;
+
+/// Caller must free result
+pub fn testZigInstallPrefix(allocator: &mem.Allocator, test_path: []const u8) ![]u8 {
+    const test_zig_dir = try os.path.join(allocator, test_path, "lib", "zig");
+    errdefer allocator.free(test_zig_dir);
+
+    const test_index_file = try os.path.join(allocator, test_zig_dir, "std", "index.zig");
+    defer allocator.free(test_index_file);
+
+    var file = try os.File.openRead(allocator, test_index_file);
+    file.close();
+
+    return test_zig_dir;
+}
+
+/// Caller must free result
+pub fn findZigLibDir(allocator: &mem.Allocator) ![]u8 {
+    const self_exe_path = try os.selfExeDirPath(allocator);
+    defer allocator.free(self_exe_path);
+
+    var cur_path: []const u8 = self_exe_path;
+    while (true) {
+        const test_dir = os.path.dirname(cur_path);
+
+        if (mem.eql(u8, test_dir, cur_path)) {
+            break;
+        }
+
+        return testZigInstallPrefix(allocator, test_dir) catch |err| {
+            cur_path = test_dir;
+            continue;
+        };
+    }
+
+    return error.FileNotFound;
+}
+
+pub fn resolveZigLibDir(allocator: &mem.Allocator) ![]u8 {
+    return findZigLibDir(allocator) catch |err| {
+        warn(
+            \\Unable to find zig lib directory: {}.
+            \\Reinstall Zig or use --zig-install-prefix.
+            \\
+            ,
+            @errorName(err)
+        );
+
+        return error.ZigLibDirNotFound;
+    };
+}

src-self-hosted/module.zig

@@ -109,6 +109,29 @@ pub const Module = struct {
         LlvmIr,
     };
 
+    pub const CliPkg = struct {
+        name: []const u8,
+        path: []const u8,
+        children: ArrayList(&CliPkg),
+        parent: ?&CliPkg,
+
+        pub fn init(allocator: &mem.Allocator, name: []const u8, path: []const u8, parent: ?&CliPkg) !&CliPkg {
+            var pkg = try allocator.create(CliPkg);
+            pkg.name = name;
+            pkg.path = path;
+            pkg.children = ArrayList(&CliPkg).init(allocator);
+            pkg.parent = parent;
+            return pkg;
+        }
+
+        pub fn deinit(self: &CliPkg) void {
+            for (self.children.toSliceConst()) |child| {
+                child.deinit();
+            }
+            self.children.deinit();
+        }
+    };
+
     pub fn create(allocator: &mem.Allocator, name: []const u8, root_src_path: ?[]const u8, target: &const Target,
         kind: Kind, build_mode: builtin.Mode, zig_lib_dir: []const u8, cache_dir: []const u8) !&Module
     {

src/codegen.cpp

@@ -467,7 +467,7 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) {
                     fn_table_entry->llvm_value, buf_ptr(&fn_export->name));
         }
     }
-    fn_table_entry->llvm_name = LLVMGetValueName(fn_table_entry->llvm_value);
+    fn_table_entry->llvm_name = strdup(LLVMGetValueName(fn_table_entry->llvm_value));
 
     switch (fn_table_entry->fn_inline) {
         case FnInlineAlways:

src/ir.cpp

@@ -11395,7 +11395,19 @@ static TypeTableEntry *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstruc
                 }
                 break;
             case VarClassRequiredAny:
-                // OK
+                if (casted_init_value->value.special == ConstValSpecialStatic &&
+                    casted_init_value->value.type->id == TypeTableEntryIdFn &&
+                    casted_init_value->value.data.x_ptr.data.fn.fn_entry->fn_inline == FnInlineAlways)
+                {
+                    var_class_requires_const = true;
+                    if (!var->src_is_const && !is_comptime_var) {
+                        ErrorMsg *msg = ir_add_error_node(ira, source_node,
+                            buf_sprintf("functions marked inline must be stored in const or comptime var"));
+                        AstNode *proto_node = casted_init_value->value.data.x_ptr.data.fn.fn_entry->proto_node;
+                        add_error_note(ira->codegen, msg, proto_node, buf_sprintf("declared here"));
+                        result_type = ira->codegen->builtin_types.entry_invalid;
+                    }
+                }
                 break;
         }
     }
@@ -11804,7 +11816,8 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
         }
     }
 
-    bool comptime_arg = param_decl_node->data.param_decl.is_inline;
+    bool comptime_arg = param_decl_node->data.param_decl.is_inline ||
+        casted_arg->value.type->id == TypeTableEntryIdNumLitInt || casted_arg->value.type->id == TypeTableEntryIdNumLitFloat;
 
     ConstExprValue *arg_val;
 
@@ -11829,6 +11842,12 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
         var->shadowable = !comptime_arg;
 
         *next_proto_i += 1;
+    } else if (casted_arg->value.type->id == TypeTableEntryIdNumLitInt ||
+            casted_arg->value.type->id == TypeTableEntryIdNumLitFloat)
+    {
+        ir_add_error(ira, casted_arg,
+            buf_sprintf("compiler bug: integer and float literals in var args function must be casted. https://github.com/zig-lang/zig/issues/557"));
+        return false;
     }
 
     if (!comptime_arg) {

src/main.cpp

@@ -54,7 +54,6 @@ static int usage(const char *arg0) {
         "  --verbose-ir                 turn on compiler debug output for Zig IR\n"
         "  --verbose-llvm-ir            turn on compiler debug output for LLVM IR\n"
         "  --verbose-cimport            turn on compiler debug output for C imports\n"
-        "  --zig-install-prefix [path]  override directory where zig thinks it is installed\n"
         "  -dirafter [dir]              same as -isystem but do it last\n"
         "  -isystem [dir]               add additional search path for other .h files\n"
         "  -mllvm [arg]                 additional arguments to forward to LLVM's option processing\n"
@@ -177,6 +176,7 @@ static int find_zig_lib_dir(Buf *out_path) {
     int err;
 
     Buf self_exe_path = BUF_INIT;
+    buf_resize(&self_exe_path, 0);
     if (!(err = os_self_exe_path(&self_exe_path))) {
         Buf *cur_path = &self_exe_path;
 
@@ -199,23 +199,14 @@ static int find_zig_lib_dir(Buf *out_path) {
     return ErrorFileNotFound;
 }
 
-static Buf *resolve_zig_lib_dir(const char *zig_install_prefix_arg) {
+static Buf *resolve_zig_lib_dir(void) {
     int err;
     Buf *result = buf_alloc();
-    if (zig_install_prefix_arg == nullptr) {
+    if ((err = find_zig_lib_dir(result))) {
-        if ((err = find_zig_lib_dir(result))) {
+        fprintf(stderr, "Unable to find zig lib directory\n");
-            fprintf(stderr, "Unable to find zig lib directory. Reinstall Zig or use --zig-install-prefix.\n");
+        exit(EXIT_FAILURE);
-            exit(EXIT_FAILURE);
-        }
-        return result;
     }
-    Buf *zig_lib_dir_buf = buf_create_from_str(zig_install_prefix_arg);
+    return result;
-    if (test_zig_install_prefix(zig_lib_dir_buf, result)) {
-        return result;
-    }
-
-    fprintf(stderr, "No Zig installation found at prefix: %s\n", zig_install_prefix_arg);
-    exit(EXIT_FAILURE);
 }
 
 enum Cmd {
@@ -299,7 +290,6 @@ int main(int argc, char **argv) {
     const char *libc_include_dir = nullptr;
     const char *msvc_lib_dir = nullptr;
     const char *kernel32_lib_dir = nullptr;
-    const char *zig_install_prefix = nullptr;
     const char *dynamic_linker = nullptr;
     ZigList<const char *> clang_argv = {0};
     ZigList<const char *> llvm_argv = {0};
@@ -359,17 +349,12 @@ int main(int argc, char **argv) {
             } else if (i + 1 < argc && strcmp(argv[i], "--cache-dir") == 0) {
                 cache_dir = argv[i + 1];
                 i += 1;
-            } else if (i + 1 < argc && strcmp(argv[i], "--zig-install-prefix") == 0) {
-                args.append(argv[i]);
-                i += 1;
-                zig_install_prefix = argv[i];
-                args.append(zig_install_prefix);
             } else {
                 args.append(argv[i]);
             }
         }
 
-        Buf *zig_lib_dir_buf = resolve_zig_lib_dir(zig_install_prefix);
+        Buf *zig_lib_dir_buf = resolve_zig_lib_dir();
 
         Buf *zig_std_dir = buf_alloc();
         os_path_join(zig_lib_dir_buf, buf_create_from_str("std"), zig_std_dir);
@@ -590,8 +575,6 @@ int main(int argc, char **argv) {
                     msvc_lib_dir = argv[i];
                 } else if (strcmp(arg, "--kernel32-lib-dir") == 0) {
                     kernel32_lib_dir = argv[i];
-                } else if (strcmp(arg, "--zig-install-prefix") == 0) {
-                    zig_install_prefix = argv[i];
                 } else if (strcmp(arg, "--dynamic-linker") == 0) {
                     dynamic_linker = argv[i];
                 } else if (strcmp(arg, "-isystem") == 0) {
@@ -803,7 +786,7 @@ int main(int argc, char **argv) {
                         full_cache_dir);
             }
 
-            Buf *zig_lib_dir_buf = resolve_zig_lib_dir(zig_install_prefix);
+            Buf *zig_lib_dir_buf = resolve_zig_lib_dir();
 
             CodeGen *g = codegen_create(zig_root_source_file, target, out_type, build_mode, zig_lib_dir_buf);
             codegen_set_out_name(g, buf_out_name);

std/c/index.zig

@@ -28,6 +28,7 @@ pub extern "c" fn unlink(path: &const u8) c_int;
 pub extern "c" fn getcwd(buf: &u8, size: usize) ?&u8;
 pub extern "c" fn waitpid(pid: c_int, stat_loc: &c_int, options: c_int) c_int;
 pub extern "c" fn fork() c_int;
+pub extern "c" fn access(path: &const u8, mode: c_uint) c_int;
 pub extern "c" fn pipe(fds: &c_int) c_int;
 pub extern "c" fn mkdir(path: &const u8, mode: c_uint) c_int;
 pub extern "c" fn symlink(existing: &const u8, new: &const u8) c_int;

std/os/darwin.zig

@@ -41,6 +41,11 @@ pub const SA_64REGSET  = 0x0200; /// signal handler with SA_SIGINFO args with 64
 pub const O_LARGEFILE = 0x0000;
 pub const O_PATH = 0x0000;
 
+pub const F_OK = 0;
+pub const X_OK = 1;
+pub const W_OK = 2;
+pub const R_OK = 4;
+
 pub const O_RDONLY   = 0x0000; /// open for reading only
 pub const O_WRONLY   = 0x0001; /// open for writing only
 pub const O_RDWR     = 0x0002; /// open for reading and writing
@@ -209,6 +214,10 @@ pub fn fork() usize {
     return errnoWrap(c.fork());
 }
 
+pub fn access(path: &const u8, mode: u32) usize {
+    return errnoWrap(c.access(path, mode));
+}
+
 pub fn pipe(fds: &[2]i32) usize {
     comptime assert(i32.bit_count == c_int.bit_count);
     return errnoWrap(c.pipe(@ptrCast(&c_int, fds)));

std/os/file.zig

@@ -85,6 +85,47 @@ pub const File = struct {
         };
     }
 
+    pub fn access(allocator: &mem.Allocator, path: []const u8, file_mode: os.FileMode) !bool {
+        const path_with_null = try std.cstr.addNullByte(allocator, path);
+        defer allocator.free(path_with_null);
+
+        if (is_posix) {
+            // mode is ignored and is always F_OK for now
+            const result = posix.access(path_with_null.ptr, posix.F_OK);
+            const err = posix.getErrno(result);
+            if (err > 0) {
+                return switch (err) {
+                    posix.EACCES => error.PermissionDenied,
+                    posix.EROFS => error.PermissionDenied,
+                    posix.ELOOP => error.PermissionDenied,
+                    posix.ETXTBSY => error.PermissionDenied,
+                    posix.ENOTDIR => error.NotFound,
+                    posix.ENOENT => error.NotFound,
+
+                    posix.ENAMETOOLONG => error.NameTooLong,
+                    posix.EINVAL => error.BadMode,
+                    posix.EFAULT => error.BadPathName,
+                    posix.EIO => error.Io,
+                    posix.ENOMEM => error.SystemResources,
+                    else => os.unexpectedErrorPosix(err),
+                };
+            }
+            return true;
+        } else if (is_windows) {
+            if (os.windows.PathFileExists(path_with_null.ptr) == os.windows.TRUE) {
+                return true;
+            }
+
+            const err = windows.GetLastError();
+            return switch (err) {
+                windows.ERROR.FILE_NOT_FOUND => error.NotFound,
+                windows.ERROR.ACCESS_DENIED => error.PermissionDenied,
+                else => os.unexpectedErrorWindows(err),
+            };
+        } else {
+            @compileError("TODO implement access for this OS");
+        }
+    }
 
     /// Upon success, the stream is in an uninitialized state. To continue using it,
     /// you must use the open() function.
@@ -245,7 +286,9 @@ pub const File = struct {
                 };
             }
 
-            return stat.mode;
+            // TODO: we should be able to cast u16 to ModeError!u32, making this
+            // explicit cast not necessary
+            return os.FileMode(stat.mode);
         } else if (is_windows) {
             return {};
         } else {

std/os/linux/index.zig

@@ -38,6 +38,11 @@ pub const MAP_STACK      = 0x20000;
 pub const MAP_HUGETLB    = 0x40000;
 pub const MAP_FILE       = 0;
 
+pub const F_OK = 0;
+pub const X_OK = 1;
+pub const W_OK = 2;
+pub const R_OK = 4;
+
 pub const WNOHANG    = 1;
 pub const WUNTRACED  = 2;
 pub const WSTOPPED   = 2;
@@ -705,6 +710,10 @@ pub fn pread(fd: i32, buf: &u8, count: usize, offset: usize) usize {
     return syscall4(SYS_pread, usize(fd), @ptrToInt(buf), count, offset);
 }
 
+pub fn access(path: &const u8, mode: u32) usize {
+    return syscall2(SYS_access, @ptrToInt(path), mode);
+}
+
 pub fn pipe(fd: &[2]i32) usize {
     return pipe2(fd, 0);
 }

std/os/test.zig

@@ -23,3 +23,20 @@ test "makePath, put some files in it, deleteTree" {
         assert(err == error.PathNotFound);
     }
 }
+
+test "access file" {
+    if (builtin.os == builtin.Os.windows) {
+        return;
+    }
+
+    try os.makePath(a, "os_test_tmp");
+    if (os.File.access(a, "os_test_tmp/file.txt", os.default_file_mode)) |ok| {
+        unreachable;
+    } else |err| {
+        assert(err == error.NotFound);
+    }
+
+    try io.writeFile(a, "os_test_tmp/file.txt", "");
+    assert((try os.File.access(a, "os_test_tmp/file.txt", os.default_file_mode)) == true);
+    try os.deleteTree(a, "os_test_tmp");
+}

std/os/windows/index.zig

@@ -78,6 +78,8 @@ pub extern "kernel32" stdcallcc fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem
 pub extern "kernel32" stdcallcc fn MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR,
     dwFlags: DWORD) BOOL;
 
+pub extern "kernel32" stdcallcc fn PathFileExists(pszPath: ?LPCTSTR) BOOL;
+
 pub extern "kernel32" stdcallcc fn ReadFile(in_hFile: HANDLE, out_lpBuffer: &c_void,
     in_nNumberOfBytesToRead: DWORD, out_lpNumberOfBytesRead: &DWORD,
     in_out_lpOverlapped: ?&OVERLAPPED) BOOL;

std/zig/ast.zig

@@ -9,38 +9,34 @@ pub const Node = struct {
     comment: ?&NodeLineComment,
 
     pub const Id = enum {
+        // Top level
         Root,
-        VarDecl,
         Use,
-        ErrorSetDecl,
+        TestDecl,
-        ContainerDecl,
+
-        StructField,
+        // Statements
-        UnionTag,
+        VarDecl,
-        EnumTag,
-        Identifier,
-        AsyncAttribute,
-        FnProto,
-        ParamDecl,
-        Block,
         Defer,
-        Comptime,
+
-        Payload,
+        // Operators
-        PointerPayload,
-        PointerIndexPayload,
-        Else,
-        Switch,
-        SwitchCase,
-        SwitchElse,
-        While,
-        For,
-        If,
         InfixOp,
         PrefixOp,
         SuffixOp,
-        GroupedExpression,
+
+        // Control flow
+        Switch,
+        While,
+        For,
+        If,
         ControlFlowExpression,
         Suspend,
-        FieldInitializer,
+
+        // Type expressions
+        VarType,
+        ErrorType,
+        FnProto,
+
+        // Primary expressions
         IntegerLiteral,
         FloatLiteral,
         StringLiteral,
@@ -50,180 +46,143 @@ pub const Node = struct {
         NullLiteral,
         UndefinedLiteral,
         ThisLiteral,
+        Unreachable,
+        Identifier,
+        GroupedExpression,
+        BuiltinCall,
+        ErrorSetDecl,
+        ContainerDecl,
         Asm,
+        Comptime,
+        Block,
+
+        // Misc
+        LineComment,
+        SwitchCase,
+        SwitchElse,
+        Else,
+        Payload,
+        PointerPayload,
+        PointerIndexPayload,
+        StructField,
+        UnionTag,
+        EnumTag,
         AsmInput,
         AsmOutput,
-        Unreachable,
+        AsyncAttribute,
-        ErrorType,
+        ParamDecl,
-        VarType,
+        FieldInitializer,
-        BuiltinCall,
-        LineComment,
-        TestDecl,
     };
 
+    const IdTypePair = struct {
+        id: Id,
+        Type: type,
+    };
+
+    // TODO: When @field exists, we could generate this by iterating over all members of `Id`,
+    //       and making an array of `IdTypePair { .id = @field(Id, @memberName(Id, i)), .Type = @field(ast, "Node" ++ @memberName(Id, i)) }`
+    const idTypeTable = []IdTypePair {
+        IdTypePair { .id = Id.Root, .Type = NodeRoot },
+        IdTypePair { .id = Id.Use, .Type = NodeUse },
+        IdTypePair { .id = Id.TestDecl, .Type = NodeTestDecl },
+
+        IdTypePair { .id = Id.VarDecl, .Type = NodeVarDecl },
+        IdTypePair { .id = Id.Defer, .Type = NodeDefer },
+
+        IdTypePair { .id = Id.InfixOp, .Type = NodeInfixOp },
+        IdTypePair { .id = Id.PrefixOp, .Type = NodePrefixOp },
+        IdTypePair { .id = Id.SuffixOp, .Type = NodeSuffixOp },
+
+        IdTypePair { .id = Id.Switch, .Type = NodeSwitch },
+        IdTypePair { .id = Id.While, .Type = NodeWhile },
+        IdTypePair { .id = Id.For, .Type = NodeFor },
+        IdTypePair { .id = Id.If, .Type = NodeIf },
+        IdTypePair { .id = Id.ControlFlowExpression, .Type = NodeControlFlowExpression },
+        IdTypePair { .id = Id.Suspend, .Type = NodeSuspend },
+
+        IdTypePair { .id = Id.VarType, .Type = NodeVarType },
+        IdTypePair { .id = Id.ErrorType, .Type = NodeErrorType },
+        IdTypePair { .id = Id.FnProto, .Type = NodeFnProto },
+
+        IdTypePair { .id = Id.IntegerLiteral, .Type = NodeIntegerLiteral },
+        IdTypePair { .id = Id.FloatLiteral, .Type = NodeFloatLiteral },
+        IdTypePair { .id = Id.StringLiteral, .Type = NodeStringLiteral },
+        IdTypePair { .id = Id.MultilineStringLiteral, .Type = NodeMultilineStringLiteral },
+        IdTypePair { .id = Id.CharLiteral, .Type = NodeCharLiteral },
+        IdTypePair { .id = Id.BoolLiteral, .Type = NodeBoolLiteral },
+        IdTypePair { .id = Id.NullLiteral, .Type = NodeNullLiteral },
+        IdTypePair { .id = Id.UndefinedLiteral, .Type = NodeUndefinedLiteral },
+        IdTypePair { .id = Id.ThisLiteral, .Type = NodeThisLiteral },
+        IdTypePair { .id = Id.Unreachable, .Type = NodeUnreachable },
+        IdTypePair { .id = Id.Identifier, .Type = NodeIdentifier },
+        IdTypePair { .id = Id.GroupedExpression, .Type = NodeGroupedExpression },
+        IdTypePair { .id = Id.BuiltinCall, .Type = NodeBuiltinCall },
+        IdTypePair { .id = Id.ErrorSetDecl, .Type = NodeErrorSetDecl },
+        IdTypePair { .id = Id.ContainerDecl, .Type = NodeContainerDecl },
+        IdTypePair { .id = Id.Asm, .Type = NodeAsm },
+        IdTypePair { .id = Id.Comptime, .Type = NodeComptime },
+        IdTypePair { .id = Id.Block, .Type = NodeBlock },
+
+        IdTypePair { .id = Id.LineComment, .Type = NodeLineComment },
+        IdTypePair { .id = Id.SwitchCase, .Type = NodeSwitchCase },
+        IdTypePair { .id = Id.SwitchElse, .Type = NodeSwitchElse },
+        IdTypePair { .id = Id.Else, .Type = NodeElse },
+        IdTypePair { .id = Id.Payload, .Type = NodePayload },
+        IdTypePair { .id = Id.PointerPayload, .Type = NodePointerPayload },
+        IdTypePair { .id = Id.PointerIndexPayload, .Type = NodePointerIndexPayload },
+        IdTypePair { .id = Id.StructField, .Type = NodeStructField },
+        IdTypePair { .id = Id.UnionTag, .Type = NodeUnionTag },
+        IdTypePair { .id = Id.EnumTag, .Type = NodeEnumTag },
+        IdTypePair { .id = Id.AsmInput, .Type = NodeAsmInput },
+        IdTypePair { .id = Id.AsmOutput, .Type = NodeAsmOutput },
+        IdTypePair { .id = Id.AsyncAttribute, .Type = NodeAsyncAttribute },
+        IdTypePair { .id = Id.ParamDecl, .Type = NodeParamDecl },
+        IdTypePair { .id = Id.FieldInitializer, .Type = NodeFieldInitializer },
+    };
+
+    pub fn IdToType(comptime id: Id) type {
+        inline for (idTypeTable) |id_type_pair| {
+            if (id == id_type_pair.id)
+                return id_type_pair.Type;
+        }
+
+        unreachable;
+    }
+
+    pub fn typeToId(comptime T: type) Id {
+        inline for (idTypeTable) |id_type_pair| {
+            if (T == id_type_pair.Type)
+                return id_type_pair.id;
+        }
+
+        unreachable;
+    }
+
     pub fn iterate(base: &Node, index: usize) ?&Node {
-        return switch (base.id) {
+        inline for (idTypeTable) |id_type_pair| {
-            Id.Root => @fieldParentPtr(NodeRoot, "base", base).iterate(index),
+            if (base.id == id_type_pair.id)
-            Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).iterate(index),
+                return @fieldParentPtr(id_type_pair.Type, "base", base).iterate(index);
-            Id.Use => @fieldParentPtr(NodeUse, "base", base).iterate(index),
+        }
-            Id.ErrorSetDecl => @fieldParentPtr(NodeErrorSetDecl, "base", base).iterate(index),
+
-            Id.ContainerDecl => @fieldParentPtr(NodeContainerDecl, "base", base).iterate(index),
+        unreachable;
-            Id.StructField => @fieldParentPtr(NodeStructField, "base", base).iterate(index),
-            Id.UnionTag => @fieldParentPtr(NodeUnionTag, "base", base).iterate(index),
-            Id.EnumTag => @fieldParentPtr(NodeEnumTag, "base", base).iterate(index),
-            Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).iterate(index),
-            Id.AsyncAttribute => @fieldParentPtr(NodeAsyncAttribute, "base", base).iterate(index),
-            Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).iterate(index),
-            Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).iterate(index),
-            Id.Block => @fieldParentPtr(NodeBlock, "base", base).iterate(index),
-            Id.Defer => @fieldParentPtr(NodeDefer, "base", base).iterate(index),
-            Id.Comptime => @fieldParentPtr(NodeComptime, "base", base).iterate(index),
-            Id.Payload => @fieldParentPtr(NodePayload, "base", base).iterate(index),
-            Id.PointerPayload => @fieldParentPtr(NodePointerPayload, "base", base).iterate(index),
-            Id.PointerIndexPayload => @fieldParentPtr(NodePointerIndexPayload, "base", base).iterate(index),
-            Id.Else => @fieldParentPtr(NodeSwitch, "base", base).iterate(index),
-            Id.Switch => @fieldParentPtr(NodeSwitch, "base", base).iterate(index),
-            Id.SwitchCase => @fieldParentPtr(NodeSwitchCase, "base", base).iterate(index),
-            Id.SwitchElse => @fieldParentPtr(NodeSwitchElse, "base", base).iterate(index),
-            Id.While => @fieldParentPtr(NodeWhile, "base", base).iterate(index),
-            Id.For => @fieldParentPtr(NodeFor, "base", base).iterate(index),
-            Id.If => @fieldParentPtr(NodeIf, "base", base).iterate(index),
-            Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).iterate(index),
-            Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).iterate(index),
-            Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).iterate(index),
-            Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).iterate(index),
-            Id.ControlFlowExpression => @fieldParentPtr(NodeControlFlowExpression, "base", base).iterate(index),
-            Id.Suspend => @fieldParentPtr(NodeSuspend, "base", base).iterate(index),
-            Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).iterate(index),
-            Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).iterate(index),
-            Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).iterate(index),
-            Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).iterate(index),
-            Id.MultilineStringLiteral => @fieldParentPtr(NodeMultilineStringLiteral, "base", base).iterate(index),
-            Id.CharLiteral => @fieldParentPtr(NodeCharLiteral, "base", base).iterate(index),
-            Id.BoolLiteral => @fieldParentPtr(NodeBoolLiteral, "base", base).iterate(index),
-            Id.NullLiteral => @fieldParentPtr(NodeNullLiteral, "base", base).iterate(index),
-            Id.UndefinedLiteral => @fieldParentPtr(NodeUndefinedLiteral, "base", base).iterate(index),
-            Id.ThisLiteral => @fieldParentPtr(NodeThisLiteral, "base", base).iterate(index),
-            Id.Asm => @fieldParentPtr(NodeAsm, "base", base).iterate(index),
-            Id.AsmInput => @fieldParentPtr(NodeAsmInput, "base", base).iterate(index),
-            Id.AsmOutput => @fieldParentPtr(NodeAsmOutput, "base", base).iterate(index),
-            Id.Unreachable => @fieldParentPtr(NodeUnreachable, "base", base).iterate(index),
-            Id.ErrorType => @fieldParentPtr(NodeErrorType, "base", base).iterate(index),
-            Id.VarType => @fieldParentPtr(NodeVarType, "base", base).iterate(index),
-            Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).iterate(index),
-            Id.LineComment => @fieldParentPtr(NodeLineComment, "base", base).iterate(index),
-            Id.TestDecl => @fieldParentPtr(NodeTestDecl, "base", base).iterate(index),
-        };
     }
 
     pub fn firstToken(base: &Node) Token {
-        return switch (base.id) {
+        inline for (idTypeTable) |id_type_pair| {
-            Id.Root => @fieldParentPtr(NodeRoot, "base", base).firstToken(),
+            if (base.id == id_type_pair.id)
-            Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).firstToken(),
+                return @fieldParentPtr(id_type_pair.Type, "base", base).firstToken();
-            Id.Use => @fieldParentPtr(NodeUse, "base", base).firstToken(),
+        }
-            Id.ErrorSetDecl => @fieldParentPtr(NodeErrorSetDecl, "base", base).firstToken(),
+
-            Id.ContainerDecl => @fieldParentPtr(NodeContainerDecl, "base", base).firstToken(),
+        unreachable;
-            Id.StructField => @fieldParentPtr(NodeStructField, "base", base).firstToken(),
-            Id.UnionTag => @fieldParentPtr(NodeUnionTag, "base", base).firstToken(),
-            Id.EnumTag => @fieldParentPtr(NodeEnumTag, "base", base).firstToken(),
-            Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).firstToken(),
-            Id.AsyncAttribute => @fieldParentPtr(NodeAsyncAttribute, "base", base).firstToken(),
-            Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).firstToken(),
-            Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).firstToken(),
-            Id.Block => @fieldParentPtr(NodeBlock, "base", base).firstToken(),
-            Id.Defer => @fieldParentPtr(NodeDefer, "base", base).firstToken(),
-            Id.Comptime => @fieldParentPtr(NodeComptime, "base", base).firstToken(),
-            Id.Payload => @fieldParentPtr(NodePayload, "base", base).firstToken(),
-            Id.PointerPayload => @fieldParentPtr(NodePointerPayload, "base", base).firstToken(),
-            Id.PointerIndexPayload => @fieldParentPtr(NodePointerIndexPayload, "base", base).firstToken(),
-            Id.Else => @fieldParentPtr(NodeSwitch, "base", base).firstToken(),
-            Id.Switch => @fieldParentPtr(NodeSwitch, "base", base).firstToken(),
-            Id.SwitchCase => @fieldParentPtr(NodeSwitchCase, "base", base).firstToken(),
-            Id.SwitchElse => @fieldParentPtr(NodeSwitchElse, "base", base).firstToken(),
-            Id.While => @fieldParentPtr(NodeWhile, "base", base).firstToken(),
-            Id.For => @fieldParentPtr(NodeFor, "base", base).firstToken(),
-            Id.If => @fieldParentPtr(NodeIf, "base", base).firstToken(),
-            Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).firstToken(),
-            Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).firstToken(),
-            Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).firstToken(),
-            Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).firstToken(),
-            Id.ControlFlowExpression => @fieldParentPtr(NodeControlFlowExpression, "base", base).firstToken(),
-            Id.Suspend => @fieldParentPtr(NodeSuspend, "base", base).firstToken(),
-            Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).firstToken(),
-            Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).firstToken(),
-            Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).firstToken(),
-            Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).firstToken(),
-            Id.MultilineStringLiteral => @fieldParentPtr(NodeMultilineStringLiteral, "base", base).firstToken(),
-            Id.CharLiteral => @fieldParentPtr(NodeCharLiteral, "base", base).firstToken(),
-            Id.BoolLiteral => @fieldParentPtr(NodeBoolLiteral, "base", base).firstToken(),
-            Id.NullLiteral => @fieldParentPtr(NodeNullLiteral, "base", base).firstToken(),
-            Id.UndefinedLiteral => @fieldParentPtr(NodeUndefinedLiteral, "base", base).firstToken(),
-            Id.Unreachable => @fieldParentPtr(NodeUnreachable, "base", base).firstToken(),
-            Id.ThisLiteral => @fieldParentPtr(NodeThisLiteral, "base", base).firstToken(),
-            Id.Asm => @fieldParentPtr(NodeAsm, "base", base).firstToken(),
-            Id.AsmInput => @fieldParentPtr(NodeAsmInput, "base", base).firstToken(),
-            Id.AsmOutput => @fieldParentPtr(NodeAsmOutput, "base", base).firstToken(),
-            Id.ErrorType => @fieldParentPtr(NodeErrorType, "base", base).firstToken(),
-            Id.VarType => @fieldParentPtr(NodeVarType, "base", base).firstToken(),
-            Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).firstToken(),
-            Id.LineComment => @fieldParentPtr(NodeLineComment, "base", base).firstToken(),
-            Id.TestDecl => @fieldParentPtr(NodeTestDecl, "base", base).firstToken(),
-        };
     }
 
     pub fn lastToken(base: &Node) Token {
-        return switch (base.id) {
+        inline for (idTypeTable) |id_type_pair| {
-            Id.Root => @fieldParentPtr(NodeRoot, "base", base).lastToken(),
+            if (base.id == id_type_pair.id)
-            Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).lastToken(),
+                return @fieldParentPtr(id_type_pair.Type, "base", base).lastToken();
-            Id.Use => @fieldParentPtr(NodeUse, "base", base).lastToken(),
+        }
-            Id.ErrorSetDecl => @fieldParentPtr(NodeErrorSetDecl, "base", base).lastToken(),
+
-            Id.ContainerDecl => @fieldParentPtr(NodeContainerDecl, "base", base).lastToken(),
+        unreachable;
-            Id.StructField => @fieldParentPtr(NodeStructField, "base", base).lastToken(),
-            Id.UnionTag => @fieldParentPtr(NodeUnionTag, "base", base).lastToken(),
-            Id.EnumTag => @fieldParentPtr(NodeEnumTag, "base", base).lastToken(),
-            Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).lastToken(),
-            Id.AsyncAttribute => @fieldParentPtr(NodeAsyncAttribute, "base", base).lastToken(),
-            Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).lastToken(),
-            Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).lastToken(),
-            Id.Block => @fieldParentPtr(NodeBlock, "base", base).lastToken(),
-            Id.Defer => @fieldParentPtr(NodeDefer, "base", base).lastToken(),
-            Id.Comptime => @fieldParentPtr(NodeComptime, "base", base).lastToken(),
-            Id.Payload => @fieldParentPtr(NodePayload, "base", base).lastToken(),
-            Id.PointerPayload => @fieldParentPtr(NodePointerPayload, "base", base).lastToken(),
-            Id.PointerIndexPayload => @fieldParentPtr(NodePointerIndexPayload, "base", base).lastToken(),
-            Id.Else => @fieldParentPtr(NodeElse, "base", base).lastToken(),
-            Id.Switch => @fieldParentPtr(NodeSwitch, "base", base).lastToken(),
-            Id.SwitchCase => @fieldParentPtr(NodeSwitchCase, "base", base).lastToken(),
-            Id.SwitchElse => @fieldParentPtr(NodeSwitchElse, "base", base).lastToken(),
-            Id.While => @fieldParentPtr(NodeWhile, "base", base).lastToken(),
-            Id.For => @fieldParentPtr(NodeFor, "base", base).lastToken(),
-            Id.If => @fieldParentPtr(NodeIf, "base", base).lastToken(),
-            Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).lastToken(),
-            Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).lastToken(),
-            Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).lastToken(),
-            Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).lastToken(),
-            Id.ControlFlowExpression => @fieldParentPtr(NodeControlFlowExpression, "base", base).lastToken(),
-            Id.Suspend => @fieldParentPtr(NodeSuspend, "base", base).lastToken(),
-            Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).lastToken(),
-            Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).lastToken(),
-            Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).lastToken(),
-            Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).lastToken(),
-            Id.MultilineStringLiteral => @fieldParentPtr(NodeMultilineStringLiteral, "base", base).lastToken(),
-            Id.CharLiteral => @fieldParentPtr(NodeCharLiteral, "base", base).lastToken(),
-            Id.BoolLiteral => @fieldParentPtr(NodeBoolLiteral, "base", base).lastToken(),
-            Id.NullLiteral => @fieldParentPtr(NodeNullLiteral, "base", base).lastToken(),
-            Id.UndefinedLiteral => @fieldParentPtr(NodeUndefinedLiteral, "base", base).lastToken(),
-            Id.ThisLiteral => @fieldParentPtr(NodeThisLiteral, "base", base).lastToken(),
-            Id.Asm => @fieldParentPtr(NodeAsm, "base", base).lastToken(),
-            Id.AsmInput => @fieldParentPtr(NodeAsmInput, "base", base).lastToken(),
-            Id.AsmOutput => @fieldParentPtr(NodeAsmOutput, "base", base).lastToken(),
-            Id.Unreachable => @fieldParentPtr(NodeUnreachable, "base", base).lastToken(),
-            Id.ErrorType => @fieldParentPtr(NodeErrorType, "base", base).lastToken(),
-            Id.VarType => @fieldParentPtr(NodeVarType, "base", base).lastToken(),
-            Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).lastToken(),
-            Id.LineComment => @fieldParentPtr(NodeLineComment, "base", base).lastToken(),
-            Id.TestDecl => @fieldParentPtr(NodeTestDecl, "base", base).lastToken(),
-        };
     }
 };
 
@@ -255,7 +214,7 @@ pub const NodeVarDecl = struct {
     eq_token: Token,
     mut_token: Token,
     comptime_token: ?Token,
-    extern_token: ?Token,
+    extern_export_token: ?Token,
     lib_name: ?&Node,
     type_node: ?&Node,
     align_node: ?&Node,
@@ -286,7 +245,7 @@ pub const NodeVarDecl = struct {
     pub fn firstToken(self: &NodeVarDecl) Token {
         if (self.visib_token) |visib_token| return visib_token;
         if (self.comptime_token) |comptime_token| return comptime_token;
-        if (self.extern_token) |extern_token| return extern_token;
+        if (self.extern_export_token) |extern_export_token| return extern_export_token;
         assert(self.lib_name == null);
         return self.mut_token;
     }
@@ -324,13 +283,13 @@ pub const NodeUse = struct {
 pub const NodeErrorSetDecl = struct {
     base: Node,
     error_token: Token,
-    decls: ArrayList(&NodeIdentifier),
+    decls: ArrayList(&Node),
     rbrace_token: Token,
 
     pub fn iterate(self: &NodeErrorSetDecl, index: usize) ?&Node {
         var i = index;
 
-        if (i < self.decls.len) return &self.decls.at(i).base;
+        if (i < self.decls.len) return self.decls.at(i);
         i -= self.decls.len;
 
         return null;
@@ -401,6 +360,7 @@ pub const NodeContainerDecl = struct {
 
 pub const NodeStructField = struct {
     base: Node,
+    visib_token: ?Token,
     name_token: Token,
     type_expr: &Node,
 
@@ -414,6 +374,7 @@ pub const NodeStructField = struct {
     }
 
     pub fn firstToken(self: &NodeStructField) Token {
+        if (self.visib_token) |visib_token| return visib_token;
         return self.name_token;
     }
 
@@ -482,18 +443,18 @@ pub const NodeEnumTag = struct {
 
 pub const NodeIdentifier = struct {
     base: Node,
-    name_token: Token,
+    token: Token,
 
     pub fn iterate(self: &NodeIdentifier, index: usize) ?&Node {
         return null;
     }
 
     pub fn firstToken(self: &NodeIdentifier) Token {
-        return self.name_token;
+        return self.token;
     }
 
     pub fn lastToken(self: &NodeIdentifier) Token {
-        return self.name_token;
+        return self.token;
     }
 };
 
@@ -535,8 +496,7 @@ pub const NodeFnProto = struct {
     params: ArrayList(&Node),
     return_type: ReturnType,
     var_args_token: ?Token,
-    extern_token: ?Token,
+    extern_export_inline_token: ?Token,
-    inline_token: ?Token,
     cc_token: ?Token,
     async_attr: ?&NodeAsyncAttribute,
     body_node: ?&Node,
@@ -586,9 +546,8 @@ pub const NodeFnProto = struct {
 
     pub fn firstToken(self: &NodeFnProto) Token {
         if (self.visib_token) |visib_token| return visib_token;
-        if (self.extern_token) |extern_token| return extern_token;
+        if (self.extern_export_inline_token) |extern_export_inline_token| return extern_export_inline_token;
         assert(self.lib_name == null);
-        if (self.inline_token) |inline_token| return inline_token;
         if (self.cc_token) |cc_token| return cc_token;
         return self.fn_token;
     }
@@ -717,13 +676,13 @@ pub const NodeComptime = struct {
 pub const NodePayload = struct {
     base: Node,
     lpipe: Token,
-    error_symbol: &NodeIdentifier,
+    error_symbol: &Node,
     rpipe: Token,
 
     pub fn iterate(self: &NodePayload, index: usize) ?&Node {
         var i = index;
 
-        if (i < 1) return &self.error_symbol.base;
+        if (i < 1) return self.error_symbol;
         i -= 1;
 
         return null;
@@ -741,14 +700,14 @@ pub const NodePayload = struct {
 pub const NodePointerPayload = struct {
     base: Node,
     lpipe: Token,
-    is_ptr: bool,
+    ptr_token: ?Token,
-    value_symbol: &NodeIdentifier,
+    value_symbol: &Node,
     rpipe: Token,
 
     pub fn iterate(self: &NodePointerPayload, index: usize) ?&Node {
         var i = index;
 
-        if (i < 1) return &self.value_symbol.base;
+        if (i < 1) return self.value_symbol;
         i -= 1;
 
         return null;
@@ -766,19 +725,19 @@ pub const NodePointerPayload = struct {
 pub const NodePointerIndexPayload = struct {
     base: Node,
     lpipe: Token,
-    is_ptr: bool,
+    ptr_token: ?Token,
-    value_symbol: &NodeIdentifier,
+    value_symbol: &Node,
-    index_symbol: ?&NodeIdentifier,
+    index_symbol: ?&Node,
     rpipe: Token,
 
     pub fn iterate(self: &NodePointerIndexPayload, index: usize) ?&Node {
         var i = index;
 
-        if (i < 1) return &self.value_symbol.base;
+        if (i < 1) return self.value_symbol;
         i -= 1;
 
         if (self.index_symbol) |index_symbol| {
-            if (i < 1) return &index_symbol.base;
+            if (i < 1) return index_symbol;
             i -= 1;
         }
 
@@ -797,14 +756,14 @@ pub const NodePointerIndexPayload = struct {
 pub const NodeElse = struct {
     base: Node,
     else_token: Token,
-    payload: ?&NodePayload,
+    payload: ?&Node,
     body: &Node,
 
     pub fn iterate(self: &NodeElse, index: usize) ?&Node {
         var i = index;
 
         if (self.payload) |payload| {
-            if (i < 1) return &payload.base;
+            if (i < 1) return payload;
             i -= 1;
         }
 
@@ -854,7 +813,7 @@ pub const NodeSwitch = struct {
 pub const NodeSwitchCase = struct {
     base: Node,
     items: ArrayList(&Node),
-    payload: ?&NodePointerPayload,
+    payload: ?&Node,
     expr: &Node,
 
     pub fn iterate(self: &NodeSwitchCase, index: usize) ?&Node {
@@ -864,7 +823,7 @@ pub const NodeSwitchCase = struct {
         i -= self.items.len;
 
         if (self.payload) |payload| {
-            if (i < 1) return &payload.base;
+            if (i < 1) return payload;
             i -= 1;
         }
 
@@ -906,7 +865,7 @@ pub const NodeWhile = struct {
     inline_token: ?Token,
     while_token: Token,
     condition: &Node,
-    payload: ?&NodePointerPayload,
+    payload: ?&Node,
     continue_expr: ?&Node,
     body: &Node,
     @"else": ?&NodeElse,
@@ -918,7 +877,7 @@ pub const NodeWhile = struct {
         i -= 1;
 
         if (self.payload) |payload| {
-            if (i < 1) return &payload.base;
+            if (i < 1) return payload;
             i -= 1;
         }
 
@@ -965,7 +924,7 @@ pub const NodeFor = struct {
     inline_token: ?Token,
     for_token: Token,
     array_expr: &Node,
-    payload: ?&NodePointerIndexPayload,
+    payload: ?&Node,
     body: &Node,
     @"else": ?&NodeElse,
 
@@ -976,7 +935,7 @@ pub const NodeFor = struct {
         i -= 1;
 
         if (self.payload) |payload| {
-            if (i < 1) return &payload.base;
+            if (i < 1) return payload;
             i -= 1;
         }
 
@@ -1016,7 +975,7 @@ pub const NodeIf = struct {
     base: Node,
     if_token: Token,
     condition: &Node,
-    payload: ?&NodePointerPayload,
+    payload: ?&Node,
     body: &Node,
     @"else": ?&NodeElse,
 
@@ -1027,7 +986,7 @@ pub const NodeIf = struct {
         i -= 1;
 
         if (self.payload) |payload| {
-            if (i < 1) return &payload.base;
+            if (i < 1) return payload;
             i -= 1;
         }
 
@@ -1089,7 +1048,7 @@ pub const NodeInfixOp = struct {
         BitXor,
         BoolAnd,
         BoolOr,
-        Catch: ?&NodePayload,
+        Catch: ?&Node,
         Div,
         EqualEqual,
         ErrorUnion,
@@ -1117,7 +1076,7 @@ pub const NodeInfixOp = struct {
         switch (self.op) {
             InfixOp.Catch => |maybe_payload| {
                 if (maybe_payload) |payload| {
-                    if (i < 1) return &payload.base;
+                    if (i < 1) return payload;
                     i -= 1;
                 }
             },
@@ -1385,14 +1344,30 @@ pub const NodeControlFlowExpression = struct {
     rhs: ?&Node,
 
     const Kind = union(enum) {
-        Break: ?Token,
+        Break: ?&Node,
-        Continue: ?Token,
+        Continue: ?&Node,
         Return,
     };
 
     pub fn iterate(self: &NodeControlFlowExpression, index: usize) ?&Node {
         var i = index;
 
+        switch (self.kind) {
+            Kind.Break => |maybe_label| {
+                if (maybe_label) |label| {
+                    if (i < 1) return label;
+                    i -= 1;
+                }
+            },
+            Kind.Continue => |maybe_label| {
+                if (maybe_label) |label| {
+                    if (i < 1) return label;
+                    i -= 1;
+                }
+            },
+            Kind.Return => {},
+        }
+
         if (self.rhs) |rhs| {
             if (i < 1) return rhs;
             i -= 1;
@@ -1411,14 +1386,14 @@ pub const NodeControlFlowExpression = struct {
         }
 
         switch (self.kind) {
-            Kind.Break => |maybe_blk_token| {
+            Kind.Break => |maybe_label| {
-                if (maybe_blk_token) |blk_token| {
+                if (maybe_label) |label| {
-                    return blk_token;
+                    return label.lastToken();
                 }
             },
-            Kind.Continue => |maybe_blk_token| {
+            Kind.Continue => |maybe_label| {
-                if (maybe_blk_token) |blk_token| {
+                if (maybe_label) |label| {
-                    return blk_token;
+                    return label.lastToken();
                 }
             },
             Kind.Return => return self.ltoken,
@@ -1431,14 +1406,14 @@ pub const NodeControlFlowExpression = struct {
 pub const NodeSuspend = struct {
     base: Node,
     suspend_token: Token,
-    payload: ?&NodePayload,
+    payload: ?&Node,
     body: ?&Node,
 
     pub fn iterate(self: &NodeSuspend, index: usize) ?&Node {
         var i = index;
 
         if (self.payload) |payload| {
-            if (i < 1) return &payload.base;
+            if (i < 1) return payload;
             i -= 1;
         }
 
@@ -1646,8 +1621,8 @@ pub const NodeThisLiteral = struct {
 
 pub const NodeAsmOutput = struct {
     base: Node,
-    symbolic_name: &NodeIdentifier,
+    symbolic_name: &Node,
-    constraint: &NodeStringLiteral,
+    constraint: &Node,
     kind: Kind,
 
     const Kind = union(enum) {
@@ -1658,10 +1633,10 @@ pub const NodeAsmOutput = struct {
     pub fn iterate(self: &NodeAsmOutput, index: usize) ?&Node {
         var i = index;
 
-        if (i < 1) return &self.symbolic_name.base;
+        if (i < 1) return self.symbolic_name;
         i -= 1;
 
-        if (i < 1) return &self.constraint.base;
+        if (i < 1) return self.constraint;
         i -= 1;
 
         switch (self.kind) {
@@ -1692,17 +1667,17 @@ pub const NodeAsmOutput = struct {
 
 pub const NodeAsmInput = struct {
     base: Node,
-    symbolic_name: &NodeIdentifier,
+    symbolic_name: &Node,
-    constraint: &NodeStringLiteral,
+    constraint: &Node,
     expr: &Node,
 
     pub fn iterate(self: &NodeAsmInput, index: usize) ?&Node {
         var i = index;
 
-        if (i < 1) return &self.symbolic_name.base;
+        if (i < 1) return self.symbolic_name;
         i -= 1;
 
-        if (i < 1) return &self.constraint.base;
+        if (i < 1) return self.constraint;
         i -= 1;
 
         if (i < 1) return self.expr;
@@ -1723,12 +1698,12 @@ pub const NodeAsmInput = struct {
 pub const NodeAsm = struct {
     base: Node,
     asm_token: Token,
-    is_volatile: bool,
+    volatile_token: ?Token,
-    template: Token,
+    template: &Node,
     //tokens: ArrayList(AsmToken),
     outputs: ArrayList(&NodeAsmOutput),
     inputs: ArrayList(&NodeAsmInput),
-    cloppers: ArrayList(&NodeStringLiteral),
+    cloppers: ArrayList(&Node),
     rparen: Token,
 
     pub fn iterate(self: &NodeAsm, index: usize) ?&Node {
@@ -1740,7 +1715,7 @@ pub const NodeAsm = struct {
         if (i < self.inputs.len) return &self.inputs.at(index).base;
         i -= self.inputs.len;
 
-        if (i < self.cloppers.len) return &self.cloppers.at(index).base;
+        if (i < self.cloppers.len) return self.cloppers.at(index);
         i -= self.cloppers.len;
 
         return null;

test/cases/fn.zig

@@ -94,3 +94,20 @@ test "inline function call" {
 }
 
 fn add(a: i32, b: i32) i32 { return a + b; }
+
+
+test "number literal as an argument" {
+    numberLiteralArg(3);
+    comptime numberLiteralArg(3);
+}
+
+fn numberLiteralArg(a: var) void {
+    assert(a == 3);
+}
+
+test "assign inline fn to const variable" {
+    const a = inlineFn;
+    a();
+}
+
+inline fn inlineFn() void { }

test/compile_errors.zig

@@ -1,6 +1,15 @@
 const tests = @import("tests.zig");
 
 pub fn addCases(cases: &tests.CompileErrorContext) void {
+    cases.add("assign inline fn to non-comptime var",
+        \\export fn entry() void {
+        \\    var a = b;
+        \\}
+        \\inline fn b() void { }
+    ,
+        ".tmp_source.zig:2:5: error: functions marked inline must be stored in const or comptime var",
+        ".tmp_source.zig:4:8: note: declared here");
+
     cases.add("wrong type passed to @panic",
         \\export fn entry() void {
         \\    var e = error.Foo;
@@ -1723,7 +1732,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(bar)); }
-    , ".tmp_source.zig:10:16: error: parameter of type '(integer literal)' requires comptime");
+    , ".tmp_source.zig:10:16: error: compiler bug: integer and float literals in var args function must be casted");
 
     cases.add("assign too big number to u16",
         \\export fn foo() void {