Merge remote-tracking branch 'origin/master' into llvm7

8 files changed, 199 insertions, 3 deletions

diff --git a/test/cases/atomics.zig b/test/cases/atomics.zig
index e8e81b76e6..d406285d29 100644
--- a/test/cases/atomics.zig
+++ b/test/cases/atomics.zig
@@ -1,12 +1,24 @@
-const assert = @import("std").debug.assert;
+const std = @import("std");
+const assert = std.debug.assert;
 const builtin = @import("builtin");
 const AtomicRmwOp = builtin.AtomicRmwOp;
 const AtomicOrder = builtin.AtomicOrder;
 
 test "cmpxchg" {
     var x: i32 = 1234;
-    while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
+    if (@cmpxchgWeak(i32, &x, 99, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| {
+        assert(x1 == 1234);
+    } else {
+        @panic("cmpxchg should have failed");
+    }
+
+    while (@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| {
+        assert(x1 == 1234);
+    }
     assert(x == 5678);
+
+    assert(@cmpxchgStrong(i32, &x, 5678, 42, AtomicOrder.SeqCst, AtomicOrder.SeqCst) == null);
+    assert(x == 42);
 }
 
 test "fence" {
@@ -15,13 +27,45 @@ test "fence" {
     x = 5678;
 }
 
-test "atomicrmw" {
+test "atomicrmw and atomicload" {
     var data: u8 = 200;
     testAtomicRmw(&data);
     assert(data == 42);
+    testAtomicLoad(&data);
 }
 
 fn testAtomicRmw(ptr: &u8) void {
     const prev_value = @atomicRmw(u8, ptr, AtomicRmwOp.Xchg, 42, AtomicOrder.SeqCst);
     assert(prev_value == 200);
+    comptime {
+        var x: i32 = 1234;
+        const y: i32 = 12345;
+        assert(@atomicLoad(i32, &x, AtomicOrder.SeqCst) == 1234);
+        assert(@atomicLoad(i32, &y, AtomicOrder.SeqCst) == 12345);
+    }
+}
+
+fn testAtomicLoad(ptr: &u8) void {
+    const x = @atomicLoad(u8, ptr, AtomicOrder.SeqCst);
+    assert(x == 42);
+}
+
+test "cmpxchg with ptr" {
+    var data1: i32 = 1234;
+    var data2: i32 = 5678;
+    var data3: i32 = 9101;
+    var x: &i32 = &data1;
+    if (@cmpxchgWeak(&i32, &x, &data2, &data3, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| {
+        assert(x1 == &data1);
+    } else {
+        @panic("cmpxchg should have failed");
+    }
+
+    while (@cmpxchgWeak(&i32, &x, &data1, &data3, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| {
+        assert(x1 == &data1);
+    }
+    assert(x == &data3);
+
+    assert(@cmpxchgStrong(&i32, &x, &data3, &data2, AtomicOrder.SeqCst, AtomicOrder.SeqCst) == null);
+    assert(x == &data2);
 }
diff --git a/test/cases/bugs/920.zig b/test/cases/bugs/920.zig
new file mode 100644
index 0000000000..13c03a304f
--- /dev/null
+++ b/test/cases/bugs/920.zig
@@ -0,0 +1,60 @@
+const std = @import("std");
+const math = std.math;
+const Random = std.rand.Random;
+
+const ZigTable = struct {
+    r: f64,
+    x: [257]f64,
+    f: [257]f64,
+
+    pdf: fn(f64) f64,
+    is_symmetric: bool,
+    zero_case: fn(&Random, f64) f64,
+};
+
+fn ZigTableGen(comptime is_symmetric: bool, comptime r: f64, comptime v: f64, comptime f: fn(f64) f64,
+       comptime f_inv: fn(f64) f64, comptime zero_case: fn(&Random, f64) f64) ZigTable {
+    var tables: ZigTable = undefined;
+
+    tables.is_symmetric = is_symmetric;
+    tables.r = r;
+    tables.pdf = f;
+    tables.zero_case = zero_case;
+
+    tables.x[0] = v / f(r);
+    tables.x[1] = r;
+
+    for (tables.x[2..256]) |*entry, i| {
+        const last = tables.x[2 + i - 1];
+        *entry = f_inv(v / last + f(last));
+    }
+    tables.x[256] = 0;
+
+    for (tables.f[0..]) |*entry, i| {
+        *entry = f(tables.x[i]);
+    }
+
+    return tables;
+}
+
+const norm_r = 3.6541528853610088;
+const norm_v = 0.00492867323399;
+
+fn norm_f(x: f64) f64 { return math.exp(-x * x / 2.0); }
+fn norm_f_inv(y: f64) f64 { return math.sqrt(-2.0 * math.ln(y)); }
+fn norm_zero_case(random: &Random, u: f64) f64 { return 0.0; }
+
+const NormalDist = blk: {
+    @setEvalBranchQuota(30000);
+    break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
+};
+
+test "bug 920 fixed" {
+    const NormalDist1 = blk: {
+        break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
+    };
+
+    for (NormalDist1.f) |_, i| {
+        std.debug.assert(NormalDist1.f[i] == NormalDist.f[i]);
+    }
+}
diff --git a/test/cases/coroutines.zig b/test/cases/coroutines.zig
index 6d28b98c9d..46055d7469 100644
--- a/test/cases/coroutines.zig
+++ b/test/cases/coroutines.zig
@@ -224,3 +224,21 @@ async fn printTrace(p: promise->error!void) void {
         }
     };
 }
+
+test "break from suspend" {
+    var buf: [500]u8 = undefined;
+    var a = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
+    var my_result: i32 = 1;
+    const p = try async<a> testBreakFromSuspend(&my_result);
+    cancel p;
+    std.debug.assert(my_result == 2);
+}
+
+async fn testBreakFromSuspend(my_result: &i32) void {
+    s: suspend |p| {
+        break :s;
+    }
+    *my_result += 1;
+    suspend;
+    *my_result += 1;
+}
diff --git a/test/cases/defer.zig b/test/cases/defer.zig
index a989af18c2..5470b4bbd0 100644
--- a/test/cases/defer.zig
+++ b/test/cases/defer.zig
@@ -41,3 +41,14 @@ fn testBreakContInDefer(x: usize) void {
         assert(i == 5);
     }
 }
+
+test "defer and labeled break" {
+    var i = usize(0);
+
+    blk: {
+        defer i += 1;
+        break :blk;
+    }
+
+    assert(i == 1);
+}
diff --git a/test/cases/eval.zig b/test/cases/eval.zig
index d6f7afe864..e13d4340e7 100644
--- a/test/cases/eval.zig
+++ b/test/cases/eval.zig
@@ -513,3 +513,19 @@ test "array concat of slices gives slice" {
         assert(std.mem.eql(u8, c, "aoeuasdf"));
     }
 }
+
+test "comptime shlWithOverflow" {
+    const ct_shifted: u64 = comptime amt: {
+        var amt = u64(0);
+        _ = @shlWithOverflow(u64, ~u64(0), 16, &amt);
+        break :amt amt;
+    };
+
+    const rt_shifted: u64 = amt: {
+        var amt = u64(0);
+        _ = @shlWithOverflow(u64, ~u64(0), 16, &amt);
+        break :amt amt;
+    };
+
+    assert(ct_shifted == rt_shifted);
+}
diff --git a/test/cases/fn.zig b/test/cases/fn.zig
index c125d98d8c..5388deac10 100644
--- a/test/cases/fn.zig
+++ b/test/cases/fn.zig
@@ -104,3 +104,10 @@ test "number literal as an argument" {
 fn numberLiteralArg(a: var) void {
     assert(a == 3);
 }
+
+test "assign inline fn to const variable" {
+    const a = inlineFn;
+    a();
+}
+
+inline fn inlineFn() void { }
diff --git a/test/cases/math.zig b/test/cases/math.zig
index 574aa39bb1..47d001a590 100644
--- a/test/cases/math.zig
+++ b/test/cases/math.zig
@@ -402,3 +402,19 @@ test "comptime float rem int" {
         assert(x == 1.0);
     }
 }
+
+test "@sqrt" {
+    testSqrt(f64, 12.0);
+    comptime testSqrt(f64, 12.0);
+    testSqrt(f32, 13.0);
+    comptime testSqrt(f32, 13.0);
+
+    const x = 14.0;
+    const y = x * x;
+    const z = @sqrt(@typeOf(y), y);
+    comptime assert(z == x);
+}
+
+fn testSqrt(comptime T: type, x: T) void {
+    assert(@sqrt(T, x * x) == x);
+}
diff --git a/test/cases/reflection.zig b/test/cases/reflection.zig
index 18a766d9fc..0abc46c9de 100644
--- a/test/cases/reflection.zig
+++ b/test/cases/reflection.zig
@@ -1,5 +1,6 @@
 const assert = @import("std").debug.assert;
 const mem = @import("std").mem;
+const reflection = this;
 
 test "reflection: array, pointer, nullable, error union type child" {
     comptime {
@@ -56,7 +57,30 @@ test "reflection: enum member types and names" {
 
 }
 
+test "reflection: @field" {
+    var f = Foo {
+        .one = 42,
+        .two = true,
+        .three = void{},
+    };
+
+    assert(f.one == f.one);
+    assert(@field(f, "o" ++ "ne") == f.one);
+    assert(@field(f, "t" ++ "wo") == f.two);
+    assert(@field(f, "th" ++ "ree") == f.three);
+    assert(@field(Foo, "const" ++ "ant") == Foo.constant);
+    assert(@field(Bar, "O" ++ "ne") == Bar.One);
+    assert(@field(Bar, "T" ++ "wo") == Bar.Two);
+    assert(@field(Bar, "Th" ++ "ree") == Bar.Three);
+    assert(@field(Bar, "F" ++ "our") == Bar.Four);
+    assert(@field(reflection, "dum" ++ "my")(true, 1, 2) == dummy(true, 1, 2));
+    @field(f, "o" ++ "ne") = 4;
+    assert(f.one == 4);
+}
+
 const Foo = struct {
+    const constant = 52;
+
     one: i32,
     two: bool,
     three: void,