tests: added enum-array tests

Author: bvdberg

ast/array_type.c2

@@ -113,11 +113,11 @@ fn void ArrayType.printPostName(const ArrayType* t, string_buffer.Buf* out) {
     } else {
         out.print("%d", t.size);
     }
+    //if (t.isEnumIndex()) out.add(" e");
     out.add1(']');
 }
 
 fn void ArrayType.print(const ArrayType* t, string_buffer.Buf* out) {
-    // TODO print preName, postName
     ArrayType* at = t.elem.getArrayTypeOrNil();
     if (at) at.printPreName(out);
     else t.elem.printInner(out, false, true, true);

test/expr/array/array_index.c2

@@ -0,0 +1,14 @@
+// @warnings{no-unused}
+module test;
+
+type Enum enum u8 { A, B, C }
+
+type Struct struct {
+    char[Enum] c;
+}
+
+fn void test1() {
+    Struct s;
+    s.c[(Enum)10] = 20; // @error{array out-of-bounds access [10] in array of [3]}
+}
+

test/expr/array/enum_array.c2

@@ -1,3 +1,4 @@
+// @warnings{no-unused}
 module test;
 
 import stdio local;
@@ -12,27 +13,34 @@ u32[Enum] a = {
 
 static_assert(elemsof(a), elemsof(Enum));
 
-public fn i32 main() {
-    printf("%d\n", a[No]);
-    printf("%d\n", a[Yes]);
-    printf("%d\n", a[Maybe]);
-    a[No] = 3;
-    a[Yes] = 4;
-    a[Maybe] = 5;
-    printf("%d\n", a[No]);
-    printf("%d\n", a[Yes]);
-    printf("%d\n", a[Maybe]);
-    printf("%d\n", a[0 ? Enum.Yes : Enum.No]);
-    Enum e = Yes;
-    printf("%d\n", a[e]);
-    printf("%d\n", a[Enum.max]);
-    i32 i = 1;
-    i32[] aa = {
-        printf("%d\n", a[No + 1]),    // @error{use of undeclared identifier 'No'}
-        printf("%d\n", a[1 ? Yes :  // @error{use of undeclared identifier 'Yes'}
-                         No]),  // @error{use of undeclared identifier 'No'}
-        printf("%d\n", a[1]),   // @error{array subscript must have enum type 'test.Enum'}
-        printf("%d\n", a[i]),   // @error{array subscript must have enum type 'test.Enum'}
+type Foo enum u8 { A, B, C }
+
+fn Enum getYes() { return Yes; }
+
+const Enum[2] Other = { Maybe, Yes }
+
+public fn i32 main(i32 argc, const char** argv) {
+    Enum e = Maybe;
+
+    u32[] aa = {
+        a[No],
+        a[Yes],
+        a[Enum.Yes],
+        a[argc ? Enum.Yes : Enum.No],
+        a[Other[1]],
+        a[getYes()],
+        a[(Enum)argc],
+        a[e],
+        a[Enum.max],
+
+        a[Foo.B],   // @error{array subscript must have enum type 'test.Enum'}
+        a[argc],    // @error{array subscript must have enum type 'test.Enum'}
+        a[No + 1],  // @error{use of undeclared identifier 'No'}
+        a[1 ? Yes : // @error{use of undeclared identifier 'Yes'}
+              No],  // @error{use of undeclared identifier 'No'}
+        a[1],       // @error{array subscript must have enum type 'test.Enum'}
+        a[argc],    // @error{array subscript must have enum type 'test.Enum'}
     }
     return 0;
 }
+

test/expr/array/enum_array_alias.c2

@@ -0,0 +1,38 @@
+// @warnings{no-unused}
+module test;
+
+type Enum enum u8 { No, Yes, Maybe }
+
+u32[Enum] a = {
+    [No]= 0,
+    [Yes]= 1,
+    [Maybe]= 2,
+}
+
+type Foo enum u8 { A, B, C }
+
+fn Enum getYes() { return Yes; }
+const Enum[2] Other = { Maybe, Yes }
+
+type Bar u32[Enum];
+Bar b;
+
+public fn i32 main(i32 argc, const char** argv) {
+
+    u32[] aa = {
+        b[No],
+        b[Enum.Yes],
+        b[argc ? Enum.Yes : Enum.No],
+        b[Other[1]],
+        b[getYes()],
+        b[(Enum)argc],
+
+        b[Foo.B],   // @error{array subscript must have enum type 'test.Enum'}
+        b[argc],    // @error{array subscript must have enum type 'test.Enum'}
+        b[No + 1],  // @error{use of undeclared identifier 'No'}
+        b[1 ? Yes : // @error{use of undeclared identifier 'Yes'}
+              No],  // @error{use of undeclared identifier 'No'}
+    }
+    return 0;
+}
+

test/expr/array/enum_array_multi.c2

@@ -0,0 +1,43 @@
+// @warnings{no-unused}
+module test;
+
+import stdio local;
+
+type Enum enum u8 { No, Yes, Maybe }
+type Enum2 enum u8 { A, B, C, D }
+
+u32[Enum][Enum2] a = {
+    [No]    = { 1, 2, 3, 4 },
+    [Yes]   = { 5, 6, 7, 8 },
+    [Maybe] = { 9, 10, 11, 12 },
+}
+
+static_assert(elemsof(a), elemsof(Enum));
+
+
+fn Enum getYes() { return Yes; }
+
+const Enum[2] Other = { Maybe, Yes }
+
+public fn i32 main(i32 argc, const char** argv) {
+    Enum e = Maybe;
+
+    u32[] aa = {
+        a[No][D],
+        a[Yes][B],
+        a[Enum.Yes][C],
+        a[argc ? Enum.Yes : Enum.No][A],
+        a[Other[1]][B],
+        a[getYes()][B],
+        a[(Enum)argc][B],
+        a[e][B],
+        a[Enum.max][Enum2.max],
+
+        a[Enum2.B][A],    // @error{array subscript must have enum type 'test.Enum'}
+        a[Yes][Enum.Yes], // @error{array subscript must have enum type 'test.Enum2'}
+        a[argc][B],       // @error{array subscript must have enum type 'test.Enum'}
+        a[Yes][argc],     // @error{array subscript must have enum type 'test.Enum2'}
+    }
+    return 0;
+}
+

test/types/enum/enum_array_type_nonpublic.c2

@@ -0,0 +1,9 @@
+// @warnings{no-unused}
+module test;
+
+type Foo enum u8 { A, B, C }
+
+type T1 u32[Foo];
+
+public type T2 u32[Foo]; // @error{public declaration using non-public variable 'test.Foo'}
+