fixed: slow steady changes to clean up compiler code

Author: brendanfh

compiler/include/astnodes.h

@@ -204,12 +204,10 @@ typedef enum AstKind {
     Ast_Kind_Param,
     Ast_Kind_Argument,
     Ast_Kind_Call,
-    Ast_Kind_Intrinsic_Call,
     Ast_Kind_Return,
     Ast_Kind_Address_Of,
     Ast_Kind_Dereference,
     Ast_Kind_Subscript,
-    Ast_Kind_Slice,
     Ast_Kind_Field_Access,
     Ast_Kind_Unary_Field_Access,
     Ast_Kind_Pipe,
@@ -721,15 +719,16 @@ struct AstArgument      {
 };
 struct AstSubscript   {
     AstTyped_base;
-    BinaryOp __unused_operation; // This will be set to Binary_Op_Subscript
+    BinaryOp operation; // This will be set to Binary_Op_Subscript
     AstTyped *addr;
     AstTyped *expr;
 
     Arguments *overload_args; // This is set of the binary operator is attempted to be overloaded
                               // but isnt successful yet.
     AstBinaryOp *potential_substitute;
 
-    u64 elem_size;
+    u32 elem_size;
+    b32 is_slice : 1;
 };
 struct AstFieldAccess   {
     AstTyped_base;
@@ -800,10 +799,8 @@ struct AstCall {
     Arguments args;
     i32 placeholder_argument_position;
 
-    union {
-        AstTyped *callee;
-        OnyxIntrinsic intrinsic;
-    };
+    AstTyped *callee;
+    OnyxIntrinsic intrinsic;
 
     VarArgKind va_kind;
     i32 ignored_return_value_count;

compiler/src/astnodes.c

@@ -64,12 +64,10 @@ static const char* ast_node_names[] = {
     "PARAM",
     "ARGUMENT",
     "CALL",
-    "INTRINSIC CALL",
     "RETURN",
     "ADDRESS OF",
     "DEREFERENCE",
     "ARRAY ACCESS",
-    "SLICE",
     "FIELD ACCESS",
     "UNARY FIELD ACCESS",
     "PIPE",

compiler/src/checker.c

@@ -910,7 +910,7 @@ CHECK_FUNC(argument, AstArgument** parg) {
 }
 
 CHECK_FUNC(resolve_callee, AstCall* call, AstTyped** effective_callee) {
-    if (call->kind == Ast_Kind_Intrinsic_Call) return Check_Success;
+    if (call->intrinsic) return Check_Success;
 
     AstTyped* callee = (AstTyped *) strip_aliases((AstNode *) call->callee);
     AstTyped* original_callee = callee;
@@ -1102,13 +1102,10 @@ CHECK_FUNC(call, AstCall** pcall) {
     // NOTE: If we are calling an intrinsic function, translate the
     // call into an intrinsic call node.
     if (callee->kind == Ast_Kind_Function && callee->is_intrinsic) {
-        call->kind = Ast_Kind_Intrinsic_Call;
-        call->callee = NULL;
-
         token_toggle_end(callee->intrinsic_name);
         char* intr_name = callee->intrinsic_name->text;
 
-        OnyxIntrinsic intrinsic = 0xffffffff;
+        OnyxIntrinsic intrinsic = ONYX_INTRINSIC_UNDEFINED;
         const IntrinsicMap *im = &builtin_intrinsics[0];
         while (im->name) {
             if (!strcmp(im->name, intr_name)) {
@@ -1118,7 +1115,7 @@ CHECK_FUNC(call, AstCall** pcall) {
             im++;
         }
 
-        if (intrinsic == 0xffffffff) {
+        if (intrinsic == ONYX_INTRINSIC_UNDEFINED) {
             ONYX_ERROR(callee->token->pos, Error_Critical, "Intrinsic not supported, '%s'.", intr_name);
             token_toggle_end(callee->intrinsic_name);
             return Check_Error;
@@ -2511,9 +2508,9 @@ CHECK_FUNC(subscript, AstSubscript** psub) {
             ERROR(sub->token->pos, "Invalid type for left of slice creation.");
         }
 
-        sub->kind = Ast_Kind_Slice;
         sub->type = type_make_slice(context, of);
         sub->elem_size = type_size_of(of);
+        sub->is_slice = 1;
 
         return Check_Success;
     }
@@ -3012,7 +3009,6 @@ CHECK_FUNC(expression, AstTyped** pexpr) {
         case Ast_Kind_Unary_Op:  retval = check_unaryop(context, (AstUnaryOp **) pexpr); break;
         case Ast_Kind_Pipe:      retval = check_pipe(context, (AstBinaryOp **) pexpr); break;
 
-        case Ast_Kind_Intrinsic_Call:
         case Ast_Kind_Call:     retval = check_call(context, (AstCall **) pexpr); break;
         case Ast_Kind_Argument: retval = check_argument(context, (AstArgument **) pexpr); break;
         case Ast_Kind_Block:    retval = check_block(context, (AstBlock *) expr); break;
@@ -3035,7 +3031,6 @@ CHECK_FUNC(expression, AstTyped** pexpr) {
 
         case Ast_Kind_Address_Of:    retval = check_address_of(context, (AstAddressOf **) pexpr); break;
         case Ast_Kind_Dereference:   retval = check_dereference(context, (AstDereference *) expr); break;
-        case Ast_Kind_Slice:
         case Ast_Kind_Subscript:     retval = check_subscript(context, (AstSubscript **) pexpr); break;
         case Ast_Kind_Field_Access:  retval = check_field_access(context, (AstFieldAccess **) pexpr); break;
         case Ast_Kind_Method_Call:   retval = check_method_call(context, (AstBinaryOp **) pexpr); break;
@@ -3435,33 +3430,37 @@ CHECK_FUNC(directive_solidify, AstDirectiveSolidify** psolid) {
 
     CHECK(expression, (AstTyped **) &solid->poly_proc);
 
-    if (solid->poly_proc && solid->poly_proc->kind == Ast_Kind_Directive_Solidify) {
-        AstFunction* potentially_resolved_proc = (AstFunction *) ((AstDirectiveSolidify *) solid->poly_proc)->resolved_proc;
-        if (!potentially_resolved_proc) return Check_Yield;
-
-        solid->poly_proc = potentially_resolved_proc;
+    if (!solid->poly_proc) {
+        ERROR(solid->token->pos, "Internal compiler error. The given procedure did not resolve correctly.");
     }
 
-    if (!solid->poly_proc || solid->poly_proc->kind != Ast_Kind_Polymorphic_Proc) {
-        ERROR(solid->token->pos, "Expected polymorphic procedure in #solidify directive.");
-    }
+    switch (solid->poly_proc->kind) {
+        case Ast_Kind_Polymorphic_Proc:
+            bh_arr_each(AstPolySolution, sln, solid->known_polyvars) {
+                // HACK: This assumes that 'ast_type' and 'value' are at the same offset.
+                CHECK(expression, &sln->value);
 
-    bh_arr_each(AstPolySolution, sln, solid->known_polyvars) {
-        // HACK: This assumes that 'ast_type' and 'value' are at the same offset.
-        CHECK(expression, &sln->value);
+                if (node_is_type((AstNode *) sln->value)) {
+                    sln->type = type_build_from_ast(context, sln->ast_type);
+                    sln->kind = PSK_Type;
+                } else {
+                    sln->kind = PSK_Value;
+                }
+            }
 
-        if (node_is_type((AstNode *) sln->value)) {
-            sln->type = type_build_from_ast(context, sln->ast_type);
-            sln->kind = PSK_Type;
-        } else {
-            sln->kind = PSK_Value;
-        }
+            solid->resolved_proc = polymorphic_proc_try_solidify(context, solid->poly_proc, solid->known_polyvars, solid->token);
+            break;
+
+        //case Ast_Kind_Poly_Union_Type:
+            //break;
+        
+        default:
+            ERROR(solid->token->pos, "Unable to '#solidify' this. Expected a 'polymorphic procedure'.");
     }
 
-    solid->resolved_proc = polymorphic_proc_try_solidify(context, solid->poly_proc, solid->known_polyvars, solid->token);
     if (solid->resolved_proc == (AstNode *) &context->node_that_signals_a_yield) {
         solid->resolved_proc = NULL;
-        YIELD(solid->token->pos, "Waiting for partially solidified procedure.");
+        YIELD(solid->token->pos, "Waiting for solidification to finish.");
     }
 
     // NOTE: Not a DirectiveSolidify.
@@ -4845,6 +4844,12 @@ CHECK_FUNC(type, AstType** ptype) {
             break;
         }
 
+        case Ast_Kind_Directive_Solidify: {
+            AstDirectiveSolidify **solidify = (AstDirectiveSolidify **) ptype;
+            CHECK(directive_solidify, solidify);
+            break;
+        }
+
         default: break;
     }
 

compiler/src/clone.c

@@ -76,12 +76,10 @@ static inline i32 ast_kind_to_size(AstNode* node) {
         case Ast_Kind_Param: return sizeof(AstLocal);
         case Ast_Kind_Argument: return sizeof(AstArgument);
         case Ast_Kind_Call: return sizeof(AstCall);
-        case Ast_Kind_Intrinsic_Call: return sizeof(AstCall);
         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_Subscript: return sizeof(AstSubscript);
-        case Ast_Kind_Slice: return sizeof(AstSubscript);
         case Ast_Kind_Field_Access: return sizeof(AstFieldAccess);
         case Ast_Kind_Unary_Field_Access: return sizeof(AstUnaryFieldAccess);
         case Ast_Kind_Pipe: return sizeof(AstBinaryOp);
@@ -215,7 +213,6 @@ AstNode* ast_clone(Context *context, void* n) {
             C(AstDereference, expr);
             break;
 
-        case Ast_Kind_Slice:
         case Ast_Kind_Subscript:
             C(AstSubscript, addr);
             C(AstSubscript, expr);

compiler/src/parser.c

@@ -1176,7 +1176,7 @@ static AstTyped* parse_factor(OnyxParser* parser) {
                 sub_node->token = open_bracket;
                 sub_node->addr = retval;
                 sub_node->expr = expr;
-                sub_node->__unused_operation = Binary_Op_Subscript;
+                sub_node->operation = Binary_Op_Subscript;
 
                 retval = (AstTyped *) sub_node;
                 expect_token(parser, ']');

compiler/src/wasm_emit.c

@@ -1838,6 +1838,11 @@ EMIT_FUNC(unaryop, AstUnaryOp* unop) {
 // this because many times for interoperability, it is nicer to get two primitive values for the pointer and
 // count of a slice, instead of a pointer.
 EMIT_FUNC(call, AstCall* call) {
+    if (call->intrinsic) {
+        emit_intrinsic_call(mod, pcode, call);
+        return;
+    }
+
     bh_arr(WasmInstruction) code = *pcode;
 
     u64 stack_top_idx = bh_imap_get(&mod->index_map, (u64) &mod->context->builtins.stack_top);
@@ -3338,7 +3343,6 @@ EMIT_FUNC(expression, AstTyped* expr) {
         case Ast_Kind_Do_Block:       emit_do_block(mod, &code, (AstDoBlock *) expr); break;
         case Ast_Kind_Call:           emit_call(mod, &code, (AstCall *) expr); break;
         case Ast_Kind_Argument:       emit_expression(mod, &code, ((AstArgument *) expr)->value); break;
-        case Ast_Kind_Intrinsic_Call: emit_intrinsic_call(mod, &code, (AstCall *) expr); break;
         case Ast_Kind_Binary_Op:      emit_binop(mod, &code, (AstBinaryOp *) expr); break;
         case Ast_Kind_Unary_Op:       emit_unaryop(mod, &code, (AstUnaryOp *) expr); break;
         case Ast_Kind_Alias:          emit_expression(mod, &code, ((AstAlias *) expr)->alias); break;
@@ -3379,6 +3383,32 @@ EMIT_FUNC(expression, AstTyped* expr) {
 
         case Ast_Kind_Subscript: {
             AstSubscript* sub = (AstSubscript *) expr;
+
+            if (sub->is_slice) {
+                emit_expression(mod, &code, sub->expr);
+                emit_struct_as_separate_values(mod, &code, sub->expr->type, 0); // nocheckin This should be optimized for range literals
+
+                u64 lo_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32);
+                u64 hi_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32);
+
+                WI(NULL, WI_DROP);
+                WIL(NULL, WI_LOCAL_SET, hi_local);
+                WIL(NULL, WI_LOCAL_TEE, lo_local);
+                if (sub->elem_size != 1) {
+                    WID(NULL, WI_I32_CONST, sub->elem_size);
+                    WI(NULL, WI_I32_MUL);
+                }
+                emit_expression(mod, &code, sub->addr);
+                WI(NULL, WI_I32_ADD);
+                WIL(NULL, WI_LOCAL_GET, hi_local);
+                WIL(NULL, WI_LOCAL_GET, lo_local);
+                WI(NULL, WI_I32_SUB);
+
+                local_raw_free(mod->local_alloc, lo_local);
+                local_raw_free(mod->local_alloc, hi_local);
+                break;
+            }
+
             u64 offset = 0;
             emit_subscript_location(mod, &code, sub, &offset);
             emit_load_instruction(mod, &code, sub->type, offset);
@@ -3497,33 +3527,6 @@ EMIT_FUNC(expression, AstTyped* expr) {
             break;
         }
 
-        case Ast_Kind_Slice: {
-            AstSubscript* sl = (AstSubscript *) expr;
-
-            emit_expression(mod, &code, sl->expr);
-            emit_struct_as_separate_values(mod, &code, sl->expr->type, 0); // nocheckin This should be optimized for range literals
-
-            u64 lo_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32);
-            u64 hi_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32);
-
-            WI(NULL, WI_DROP);
-            WIL(NULL, WI_LOCAL_SET, hi_local);
-            WIL(NULL, WI_LOCAL_TEE, lo_local);
-            if (sl->elem_size != 1) {
-                WID(NULL, WI_I32_CONST, sl->elem_size);
-                WI(NULL, WI_I32_MUL);
-            }
-            emit_expression(mod, &code, sl->addr);
-            WI(NULL, WI_I32_ADD);
-            WIL(NULL, WI_LOCAL_GET, hi_local);
-            WIL(NULL, WI_LOCAL_GET, lo_local);
-            WI(NULL, WI_I32_SUB);
-
-            local_raw_free(mod->local_alloc, lo_local);
-            local_raw_free(mod->local_alloc, hi_local);
-            break;
-        }
-
         case Ast_Kind_Size_Of: {
             AstSizeOf* so = (AstSizeOf *) expr;
             WID(NULL, WI_I32_CONST, so->size);