cleaned up trying operator overloads

diff --git a/core/sync/barrier.onyx b/core/sync/barrier.onyx
index 8e7e84252ece5d00caddab166b97cdee0b1a5cee..b31fc696b33b61e4308363bc222e87dc770f0a0e 100644 (file)
--- a/core/sync/barrier.onyx
+++ b/core/sync/barrier.onyx
@@ -41,4 +41,4 @@ barrier_wait :: (b: ^Barrier) {
     b.generation += 1;
     condition_broadcast(^b.cond);
     return;
-}
\ No newline at end of file
+}

diff --git a/core/sync/mutex.onyx b/core/sync/mutex.onyx
index 1211ecf443c2b64aca9fa08619015893b9453652..19cc3894f058c1e9c19987789bbc771e86f81410 100644 (file)
--- a/core/sync/mutex.onyx
+++ b/core/sync/mutex.onyx
@@ -31,7 +31,14 @@ mutex_destroy :: (m: ^Mutex) {
 mutex_lock :: (m: ^Mutex) {
     while __atomic_cmpxchg(^m.lock, 0, 1) == 1 {
         if m.owner == context.thread_id do return;
-        __atomic_wait(^m.lock, 1);
+
+        @ThreadingCleanup // You cannot wait on the main thread in
+        // a web browser, for kind of obvious reasons. However, this
+        // makes waiting for a mutex expensive because the only option
+        // is to do a spin-lock. Ugh.
+        if context.thread_id != 0 {
+            __atomic_wait(^m.lock, 1);
+        }
     }
 
     m.owner = context.thread_id;
@@ -59,4 +66,4 @@ critical_section :: macro (m: ^Mutex, body: Code) -> i32 {
     #insert body;
 
     return 0;
-}
\ No newline at end of file
+}

diff --git a/modules/wasm_utils/parser.onyx b/modules/wasm_utils/parser.onyx
index 5cd7332139eb3c421163b0e68a7b4962f638f3e6..1b509e2751768fcd06eebb73ce17b304b1d75f83 100644 (file)
--- a/modules/wasm_utils/parser.onyx
+++ b/modules/wasm_utils/parser.onyx
@@ -295,8 +295,9 @@ parse_code_section :: (use bin: ^WasmBinary, allocator := context.allocator) ->
 }
 
 #private
-parse_vector :: (reader: ^io.Reader, bin: ^WasmBinary,
-                 read: (^io.Reader, ^WasmBinary) -> $T) -> [] T {
+parse_vector :: macro (reader: ^io.Reader, bin: ^WasmBinary,
+                       read: (^io.Reader, ^WasmBinary) -> $T) -> [] T {
+    wasm_allocator :: wasm_allocator;
     
     n := cast(u32) read_uleb128(reader);
     result := memory.make_slice(T, n, allocator=wasm_allocator);

diff --git a/modules/wasm_utils/types.onyx b/modules/wasm_utils/types.onyx
index 7812005d4d2bf386a2b803e283352475690cf3a4..d290d8ef1f2a8a0f112841e0d3f8a83c41755368 100644 (file)
--- a/modules/wasm_utils/types.onyx
+++ b/modules/wasm_utils/types.onyx
@@ -63,9 +63,9 @@ WasmImport :: struct {
     module_name : str;
     import_name : str;
 
-    type  : WasmForeignType;
+    type : WasmForeignType;
 
-    use __: struct #union {
+    use _: struct #union {
         index  : u32;
         limits : WasmLimits;
     };

diff --git a/src/checker.c b/src/checker.c
index f0c2c4b797b571803958dee5ae79b52074f2f726..8be7267d7470ba4e71d2af0c98523e838ffcbb36 100644 (file)
--- a/src/checker.c
+++ b/src/checker.c
@@ -598,33 +598,29 @@ static AstCall* binaryop_try_operator_overload(AstBinaryOp* binop, AstTyped* thi
     args.values = (AstTyped **) &value_buffer[sizeof(bh__arr)];
     bh_arr_set_length(args.values, third_argument ? 3 : 2);
 
-    args.values[0] = (AstTyped *) make_argument(context.ast_alloc, binop->left);
-    args.values[1] = (AstTyped *) make_argument(context.ast_alloc, binop->right);
-    if (third_argument != NULL) args.values[2] = (AstTyped *) make_argument(context.ast_alloc, third_argument);
-
-    u32 current_all_checks_are_final = all_checks_are_final;
-    all_checks_are_final = 0;
-    u32 current_checking_level_store = current_checking_level;
-    bh_arr_each(AstTyped *, v, args.values) check_argument((AstArgument **) v);
-    current_checking_level = current_checking_level_store;
-    all_checks_are_final   = current_all_checks_are_final;
-
     if (binop_is_assignment(binop->operation)) {
         args.values[0] = (AstTyped *) make_address_of(context.ast_alloc, binop->left);
 
+        u32 current_all_checks_are_final = all_checks_are_final;
+        all_checks_are_final = 0;
         u32 current_checking_level_store = current_checking_level;
         CheckStatus cs = check_address_of((AstAddressOf **) &args.values[0]);
         current_checking_level = current_checking_level_store;
+        all_checks_are_final   = current_all_checks_are_final;
 
-        if (cs == Check_Yield_Macro) return (AstCall *) &node_that_signals_a_yield;
-        if (cs == Check_Error)       return NULL;
+        if (cs == Check_Yield_Macro)      return (AstCall *) &node_that_signals_a_yield;
+        if (cs == Check_Error)            return NULL;
 
         args.values[0] = (AstTyped *) make_argument(context.ast_alloc, args.values[0]);
-        current_checking_level_store = current_checking_level;
-        check_argument((AstArgument **) &args.values[0]);
-        current_checking_level = current_checking_level_store;
+
+    } else {
+        args.values[0] = (AstTyped *) make_argument(context.ast_alloc, binop->left);
     }
 
+
+    args.values[1] = (AstTyped *) make_argument(context.ast_alloc, binop->right);
+    if (third_argument != NULL) args.values[2] = (AstTyped *) make_argument(context.ast_alloc, third_argument);
+
     b32 should_yield = 0;
     AstTyped* overload = find_matching_overload_by_arguments(operator_overloads[binop->operation], &args, &should_yield);
     if (should_yield)     return (AstCall *) &node_that_signals_a_yield;
@@ -863,6 +859,14 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop) {
     if (binop->flags & Ast_Flag_Has_Been_Checked) return Check_Success;
 
     if (binop->operation == Binary_Op_Assign && binop->left->kind == Ast_Kind_Subscript && bh_arr_length(operator_overloads[Binary_Op_Subscript_Equals]) > 0) {
+        AstSubscript* sub = (AstSubscript *) binop->left;
+        
+        u32 current_checking_level_store = current_checking_level;
+        CHECK(expression, &sub->addr);
+        CHECK(expression, &sub->expr);
+        CHECK(expression, &binop->right);
+        current_checking_level = current_checking_level_store;
+
         AstBinaryOp op;
         op.kind = Ast_Kind_Binary_Op;
         op.token = binop->token;
@@ -879,6 +883,7 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop) {
             CHECK(call, (AstCall **) pbinop);
             return Check_Success;
         }
+
     }
 
     u32 current_checking_level_store = current_checking_level;