AST: remove redundant enum prefixes

* declare more arrays with enum size
* remove most enum prefixes

Author: chqrlie

analyser/module_analyser_member.c2

@@ -118,7 +118,7 @@ fn QualType Analyser.analyseMemberExpr(Analyser* ma, Expr** e_ptr, u32 side) {
                 // no need to update valtype
                 break;
             case Enum:
-                //stdio.printf("ENUM BASE  (type: %d)\n", valtype == ValType.NValue);
+                //stdio.printf("ENUM BASE  (type: %d)\n", valtype == NValue);
                 EnumType* et = (EnumType*)t;
                 EnumTypeDecl* etd = et.getDecl();
                 d = (Decl*)etd;

ast/binary_operator.c2

@@ -105,7 +105,7 @@ public type BinaryOperator struct @(opaque) {
 
 public fn BinaryOperator* BinaryOperator.create(ast_context.Context* c, SrcLoc loc, BinaryOpcode kind, Expr* lhs, Expr* rhs) {
     BinaryOperator* e = c.alloc(sizeof(BinaryOperator));
-    e.base.init(BinaryOperator, loc, 0, 0, kind >= BinaryOpcode.Assign, RValue);
+    e.base.init(BinaryOperator, loc, 0, 0, kind >= Assign, RValue);
     e.base.base.binaryOperatorBits.kind = kind;
     e.lhs = lhs;
     e.rhs = rhs;

ast/conditional_operator.c2

@@ -35,7 +35,7 @@ public fn ConditionalOperator* ConditionalOperator.create(ast_context.Context* c
                                                             Expr* rhs)
 {
     ConditionalOperator* e = c.alloc(sizeof(ConditionalOperator));
-    e.base.init(ConditionalOperator, questionLoc, 0, 1, 1, ValType.RValue);
+    e.base.init(ConditionalOperator, questionLoc, 0, 1, 1, RValue);
     e.colonLoc = colonLoc;
     e.cond = cond;
     e.lhs = lhs;

ast/expr.c2

@@ -46,7 +46,7 @@ public type ExprKind enum u8 {
     Alternate,
 }
 
-const char*[] exprKind_names = {
+const char*[ExprKind] exprKind_names = {
     "IntegerLiteral",
     "FloatLiteral",
     "BooleanLiteral",
@@ -73,7 +73,6 @@ const char*[] exprKind_names = {
     "NamedArgument",
     "Alternate",
 }
-static_assert(elemsof(ExprKind), elemsof(exprKind_names));
 
 /*
     An LValue may be on the left/right side of an assignment
@@ -102,12 +101,11 @@ public type ValType enum u8 {
     LValue, // can be used as LHS / RHS of assignment
 }
 
-const char*[] valType_names = {
+const char*[ValType] valType_names = {
     "nvalue",
     "rvalue",
     "lvalue",
 }
-static_assert(elemsof(ValType), elemsof(valType_names));
 
 type ExprBits struct {
     u32 : NumStmtBits;
@@ -315,17 +313,17 @@ public fn ValType Expr.getValType(const Expr* e) {
 }
 
 public fn bool Expr.isNValue(const Expr* e) {
-    return e.getValType() == ValType.NValue;
+    return e.getValType() == NValue;
 }
 
 /*
 public fn bool Expr.isRValue(const Expr* e) {
-    return e.getValType() == ValType.RValue;
+    return e.getValType() == RValue;
 }
 */
 
 public fn bool Expr.isLValue(const Expr* e) {
-    return e.getValType() == ValType.LValue;
+    return e.getValType() == LValue;
 }
 
 public fn void Expr.setLValue(Expr* e) {

ast/function_decl.c2

@@ -29,13 +29,12 @@ public type CallKind enum u8 {
     StaticTypeFunc,
 }
 
-const char*[] callKind_names = {
+const char*[CallKind] callKind_names = {
     "Invalid",
     "Normal",
     "SF",
     "SSF",
 }
-static_assert(elemsof(CallKind), elemsof(callKind_names));
 
 public type DefKind enum u8 {
     Global,         // fn void (..) { .. }
@@ -45,7 +44,7 @@ public type DefKind enum u8 {
     Template,       // ..
 }
 
-const char*[] defKind_names = {
+const char*[DefKind] defKind_names = {
     "global",
     "type",
     "struct-member",

ast/identifier_expr.c2

@@ -61,7 +61,7 @@ public type IdentifierExpr struct @(opaque) {
 
 public fn IdentifierExpr* IdentifierExpr.create(ast_context.Context* c, SrcLoc loc, u32 name, u32 name_len) {
     IdentifierExpr* e = c.alloc(sizeof(IdentifierExpr));
-    e.base.init(Identifier, loc, 0, 0, 0, ValType.NValue);
+    e.base.init(Identifier, loc, 0, 0, 0, NValue);
     e.name_idx = name;
     e.base.base.identifierExprBits.name_len = name_len;
 #if AstStatistics

ast/implicit_cast_expr.c2

@@ -28,7 +28,7 @@ public type ImplicitCastKind enum u8 {
     BitCast,    // pointer conversion (char* -> i32*, or void* -> FunctionPtr)
 }
 
-const char*[] implicitCastKind_names = {
+const char*[ImplicitCastKind] implicitCastKind_names = {
     "ArrayToPointerDecay",
     "LValueToRValue",
     "PointerToBoolean",
@@ -37,8 +37,6 @@ const char*[] implicitCastKind_names = {
     "BitCast",
 }
 
-static_assert(elemsof(ImplicitCastKind), elemsof(implicitCastKind_names));
-
 type ImplicitCastBits struct {
     u32 : NumExprBits;
     u32 kind : 3;

ast/statistics.c2

@@ -121,36 +121,32 @@ fn void Stats.dump(const Stats* s) {
     printf("--- Types ---\n");
     u32 typesTotal = 0;
     u32 typesCount = 0;
-    //for (u32 i = TypeKind.min; i <= TypeKind.max; i++) {
-    for (u32 i=enum_min(TypeKind); i<=enum_max(TypeKind); i++) {
-        s.types[i].dump(typeKind_names[i], &typesCount, &typesTotal);
+    for (TypeKind kind = TypeKind.min; kind <= TypeKind.max; kind++) {
+        s.types[kind].dump(typeKind_names[kind], &typesCount, &typesTotal);
     }
     printf("  %20s  %6d  %7d\n", "total", typesCount, typesTotal);
 
     printf("--- Expressions ---\n");
     u32 exprTotal = 0;
     u32 exprCount = 0;
-    //for (u32 i = ExprKind.min; i <= ExprKind.max; i++) {
-    for (u32 i=enum_min(ExprKind); i<=enum_max(ExprKind); i++) {
+    for (ExprKind i = ExprKind.min; i <= ExprKind.max; i++) {
         s.exprs[i].dump(exprKind_names[i], &exprCount, &exprTotal);
     }
     printf("  %20s  %6d  %7d\n", "total", exprCount, exprTotal);
 
     printf("--- Statements ---\n");
     u32 stmtTotal = 0;
     u32 stmtCount = 0;
-    //for (u32 i = StmtKind.min; i <= StmtKind.max; i++) {
-    for (u32 i=enum_min(StmtKind); i<=enum_max(StmtKind); i++) {
+    for (StmtKind i = StmtKind.min; i <= StmtKind.max; i++) {
         s.stmts[i].dump(stmtKind_names[i], &stmtCount, &stmtTotal);
     }
     printf("  %20s  %6d  %7d\n", "total", stmtCount, stmtTotal);
 
     printf("--- Decls ---\n");
     u32 declTotal = 0;
     u32 declCount = 0;
-    //for (u32 i = DeclKind.min; i <= DeclKind.max; i++) {
-    for (u32 i=enum_min(DeclKind); i<=enum_max(DeclKind); i++) {
-        s.decls[i].dump(declKind_names[(DeclKind)i], &declCount, &declTotal);
+    for (DeclKind i = DeclKind.min; i <= DeclKind.max; i++) {
+        s.decls[i].dump(declKind_names[i], &declCount, &declTotal);
     }
     printf("  %20s  %6d  %7d\n", "total", declCount, declTotal);
 

ast/stmt.c2

@@ -36,7 +36,7 @@ public type StmtKind enum u8 {
     Assert,
 }
 
-const char*[] stmtKind_names = {
+const char*[StmtKind] stmtKind_names = {
     "ReturnStmt",
     "ExprStmt",
     "IfStmt",
@@ -54,8 +54,6 @@ const char*[] stmtKind_names = {
     "AssertStmt",
 }
 
-static_assert(elemsof(StmtKind), elemsof(stmtKind_names));
-
 type StmtBits struct {
     u32 kind : NumStmtBits;
 }

ast/type.c2

@@ -29,7 +29,7 @@ public type TypeKind enum u8 {
     Module,
 }
 
-const char*[] typeKind_names = {
+const char*[TypeKind] typeKind_names = {
     "Builtin",
     "Pointer",
     "Array",
@@ -41,8 +41,6 @@ const char*[] typeKind_names = {
     "Module",
 }
 
-static_assert(elemsof(TypeKind), elemsof(typeKind_names));
-
 type TypeBits struct {
     TypeKind kind : 8;
 }