renamed AstArrayAccess to AstSubscript

diff --git a/bin/onyx b/bin/onyx
index 828b2c92d0befbc248fae0610d44eeb9480db2ef..3d3597925d285b05d50929b590419e2b92345e8e 100755 (executable)
Binary files a/bin/onyx and b/bin/onyx differ

diff --git a/bin/test b/bin/test
index c776603795584ed441a2016e89ce344a7bbb7f70..b176bf105994525098140af97b0be0d0b44b35c7 100755 (executable)
--- a/bin/test
+++ b/bin/test
@@ -11,7 +11,7 @@ print_check() {
 if command -v wasmer >/dev/null; then
     printf "Using $(wasmer --version)\n"
 else
-    printf "Using $(node --verison)\n"
+    printf "Using node $(node -v)\n"
 fi
 
 failed=0

diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index 857778869c8b87ac910ae23120df9099ca4eb33f..eb9a399f49c6f1664f4cdf38e1e310778f02ddfd 100644 (file)
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -18,7 +18,7 @@
     NODE(Argument)             \
     NODE(AddressOf)            \
     NODE(Dereference)          \
-    NODE(ArrayAccess)          \
+    NODE(Subscript)            \
     NODE(FieldAccess)          \
     NODE(UnaryFieldAccess)     \
     NODE(SizeOf)               \
@@ -153,7 +153,7 @@ typedef enum AstKind {
     Ast_Kind_Return,
     Ast_Kind_Address_Of,
     Ast_Kind_Dereference,
-    Ast_Kind_Array_Access,
+    Ast_Kind_Subscript,
     Ast_Kind_Slice,
     Ast_Kind_Field_Access,
     Ast_Kind_Unary_Field_Access,
@@ -516,7 +516,7 @@ struct AstAddressOf     { AstTyped_base; AstTyped *expr; };
 struct AstDereference   { AstTyped_base; AstTyped *expr; };
 struct AstSizeOf        { AstTyped_base; AstType *so_ast_type; Type *so_type; u64 size; };
 struct AstAlignOf       { AstTyped_base; AstType *ao_ast_type; Type *ao_type; u64 alignment; };
-struct AstArrayAccess   {
+struct AstSubscript   {
     AstTyped_base;
     BinaryOp __unused_operation; // This will be set to Binary_Op_Subscript
     AstTyped *addr;
@@ -1273,7 +1273,7 @@ static inline b32 is_lval(AstNode* node) {
         || (node->kind == Ast_Kind_Param)
         || (node->kind == Ast_Kind_Global)
         || (node->kind == Ast_Kind_Dereference)
-        || (node->kind == Ast_Kind_Array_Access)
+        || (node->kind == Ast_Kind_Subscript)
         || (node->kind == Ast_Kind_Field_Access)
         || (node->kind == Ast_Kind_Memres))
         return 1;

diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 9829b1d030725f1b31f5d3dcd0ae8e1369e79e5c..59b43914072d1e91723fdaeee62b9782bc273b57 100644 (file)
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -38,7 +38,7 @@ CheckStatus check_compound(AstCompound* compound);
 CheckStatus check_expression(AstTyped** expr);
 CheckStatus check_address_of(AstAddressOf* aof);
 CheckStatus check_dereference(AstDereference* deref);
-CheckStatus check_array_access(AstArrayAccess** paa);
+CheckStatus check_subscript(AstSubscript** paa);
 CheckStatus check_field_access(AstFieldAccess** pfield);
 CheckStatus check_method_call(AstBinaryOp** mcall);
 CheckStatus check_size_of(AstSizeOf* so);
@@ -1253,7 +1253,7 @@ CheckStatus check_compound(AstCompound* compound) {
 CheckStatus check_address_of(AstAddressOf* aof) {
     CHECK(expression, &aof->expr);
 
-    if ((aof->expr->kind != Ast_Kind_Array_Access
+    if ((aof->expr->kind != Ast_Kind_Subscript
             && aof->expr->kind != Ast_Kind_Dereference
             && aof->expr->kind != Ast_Kind_Field_Access
             && aof->expr->kind != Ast_Kind_Memres
@@ -1288,88 +1288,88 @@ CheckStatus check_dereference(AstDereference* deref) {
     return Check_Success;
 }
 
-CheckStatus check_array_access(AstArrayAccess** paa) {
-    AstArrayAccess* aa = *paa;
-    CHECK(expression, &aa->addr);
-    CHECK(expression, &aa->expr);
+CheckStatus check_subscript(AstSubscript** psub) {
+    AstSubscript* sub = *psub;
+    CHECK(expression, &sub->addr);
+    CHECK(expression, &sub->expr);
 
     // NOTE: Try operator overloading before checking everything else.
-    if ((aa->addr->type != NULL && aa->expr->type != NULL) &&
-        (aa->addr->type->kind != Type_Kind_Basic || aa->expr->type->kind != Type_Kind_Basic)) {
-        // AstArrayAccess is the same as AstBinaryOp for the first sizeof(AstBinaryOp) bytes
-        AstBinaryOp* binop = (AstBinaryOp *) aa;
+    if ((sub->addr->type != NULL && sub->expr->type != NULL) &&
+        (sub->addr->type->kind != Type_Kind_Basic || sub->expr->type->kind != Type_Kind_Basic)) {
+        // AstSubscript is the same as AstBinaryOp for the first sizeof(AstBinaryOp) bytes
+        AstBinaryOp* binop = (AstBinaryOp *) sub;
         AstCall *implicit_call = binaryop_try_operator_overload(binop);
 
         if (implicit_call != NULL) {
             CHECK(call, implicit_call);
 
             // NOTE: Not an array access
-            *paa = (AstArrayAccess *) implicit_call;
+            *psub = (AstSubscript *) implicit_call;
             return Check_Success;
         }
     }
 
-    if (!type_is_array_accessible(aa->addr->type)) {
-        onyx_report_error(aa->token->pos,
+    if (!type_is_array_accessible(sub->addr->type)) {
+        onyx_report_error(sub->token->pos,
                 "Expected pointer or array type for left of array access, got '%s'.",
-                node_get_type_name(aa->addr));
+                node_get_type_name(sub->addr));
         return Check_Error;
     }
 
-    if (types_are_compatible(aa->expr->type, builtin_range_type_type)) {
+    if (types_are_compatible(sub->expr->type, builtin_range_type_type)) {
         Type *of = NULL;
-        if (aa->addr->type->kind == Type_Kind_Pointer)
-            of = aa->addr->type->Pointer.elem;
-        else if (aa->addr->type->kind == Type_Kind_Array)
-            of = aa->addr->type->Array.elem;
+        if (sub->addr->type->kind == Type_Kind_Pointer)
+            of = sub->addr->type->Pointer.elem;
+        else if (sub->addr->type->kind == Type_Kind_Array)
+            of = sub->addr->type->Array.elem;
         else {
             // FIXME: Slice creation should be allowed for slice types and dynamic array types, like it
             // is below, but this code doesn't look at that.
-            onyx_report_error(aa->token->pos, "Invalid type for left of slice creation.");
+            onyx_report_error(sub->token->pos, "Invalid type for left of slice creation.");
             return Check_Error;
         }
 
-        aa->kind = Ast_Kind_Slice;
-        aa->type = type_make_slice(context.ast_alloc, of);
-        aa->elem_size = type_size_of(of);
+        sub->kind = Ast_Kind_Slice;
+        sub->type = type_make_slice(context.ast_alloc, of);
+        sub->elem_size = type_size_of(of);
 
         return Check_Success;
     }
 
-    resolve_expression_type(aa->expr);
-    if (aa->expr->type->kind != Type_Kind_Basic
-            || (aa->expr->type->Basic.kind != Basic_Kind_I32 && aa->expr->type->Basic.kind != Basic_Kind_U32)) {
-        onyx_report_error(aa->token->pos,
+    resolve_expression_type(sub->expr);
+    if (sub->expr->type->kind != Type_Kind_Basic
+            || (sub->expr->type->Basic.kind != Basic_Kind_I32 && sub->expr->type->Basic.kind != Basic_Kind_U32)) {
+        onyx_report_error(sub->token->pos,
             "Expected type u32 or i32 for index, got '%s'.",
-            node_get_type_name(aa->expr));
+            node_get_type_name(sub->expr));
         return Check_Error;
     }
 
-    if (aa->addr->type->kind == Type_Kind_Pointer)
-        aa->type = aa->addr->type->Pointer.elem;
-    else if (aa->addr->type->kind == Type_Kind_Array)
-        aa->type = aa->addr->type->Array.elem;
-    else if (aa->addr->type->kind == Type_Kind_Slice
-            || aa->addr->type->kind == Type_Kind_DynArray
-            || aa->addr->type->kind == Type_Kind_VarArgs) {
+    if (sub->addr->type->kind == Type_Kind_Pointer)
+        sub->type = sub->addr->type->Pointer.elem;
+    else if (sub->addr->type->kind == Type_Kind_Array)
+        sub->type = sub->addr->type->Array.elem;
+    else if (sub->addr->type->kind == Type_Kind_Slice
+            || sub->addr->type->kind == Type_Kind_DynArray
+            || sub->addr->type->kind == Type_Kind_VarArgs) {
         // If we are accessing on a slice or a dynamic array, implicitly add a field access for the data member
         StructMember smem;
-        type_lookup_member(aa->addr->type, "data", &smem);
+        type_lookup_member(sub->addr->type, "data", &smem);
 
-        AstFieldAccess* fa = make_field_access(context.ast_alloc, aa->addr, "data");
+        AstFieldAccess* fa = make_field_access(context.ast_alloc, sub->addr, "data");
         fa->type   = smem.type;
         fa->offset = smem.offset;
         fa->idx    = smem.idx;
 
-        aa->addr = (AstTyped *) fa;
-        aa->type = aa->addr->type->Pointer.elem;
+        sub->addr = (AstTyped *) fa;
+        sub->type = sub->addr->type->Pointer.elem;
     }
     else {
-        onyx_report_error(aa->token->pos, "Invalid type for left of array access.");
+        onyx_report_error(sub->token->pos, "Invalid type for left of array access.");
         return Check_Error;
     }
 
-    aa->elem_size = type_size_of(aa->type);
+    sub->elem_size = type_size_of(sub->type);
 
     return Check_Success;
 }
@@ -1534,7 +1534,7 @@ CheckStatus check_expression(AstTyped** pexpr) {
         case Ast_Kind_Address_Of:    retval = check_address_of((AstAddressOf *) expr); break;
         case Ast_Kind_Dereference:   retval = check_dereference((AstDereference *) expr); break;
         case Ast_Kind_Slice:
-        case Ast_Kind_Array_Access:  retval = check_array_access((AstArrayAccess **) pexpr); break;
+        case Ast_Kind_Subscript:     retval = check_subscript((AstSubscript **) pexpr); break;
         case Ast_Kind_Field_Access:  retval = check_field_access((AstFieldAccess **) pexpr); break;
         case Ast_Kind_Method_Call:   retval = check_method_call((AstBinaryOp **) pexpr); break;
         case Ast_Kind_Size_Of:       retval = check_size_of((AstSizeOf *) expr); break;

diff --git a/src/onyxclone.c b/src/onyxclone.c
index 4e5e3a9bb27c4b967a2591f77ecd80200a4cf76e..ca0e813396e1b0f6446ec3e3b03fb78ba7afa00e 100644 (file)
--- a/src/onyxclone.c
+++ b/src/onyxclone.c
@@ -68,8 +68,8 @@ static inline i32 ast_kind_to_size(AstNode* node) {
         case Ast_Kind_Return: return sizeof(AstReturn);
         case Ast_Kind_Address_Of: return sizeof(AstAddressOf);
         case Ast_Kind_Dereference: return sizeof(AstDereference);
-        case Ast_Kind_Array_Access: return sizeof(AstArrayAccess);
-        case Ast_Kind_Slice: return sizeof(AstArrayAccess);
+        case Ast_Kind_Subscript: return sizeof(AstSubscript);
+        case Ast_Kind_Slice: return sizeof(AstSubscript);
         case Ast_Kind_Field_Access: return sizeof(AstFieldAccess);
         case Ast_Kind_Pipe: return sizeof(AstBinaryOp);
         case Ast_Kind_Range_Literal: return sizeof(AstRangeLiteral);
@@ -163,9 +163,9 @@ AstNode* ast_clone(bh_allocator a, void* n) {
                        break;
 
                case Ast_Kind_Slice:
-               case Ast_Kind_Array_Access:
-                       ((AstArrayAccess *) nn)->addr = (AstTyped *) ast_clone(a, ((AstArrayAccess *) node)->addr);
-                       ((AstArrayAccess *) nn)->expr = (AstTyped *) ast_clone(a, ((AstArrayAccess *) node)->expr);
+               case Ast_Kind_Subscript:
+                       ((AstSubscript *) nn)->addr = (AstTyped *) ast_clone(a, ((AstSubscript *) node)->addr);
+                       ((AstSubscript *) nn)->expr = (AstTyped *) ast_clone(a, ((AstSubscript *) node)->expr);
                        break;
 
                case Ast_Kind_Field_Access:

diff --git a/src/onyxparser.c b/src/onyxparser.c
index fd805896d76a38d38054929a51faef4f8ba55582..08a5256fe38e734c5a80322f732d3e05f617b638 100644 (file)
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -610,15 +610,13 @@ static AstTyped* parse_factor(OnyxParser* parser) {
                 OnyxToken *open_bracket = expect_token(parser, '[');
                 AstTyped *expr = parse_compound_expression(parser, 0);
 
-                AstKind kind = Ast_Kind_Array_Access;
+                AstSubscript *sub_node = make_node(AstSubscript, Ast_Kind_Subscript);
+                sub_node->token = open_bracket;
+                sub_node->addr = retval;
+                sub_node->expr = expr;
+                sub_node->__unused_operation = Binary_Op_Subscript;
 
-                AstArrayAccess *aa_node = make_node(AstArrayAccess, kind);
-                aa_node->token = open_bracket;
-                aa_node->addr = retval;
-                aa_node->expr = expr;
-                aa_node->__unused_operation = Binary_Op_Subscript;
-
-                retval = (AstTyped *) aa_node;
+                retval = (AstTyped *) sub_node;
                 expect_token(parser, ']');
                 break;
             }

diff --git a/src/onyxsymres.c b/src/onyxsymres.c
index 9dbb838ba476dcb1769362cef8601e473ca5bdb8..deb1bbfeda80cf47a1cdcd6d472dd01b3e64efce 100644 (file)
--- a/src/onyxsymres.c
+++ b/src/onyxsymres.c
@@ -432,9 +432,9 @@ static SymresStatus symres_expression(AstTyped** expr) {
             break;
 
         case Ast_Kind_Slice:
-        case Ast_Kind_Array_Access:
-            SYMRES(expression, &((AstArrayAccess *)(*expr))->addr);
-            SYMRES(expression, &((AstArrayAccess *)(*expr))->expr);
+        case Ast_Kind_Subscript:
+            SYMRES(expression, &((AstSubscript *)(*expr))->addr);
+            SYMRES(expression, &((AstSubscript *)(*expr))->expr);
             break;
 
         case Ast_Kind_Struct_Literal:

diff --git a/src/onyxwasm.c b/src/onyxwasm.c
index 732f9f243e47f0b2b9de10f3e4aa6f655e72e2f0..52640dff58eab306f29269aa3f2156dd5c02c17d 100644 (file)
--- a/src/onyxwasm.c
+++ b/src/onyxwasm.c
@@ -240,7 +240,7 @@ EMIT_FUNC(binop,                         AstBinaryOp* binop);
 EMIT_FUNC(unaryop,                       AstUnaryOp* unop);
 EMIT_FUNC(call,                          AstCall* call);
 EMIT_FUNC(intrinsic_call,                AstCall* call);
-EMIT_FUNC(array_access_location,         AstArrayAccess* aa, u64* offset_return);
+EMIT_FUNC(subscript_location,            AstSubscript* sub, u64* offset_return);
 EMIT_FUNC(field_access_location,         AstFieldAccess* field, u64* offset_return);
 EMIT_FUNC(local_location,                AstLocal* local, u64* offset_return);
 EMIT_FUNC(memory_reservation_location,   AstMemRes* memres);
@@ -1868,31 +1868,31 @@ EMIT_FUNC(intrinsic_call, AstCall* call) {
     *pcode = code;
 }
 
-EMIT_FUNC(array_access_location, AstArrayAccess* aa, u64* offset_return) {
+EMIT_FUNC(subscript_location, AstSubscript* sub, u64* offset_return) {
     bh_arr(WasmInstruction) code = *pcode;
 
-    emit_expression(mod, &code, aa->expr);
-    if (aa->elem_size != 1) {
-        WID(WI_PTR_CONST, aa->elem_size);
+    emit_expression(mod, &code, sub->expr);
+    if (sub->elem_size != 1) {
+        WID(WI_PTR_CONST, sub->elem_size);
         WI(WI_PTR_MUL);
     }
 
     // CLEANUP: This is one dense clusterf**k of code...
     u64 offset = 0;
-    if (aa->addr->kind == Ast_Kind_Array_Access
-        && aa->addr->type->kind == Type_Kind_Array) {
-        emit_array_access_location(mod, &code, (AstArrayAccess *) aa->addr, &offset);
-    } else if (aa->addr->kind == Ast_Kind_Field_Access
-        && aa->addr->type->kind == Type_Kind_Array) {
-        emit_field_access_location(mod, &code, (AstFieldAccess *) aa->addr, &offset);
-    } else if ((aa->addr->kind == Ast_Kind_Local || aa->addr->kind == Ast_Kind_Param)
-        && aa->addr->type->kind == Type_Kind_Array) {
-        emit_local_location(mod, &code, (AstLocal *) aa->addr, &offset);
-    } else if (aa->addr->kind == Ast_Kind_Memres
-        && aa->addr->type->kind != Type_Kind_Array) {
-        emit_memory_reservation_location(mod, &code, (AstMemRes *) aa->addr);
+    if (sub->addr->kind == Ast_Kind_Subscript
+        && sub->addr->type->kind == Type_Kind_Array) {
+        emit_subscript_location(mod, &code, (AstSubscript *) sub->addr, &offset);
+    } else if (sub->addr->kind == Ast_Kind_Field_Access
+        && sub->addr->type->kind == Type_Kind_Array) {
+        emit_field_access_location(mod, &code, (AstFieldAccess *) sub->addr, &offset);
+    } else if ((sub->addr->kind == Ast_Kind_Local || sub->addr->kind == Ast_Kind_Param)
+        && sub->addr->type->kind == Type_Kind_Array) {
+        emit_local_location(mod, &code, (AstLocal *) sub->addr, &offset);
+    } else if (sub->addr->kind == Ast_Kind_Memres
+        && sub->addr->type->kind != Type_Kind_Array) {
+        emit_memory_reservation_location(mod, &code, (AstMemRes *) sub->addr);
     } else {
-        emit_expression(mod, &code, aa->addr);
+        emit_expression(mod, &code, sub->addr);
     }
 
     WI(WI_PTR_ADD);
@@ -1913,10 +1913,10 @@ EMIT_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return) {
         source_expr = (AstTyped *) ((AstFieldAccess *) source_expr)->expr;
     }
 
-    if (source_expr->kind == Ast_Kind_Array_Access
+    if (source_expr->kind == Ast_Kind_Subscript
         && source_expr->type->kind != Type_Kind_Pointer) {
         u64 o2 = 0;
-        emit_array_access_location(mod, &code, (AstArrayAccess *) source_expr, &o2);
+        emit_subscript_location(mod, &code, (AstSubscript *) source_expr, &o2);
         offset += o2;
 
     } else if ((source_expr->kind == Ast_Kind_Local || source_expr->kind == Ast_Kind_Param)
@@ -2140,9 +2140,9 @@ EMIT_FUNC(location_return_offset, AstTyped* expr, u64* offset_return) {
             break;
         }
 
-        case Ast_Kind_Array_Access: {
-            AstArrayAccess* aa = (AstArrayAccess *) expr;
-            emit_array_access_location(mod, &code, aa, offset_return);
+        case Ast_Kind_Subscript: {
+            AstSubscript* sub = (AstSubscript *) expr;
+            emit_subscript_location(mod, &code, sub, offset_return);
             break;
         }
 
@@ -2317,11 +2317,11 @@ EMIT_FUNC(expression, AstTyped* expr) {
             break;
         }
 
-        case Ast_Kind_Array_Access: {
-            AstArrayAccess* aa = (AstArrayAccess *) expr;
+        case Ast_Kind_Subscript: {
+            AstSubscript* sub = (AstSubscript *) expr;
             u64 offset = 0;
-            emit_array_access_location(mod, &code, aa, &offset);
-            emit_load_instruction(mod, &code, aa->type, offset);
+            emit_subscript_location(mod, &code, sub, &offset);
+            emit_load_instruction(mod, &code, sub->type, offset);
             break;
         }
 
@@ -2380,7 +2380,7 @@ EMIT_FUNC(expression, AstTyped* expr) {
         }
 
         case Ast_Kind_Slice: {
-            AstArrayAccess* sl = (AstArrayAccess *) expr;
+            AstSubscript* sl = (AstSubscript *) expr;
 
             emit_expression(mod, &code, sl->expr);