Merge remote-tracking branch 'origin/master' into async-fs

.gitignore

@@ -1,3 +1,14 @@
+# This file is for zig-specific build artifacts.
+# If you have OS-specific or editor-specific files to ignore,
+# such as *.swp or .DS_Store, put those in your global
+# ~/.gitignore and put this in your ~/.gitconfig:
+#
+# [core]
+#     excludesfile = ~/.gitignore
+#
+# Cheers!
+# -andrewrk
+
 zig-cache/
 build/
 build-*/

src/ir.cpp

@@ -3332,7 +3332,15 @@ static VariableTableEntry *create_local_var(CodeGen *codegen, AstNode *node, Sco
 static VariableTableEntry *ir_create_var(IrBuilder *irb, AstNode *node, Scope *scope, Buf *name,
         bool src_is_const, bool gen_is_const, bool is_shadowable, IrInstruction *is_comptime)
 {
-    VariableTableEntry *var = create_local_var(irb->codegen, node, scope, name, src_is_const, gen_is_const, is_shadowable, is_comptime);
+    bool is_underscored = name ? buf_eql_str(name, "_") : false;
+    VariableTableEntry *var = create_local_var( irb->codegen
+                                              , node
+                                              , scope
+                                              , (is_underscored ? nullptr : name)
+                                              , src_is_const
+                                              , gen_is_const
+                                              , (is_underscored ? true : is_shadowable)
+                                              , is_comptime );
     if (is_comptime != nullptr || gen_is_const) {
         var->mem_slot_index = exec_next_mem_slot(irb->exec);
         var->owner_exec = irb->exec;
@@ -5186,6 +5194,11 @@ static IrInstruction *ir_gen_var_decl(IrBuilder *irb, Scope *scope, AstNode *nod
 
     AstNodeVariableDeclaration *variable_declaration = &node->data.variable_declaration;
 
+    if (buf_eql_str(variable_declaration->symbol, "_")) {
+        add_node_error(irb->codegen, node, buf_sprintf("`_` is not a declarable symbol"));
+        return irb->codegen->invalid_instruction;
+    }
+
     IrInstruction *type_instruction;
     if (variable_declaration->type != nullptr) {
         type_instruction = ir_gen_node(irb, variable_declaration->type, scope);
@@ -5198,6 +5211,7 @@ static IrInstruction *ir_gen_var_decl(IrBuilder *irb, Scope *scope, AstNode *nod
     bool is_shadowable = false;
     bool is_const = variable_declaration->is_const;
     bool is_extern = variable_declaration->is_extern;
+
     IrInstruction *is_comptime = ir_build_const_bool(irb, scope, node,
         ir_should_inline(irb->exec, scope) || variable_declaration->is_comptime);
     VariableTableEntry *var = ir_create_var(irb, node, scope, variable_declaration->symbol,

std/os/linux/index.zig

@@ -999,7 +999,7 @@ pub fn setgroups(size: usize, list: *const u32) usize {
 }
 
 pub fn getpid() i32 {
-    return @bitCast(i32, u32(syscall0(SYS_getpid)));
+    return @bitCast(i32, @truncate(u32, syscall0(SYS_getpid)));
 }
 
 pub fn sigprocmask(flags: u32, noalias set: *const sigset_t, noalias oldset: ?*sigset_t) usize {

std/os/linux/test.zig

@@ -3,6 +3,10 @@ const builtin = @import("builtin");
 const linux = std.os.linux;
 const assert = std.debug.assert;
 
+test "getpid" {
+    assert(linux.getpid() != 0);
+}
+
 test "timer" {
     const epoll_fd = linux.epoll_create();
     var err = linux.getErrno(epoll_fd);

std/rand/index.zig

@@ -30,7 +30,7 @@ pub const DefaultCsprng = Isaac64;
 pub const Random = struct {
     fillFn: fn (r: *Random, buf: []u8) void,
 
-    /// Read random bytes into the specified buffer until fill.
+    /// Read random bytes into the specified buffer until full.
     pub fn bytes(r: *Random, buf: []u8) void {
         r.fillFn(r, buf);
     }
@@ -48,10 +48,10 @@ pub const Random = struct {
         }
     }
 
-    /// Get a random unsigned integer with even distribution between `start`
+    /// Return a random integer with even distribution between `start`
-    /// inclusive and `end` exclusive.
+    /// inclusive and `end` exclusive.  `start` must be less than `end`.
     pub fn range(r: *Random, comptime T: type, start: T, end: T) T {
-        assert(start <= end);
+        assert(start < end);
         if (T.is_signed) {
             const uint = @IntType(false, T.bit_count);
             if (start >= 0 and end >= 0) {
@@ -664,6 +664,7 @@ test "Random range" {
     testRange(&prng.random, -4, 3);
     testRange(&prng.random, -4, -1);
     testRange(&prng.random, 10, 14);
+    // TODO: test that prng.random.range(1, 1) causes an assertion error
 }
 
 fn testRange(r: *Random, start: i32, end: i32) void {

test/behavior.zig

@@ -60,6 +60,7 @@ comptime {
     _ = @import("cases/try.zig");
     _ = @import("cases/type_info.zig");
     _ = @import("cases/undefined.zig");
+    _ = @import("cases/underscore.zig");
     _ = @import("cases/union.zig");
     _ = @import("cases/var_args.zig");
     _ = @import("cases/void.zig");

test/cases/underscore.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+test "ignore lval with underscore" {
+    _ = false;
+}
+
+test "ignore lval with underscore (for loop)" {
+    for ([]void{}) |_, i| {
+        for ([]void{}) |_, j| {
+            break;
+        }
+        break;
+    }
+}
+
+test "ignore lval with underscore (while loop)" {
+    while (optionalReturnError()) |_| {
+      while (optionalReturnError()) |_| {
+          break;
+      } else |_| { }
+      break;
+    } else |_| { }
+}
+
+fn optionalReturnError() !?u32 {
+    return error.optionalReturnError;
+}

test/cases/union.zig

@@ -297,3 +297,17 @@ test "access a member of tagged union with conflicting enum tag name" {
 
     comptime assert(Bar.A == u8);
 }
+
+test "tagged union initialization with runtime void" {
+    assert(testTaggedUnionInit({}));
+}
+
+const TaggedUnionWithAVoid = union(enum) {
+    A,
+    B: i32,
+};
+
+fn testTaggedUnionInit(x: var) bool {
+    const y = TaggedUnionWithAVoid{ .A = x };
+    return @TagType(TaggedUnionWithAVoid)(y) == TaggedUnionWithAVoid.A;
+}

test/compile_errors.zig

@@ -22,6 +22,64 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ".tmp_source.zig:3:28: error: @handle() in non-async function",
     );
 
+    cases.add(
+        "`_` is not a declarable symbol",
+        \\export fn f1() usize {
+        \\    var _: usize = 2;
+        \\    return _;
+        \\}
+    ,
+        ".tmp_source.zig:2:5: error: `_` is not a declarable symbol",
+        ".tmp_source.zig:3:12: error: use of undeclared identifier '_'",
+    );
+
+    cases.add(
+        "`_` should not be usable inside for",
+        \\export fn returns() void {
+        \\    for ([]void{}) |_, i| {
+        \\        for ([]void{}) |_, j| {
+        \\            return _;
+        \\        }
+        \\    }
+        \\}
+    ,
+        ".tmp_source.zig:4:20: error: use of undeclared identifier '_'",
+    );
+
+    cases.add(
+        "`_` should not be usable inside while",
+        \\export fn returns() void {
+        \\    while (optionalReturn()) |_| {
+        \\        while (optionalReturn()) |_| {
+        \\            return _;
+        \\        }
+        \\    }
+        \\}
+        \\fn optionalReturn() ?u32 {
+        \\    return 1;
+        \\}
+    ,
+        ".tmp_source.zig:4:20: error: use of undeclared identifier '_'",
+    );
+
+    cases.add(
+        "`_` should not be usable inside while else",
+        \\export fn returns() void {
+        \\    while (optionalReturnError()) |_| {
+        \\        while (optionalReturnError()) |_| {
+        \\            return;
+        \\        } else |_| {
+        \\            if (_ == error.optionalReturnError) return;
+        \\        }
+        \\    }
+        \\}
+        \\fn optionalReturnError() !?u32 {
+        \\    return error.optionalReturnError;
+        \\}
+    ,
+        ".tmp_source.zig:6:17: error: use of undeclared identifier '_'",
+    );
+
     cases.add(
         "while loop body expression ignored",
         \\fn returns() usize {