Merge branch 'master' into zen_stdlib

1 files changed, 572 insertions, 72 deletions

diff --git a/test/cases/enum.zig b/test/cases/enum.zig
index 644c989b04..50edfda536 100644
--- a/test/cases/enum.zig
+++ b/test/cases/enum.zig
@@ -2,8 +2,13 @@ const assert = @import("std").debug.assert;
 const mem = @import("std").mem;
 
 test "enum type" {
-    const foo1 = Foo{ .One = 13};
-    const foo2 = Foo{. Two = Point { .x = 1234, .y = 5678, }};
+    const foo1 = Foo{ .One = 13 };
+    const foo2 = Foo{
+        .Two = Point{
+            .x = 1234,
+            .y = 5678,
+        },
+    };
     const bar = Bar.B;
 
     assert(bar == Bar.B);
@@ -41,26 +46,25 @@ const Bar = enum {
 };
 
 fn returnAnInt(x: i32) Foo {
-    return Foo { .One = x };
+    return Foo{ .One = x };
 }
 
-
 test "constant enum with payload" {
-    var empty = AnEnumWithPayload {.Empty = {}};
-    var full = AnEnumWithPayload {.Full = 13};
+    var empty = AnEnumWithPayload{ .Empty = {} };
+    var full = AnEnumWithPayload{ .Full = 13 };
     shouldBeEmpty(empty);
     shouldBeNotEmpty(full);
 }
 
-fn shouldBeEmpty(x: &const AnEnumWithPayload) void {
-    switch (*x) {
+fn shouldBeEmpty(x: *const AnEnumWithPayload) void {
+    switch (x.*) {
         AnEnumWithPayload.Empty => {},
         else => unreachable,
     }
 }
 
-fn shouldBeNotEmpty(x: &const AnEnumWithPayload) void {
-    switch (*x) {
+fn shouldBeNotEmpty(x: *const AnEnumWithPayload) void {
+    switch (x.*) {
         AnEnumWithPayload.Empty => unreachable,
         else => {},
     }
@@ -71,8 +75,6 @@ const AnEnumWithPayload = union(enum) {
     Full: i32,
 };
 
-
-
 const Number = enum {
     Zero,
     One,
@@ -90,15 +92,14 @@ test "enum to int" {
 }
 
 fn shouldEqual(n: Number, expected: u3) void {
-    assert(u3(n) == expected);
+    assert(@enumToInt(n) == expected);
 }
 
-
 test "int to enum" {
     testIntToEnumEval(3);
 }
 fn testIntToEnumEval(x: i32) void {
-    assert(IntToEnumNumber(u3(x)) == IntToEnumNumber.Three);
+    assert(@intToEnum(IntToEnumNumber, @intCast(u3, x)) == IntToEnumNumber.Three);
 }
 const IntToEnumNumber = enum {
     Zero,
@@ -108,7 +109,6 @@ const IntToEnumNumber = enum {
     Four,
 };
 
-
 test "@tagName" {
     assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
     comptime assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
@@ -124,7 +124,6 @@ const BareNumber = enum {
     Three,
 };
 
-
 test "enum alignment" {
     comptime {
         assert(@alignOf(AlignTestEnum) >= @alignOf([9]u8));
@@ -137,47 +136,529 @@ const AlignTestEnum = union(enum) {
     B: u64,
 };
 
-const ValueCount1 = enum { I0 };
-const ValueCount2 = enum { I0, I1 };
+const ValueCount1 = enum {
+    I0,
+};
+const ValueCount2 = enum {
+    I0,
+    I1,
+};
 const ValueCount256 = enum {
-    I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15,
-    I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31,
-    I32, I33, I34, I35, I36, I37, I38, I39, I40, I41, I42, I43, I44, I45, I46, I47,
-    I48, I49, I50, I51, I52, I53, I54, I55, I56, I57, I58, I59, I60, I61, I62, I63,
-    I64, I65, I66, I67, I68, I69, I70, I71, I72, I73, I74, I75, I76, I77, I78, I79,
-    I80, I81, I82, I83, I84, I85, I86, I87, I88, I89, I90, I91, I92, I93, I94, I95,
-    I96, I97, I98, I99, I100, I101, I102, I103, I104, I105, I106, I107, I108, I109,
-    I110, I111, I112, I113, I114, I115, I116, I117, I118, I119, I120, I121, I122, I123,
-    I124, I125, I126, I127, I128, I129, I130, I131, I132, I133, I134, I135, I136, I137,
-    I138, I139, I140, I141, I142, I143, I144, I145, I146, I147, I148, I149, I150, I151,
-    I152, I153, I154, I155, I156, I157, I158, I159, I160, I161, I162, I163, I164, I165,
-    I166, I167, I168, I169, I170, I171, I172, I173, I174, I175, I176, I177, I178, I179,
-    I180, I181, I182, I183, I184, I185, I186, I187, I188, I189, I190, I191, I192, I193,
-    I194, I195, I196, I197, I198, I199, I200, I201, I202, I203, I204, I205, I206, I207,
-    I208, I209, I210, I211, I212, I213, I214, I215, I216, I217, I218, I219, I220, I221,
-    I222, I223, I224, I225, I226, I227, I228, I229, I230, I231, I232, I233, I234, I235,
-    I236, I237, I238, I239, I240, I241, I242, I243, I244, I245, I246, I247, I248, I249,
-    I250, I251, I252, I253, I254, I255
+    I0,
+    I1,
+    I2,
+    I3,
+    I4,
+    I5,
+    I6,
+    I7,
+    I8,
+    I9,
+    I10,
+    I11,
+    I12,
+    I13,
+    I14,
+    I15,
+    I16,
+    I17,
+    I18,
+    I19,
+    I20,
+    I21,
+    I22,
+    I23,
+    I24,
+    I25,
+    I26,
+    I27,
+    I28,
+    I29,
+    I30,
+    I31,
+    I32,
+    I33,
+    I34,
+    I35,
+    I36,
+    I37,
+    I38,
+    I39,
+    I40,
+    I41,
+    I42,
+    I43,
+    I44,
+    I45,
+    I46,
+    I47,
+    I48,
+    I49,
+    I50,
+    I51,
+    I52,
+    I53,
+    I54,
+    I55,
+    I56,
+    I57,
+    I58,
+    I59,
+    I60,
+    I61,
+    I62,
+    I63,
+    I64,
+    I65,
+    I66,
+    I67,
+    I68,
+    I69,
+    I70,
+    I71,
+    I72,
+    I73,
+    I74,
+    I75,
+    I76,
+    I77,
+    I78,
+    I79,
+    I80,
+    I81,
+    I82,
+    I83,
+    I84,
+    I85,
+    I86,
+    I87,
+    I88,
+    I89,
+    I90,
+    I91,
+    I92,
+    I93,
+    I94,
+    I95,
+    I96,
+    I97,
+    I98,
+    I99,
+    I100,
+    I101,
+    I102,
+    I103,
+    I104,
+    I105,
+    I106,
+    I107,
+    I108,
+    I109,
+    I110,
+    I111,
+    I112,
+    I113,
+    I114,
+    I115,
+    I116,
+    I117,
+    I118,
+    I119,
+    I120,
+    I121,
+    I122,
+    I123,
+    I124,
+    I125,
+    I126,
+    I127,
+    I128,
+    I129,
+    I130,
+    I131,
+    I132,
+    I133,
+    I134,
+    I135,
+    I136,
+    I137,
+    I138,
+    I139,
+    I140,
+    I141,
+    I142,
+    I143,
+    I144,
+    I145,
+    I146,
+    I147,
+    I148,
+    I149,
+    I150,
+    I151,
+    I152,
+    I153,
+    I154,
+    I155,
+    I156,
+    I157,
+    I158,
+    I159,
+    I160,
+    I161,
+    I162,
+    I163,
+    I164,
+    I165,
+    I166,
+    I167,
+    I168,
+    I169,
+    I170,
+    I171,
+    I172,
+    I173,
+    I174,
+    I175,
+    I176,
+    I177,
+    I178,
+    I179,
+    I180,
+    I181,
+    I182,
+    I183,
+    I184,
+    I185,
+    I186,
+    I187,
+    I188,
+    I189,
+    I190,
+    I191,
+    I192,
+    I193,
+    I194,
+    I195,
+    I196,
+    I197,
+    I198,
+    I199,
+    I200,
+    I201,
+    I202,
+    I203,
+    I204,
+    I205,
+    I206,
+    I207,
+    I208,
+    I209,
+    I210,
+    I211,
+    I212,
+    I213,
+    I214,
+    I215,
+    I216,
+    I217,
+    I218,
+    I219,
+    I220,
+    I221,
+    I222,
+    I223,
+    I224,
+    I225,
+    I226,
+    I227,
+    I228,
+    I229,
+    I230,
+    I231,
+    I232,
+    I233,
+    I234,
+    I235,
+    I236,
+    I237,
+    I238,
+    I239,
+    I240,
+    I241,
+    I242,
+    I243,
+    I244,
+    I245,
+    I246,
+    I247,
+    I248,
+    I249,
+    I250,
+    I251,
+    I252,
+    I253,
+    I254,
+    I255,
 };
 const ValueCount257 = enum {
-    I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15,
-    I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31,
-    I32, I33, I34, I35, I36, I37, I38, I39, I40, I41, I42, I43, I44, I45, I46, I47,
-    I48, I49, I50, I51, I52, I53, I54, I55, I56, I57, I58, I59, I60, I61, I62, I63,
-    I64, I65, I66, I67, I68, I69, I70, I71, I72, I73, I74, I75, I76, I77, I78, I79,
-    I80, I81, I82, I83, I84, I85, I86, I87, I88, I89, I90, I91, I92, I93, I94, I95,
-    I96, I97, I98, I99, I100, I101, I102, I103, I104, I105, I106, I107, I108, I109,
-    I110, I111, I112, I113, I114, I115, I116, I117, I118, I119, I120, I121, I122, I123,
-    I124, I125, I126, I127, I128, I129, I130, I131, I132, I133, I134, I135, I136, I137,
-    I138, I139, I140, I141, I142, I143, I144, I145, I146, I147, I148, I149, I150, I151,
-    I152, I153, I154, I155, I156, I157, I158, I159, I160, I161, I162, I163, I164, I165,
-    I166, I167, I168, I169, I170, I171, I172, I173, I174, I175, I176, I177, I178, I179,
-    I180, I181, I182, I183, I184, I185, I186, I187, I188, I189, I190, I191, I192, I193,
-    I194, I195, I196, I197, I198, I199, I200, I201, I202, I203, I204, I205, I206, I207,
-    I208, I209, I210, I211, I212, I213, I214, I215, I216, I217, I218, I219, I220, I221,
-    I222, I223, I224, I225, I226, I227, I228, I229, I230, I231, I232, I233, I234, I235,
-    I236, I237, I238, I239, I240, I241, I242, I243, I244, I245, I246, I247, I248, I249,
-    I250, I251, I252, I253, I254, I255, I256
+    I0,
+    I1,
+    I2,
+    I3,
+    I4,
+    I5,
+    I6,
+    I7,
+    I8,
+    I9,
+    I10,
+    I11,
+    I12,
+    I13,
+    I14,
+    I15,
+    I16,
+    I17,
+    I18,
+    I19,
+    I20,
+    I21,
+    I22,
+    I23,
+    I24,
+    I25,
+    I26,
+    I27,
+    I28,
+    I29,
+    I30,
+    I31,
+    I32,
+    I33,
+    I34,
+    I35,
+    I36,
+    I37,
+    I38,
+    I39,
+    I40,
+    I41,
+    I42,
+    I43,
+    I44,
+    I45,
+    I46,
+    I47,
+    I48,
+    I49,
+    I50,
+    I51,
+    I52,
+    I53,
+    I54,
+    I55,
+    I56,
+    I57,
+    I58,
+    I59,
+    I60,
+    I61,
+    I62,
+    I63,
+    I64,
+    I65,
+    I66,
+    I67,
+    I68,
+    I69,
+    I70,
+    I71,
+    I72,
+    I73,
+    I74,
+    I75,
+    I76,
+    I77,
+    I78,
+    I79,
+    I80,
+    I81,
+    I82,
+    I83,
+    I84,
+    I85,
+    I86,
+    I87,
+    I88,
+    I89,
+    I90,
+    I91,
+    I92,
+    I93,
+    I94,
+    I95,
+    I96,
+    I97,
+    I98,
+    I99,
+    I100,
+    I101,
+    I102,
+    I103,
+    I104,
+    I105,
+    I106,
+    I107,
+    I108,
+    I109,
+    I110,
+    I111,
+    I112,
+    I113,
+    I114,
+    I115,
+    I116,
+    I117,
+    I118,
+    I119,
+    I120,
+    I121,
+    I122,
+    I123,
+    I124,
+    I125,
+    I126,
+    I127,
+    I128,
+    I129,
+    I130,
+    I131,
+    I132,
+    I133,
+    I134,
+    I135,
+    I136,
+    I137,
+    I138,
+    I139,
+    I140,
+    I141,
+    I142,
+    I143,
+    I144,
+    I145,
+    I146,
+    I147,
+    I148,
+    I149,
+    I150,
+    I151,
+    I152,
+    I153,
+    I154,
+    I155,
+    I156,
+    I157,
+    I158,
+    I159,
+    I160,
+    I161,
+    I162,
+    I163,
+    I164,
+    I165,
+    I166,
+    I167,
+    I168,
+    I169,
+    I170,
+    I171,
+    I172,
+    I173,
+    I174,
+    I175,
+    I176,
+    I177,
+    I178,
+    I179,
+    I180,
+    I181,
+    I182,
+    I183,
+    I184,
+    I185,
+    I186,
+    I187,
+    I188,
+    I189,
+    I190,
+    I191,
+    I192,
+    I193,
+    I194,
+    I195,
+    I196,
+    I197,
+    I198,
+    I199,
+    I200,
+    I201,
+    I202,
+    I203,
+    I204,
+    I205,
+    I206,
+    I207,
+    I208,
+    I209,
+    I210,
+    I211,
+    I212,
+    I213,
+    I214,
+    I215,
+    I216,
+    I217,
+    I218,
+    I219,
+    I220,
+    I221,
+    I222,
+    I223,
+    I224,
+    I225,
+    I226,
+    I227,
+    I228,
+    I229,
+    I230,
+    I231,
+    I232,
+    I233,
+    I234,
+    I235,
+    I236,
+    I237,
+    I238,
+    I239,
+    I240,
+    I241,
+    I242,
+    I243,
+    I244,
+    I245,
+    I246,
+    I247,
+    I248,
+    I249,
+    I250,
+    I251,
+    I252,
+    I253,
+    I254,
+    I255,
+    I256,
 };
 
 test "enum sizes" {
@@ -189,11 +670,11 @@ test "enum sizes" {
     }
 }
 
-const Small2 = enum (u2) {
+const Small2 = enum(u2) {
     One,
     Two,
 };
-const Small = enum (u2) {
+const Small = enum(u2) {
     One,
     Two,
     Three,
@@ -213,8 +694,7 @@ test "set enum tag type" {
     }
 }
 
-
-const A = enum (u3) {
+const A = enum(u3) {
     One,
     Two,
     Three,
@@ -225,7 +705,7 @@ const A = enum (u3) {
     Four2,
 };
 
-const B = enum (u3) {
+const B = enum(u3) {
     One3,
     Two3,
     Three3,
@@ -236,7 +716,7 @@ const B = enum (u3) {
     Four23,
 };
 
-const C = enum (u2) {
+const C = enum(u2) {
     One4,
     Two4,
     Three4,
@@ -249,7 +729,7 @@ const BitFieldOfEnums = packed struct {
     c: C,
 };
 
-const bit_field_1 = BitFieldOfEnums {
+const bit_field_1 = BitFieldOfEnums{
     .a = A.Two,
     .b = B.Three3,
     .c = C.Four4,
@@ -270,15 +750,15 @@ test "bit field access with enum fields" {
     assert(data.b == B.Four3);
 }
 
-fn getA(data: &const BitFieldOfEnums) A {
+fn getA(data: *const BitFieldOfEnums) A {
     return data.a;
 }
 
-fn getB(data: &const BitFieldOfEnums) B {
+fn getB(data: *const BitFieldOfEnums) B {
     return data.b;
 }
 
-fn getC(data: &const BitFieldOfEnums) C {
+fn getC(data: *const BitFieldOfEnums) C {
     return data.c;
 }
 
@@ -288,7 +768,7 @@ test "casting enum to its tag type" {
 }
 
 fn testCastEnumToTagType(value: Small2) void {
-    assert(u2(value) == 1);
+    assert(@enumToInt(value) == 1);
 }
 
 const MultipleChoice = enum(u32) {
@@ -304,7 +784,7 @@ test "enum with specified tag values" {
 }
 
 fn testEnumWithSpecifiedTagValues(x: MultipleChoice) void {
-    assert(u32(x) == 60);
+    assert(@enumToInt(x) == 60);
     assert(1234 == switch (x) {
         MultipleChoice.A => 1,
         MultipleChoice.B => 2,
@@ -331,7 +811,7 @@ test "enum with specified and unspecified tag values" {
 }
 
 fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {
-    assert(u32(x) == 1000);
+    assert(@enumToInt(x) == 1000);
     assert(1234 == switch (x) {
         MultipleChoice2.A => 1,
         MultipleChoice2.B => 2,
@@ -346,8 +826,8 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {
 }
 
 test "cast integer literal to enum" {
-    assert(MultipleChoice2(0) == MultipleChoice2.Unspecified1);
-    assert(MultipleChoice2(40) == MultipleChoice2.B);
+    assert(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);
+    assert(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B);
 }
 
 const EnumWithOneMember = enum {
@@ -385,10 +865,30 @@ const EnumWithTagValues = enum(u4) {
     D = 1 << 3,
 };
 test "enum with tag values don't require parens" {
-    assert(u4(EnumWithTagValues.C) == 0b0100);
+    assert(@enumToInt(EnumWithTagValues.C) == 0b0100);
 }
 
 test "enum with 1 field but explicit tag type should still have the tag type" {
-    const Enum = enum(u8) { B = 2 };
+    const Enum = enum(u8) {
+        B = 2,
+    };
     comptime @import("std").debug.assert(@sizeOf(Enum) == @sizeOf(u8));
 }
+
+test "empty extern enum with members" {
+    const E = extern enum {
+        A,
+        B,
+        C,
+    };
+    assert(@sizeOf(E) == @sizeOf(c_int));
+}
+
+test "aoeu" {
+    const LocalFoo = enum {
+        A = 1,
+        B = 0,
+    };
+    var b = LocalFoo.B;
+    assert(mem.eql(u8, @tagName(b), "B"));
+}