added: #inject option to #unquote

Author: brendanfh

compiler/include/astnodes.h

@@ -1630,6 +1630,12 @@ struct AstCodeBlock {
     b32 is_expression: 1;
 };
 
+typedef struct UnquoteDirectiveBinding UnquoteDirectiveBinding;
+struct UnquoteDirectiveBinding {
+    OnyxToken *symbol;
+    AstNode *value;
+};
+
 struct AstDirectiveInsert {
     AstTyped_base;
 
@@ -1638,6 +1644,8 @@ struct AstDirectiveInsert {
 
     // Set when using #skip_scope
     AstTyped *skip_scope_index;
+
+    bh_arr(UnquoteDirectiveBinding) bindings;
 };
 
 struct AstDirectiveInit {

compiler/src/checker.c

@@ -3324,9 +3324,8 @@ CHECK_FUNC(insert_directive, AstDirectiveInsert** pinsert, b32 expected_expressi
         scope_for_cloned_block = scope_create(context, skip_scope, cloned_block->token->pos);
     }
 
-    if (bound_expr_count > 0) {
-        Scope **scope = NULL;
-
+    Scope **scope = NULL;
+    if (bound_expr_count > 0 || bh_arr_length(insert->bindings) > 0) {
         if (cloned_block->kind == Ast_Kind_Block) {
             ((AstBlock *) cloned_block)->scope = scope_for_cloned_block;
             scope = &((AstBlock *) cloned_block)->quoted_block_capture_scope;
@@ -3351,26 +3350,35 @@ CHECK_FUNC(insert_directive, AstDirectiveInsert** pinsert, b32 expected_expressi
 
             cloned_block = (AstNode *) doblock;
         }
+    }
 
-        if (bound_symbol_count > 0) {
-            assert(scope);
-            *scope = scope_create(context, NULL, code_block->token->pos);
+    if (bound_symbol_count > 0) {
+        assert(scope);
+        *scope = scope_create(context, NULL, code_block->token->pos);
 
-            fori (i, 0, bound_symbol_count) {
-                CodeBlockBindingSymbol sym = code_block->binding_symbols[i];
-                if (sym.type_node) {
-                    Type *type = type_build_from_ast(context, sym.type_node);
+        fori (i, 0, bound_symbol_count) {
+            CodeBlockBindingSymbol sym = code_block->binding_symbols[i];
+            if (sym.type_node) {
+                Type *type = type_build_from_ast(context, sym.type_node);
 
-                    TYPE_CHECK(&insert->binding_exprs[i], type) {
-                        ERROR_(insert->token->pos, "Expected type '%s' but got type '%s' for the '%d%s' argument to the code block.", 
-                               type_get_name(context, type), type_get_name(context, insert->binding_exprs[i]->type),
-                               i + 1, bh_num_suffix(i + 1));
-                    }
+                TYPE_CHECK(&insert->binding_exprs[i], type) {
+                    ERROR_(insert->token->pos, "Expected type '%s' but got type '%s' for the '%d%s' argument to the code block.", 
+                           type_get_name(context, type), type_get_name(context, insert->binding_exprs[i]->type),
+                           i + 1, bh_num_suffix(i + 1));
                 }
-
-                AstNode *value = (void *) insert->binding_exprs[i];
-                symbol_introduce(context, *scope, sym.symbol, value);
             }
+
+            AstNode *value = (void *) insert->binding_exprs[i];
+            symbol_introduce(context, *scope, sym.symbol, value);
+        }
+    }
+
+    if (bh_arr_length(insert->bindings) > 0) {
+        assert(scope);
+        if (!*scope) *scope = scope_create(context, NULL, code_block->token->pos);
+
+        bh_arr_each(UnquoteDirectiveBinding, binding, insert->bindings) {
+            symbol_introduce(context, *scope, binding->symbol, (AstNode *) binding->value);
         }
     }
 

compiler/src/parser.c

@@ -1078,6 +1078,28 @@ static AstTyped* parse_factor(OnyxParser* parser) {
                     insert->skip_scope_index = parse_factor(parser);
                 }
 
+                // CLEANUP: Could this system use the same logic for AstBinding?
+                if (parse_possible_directive(parser, "inject")){
+                    expect_token(parser, '{');
+                    while (!consume_token_if_next(parser, '}')) {
+                        if (parser->hit_unexpected_token) break;
+
+                        OnyxToken *sym = expect_token(parser, Token_Type_Symbol);
+                        expect_token(parser, ':');
+                        expect_token(parser, ':');
+
+                        AstTyped *binding = parse_top_level_expression(parser);
+
+                        bh_arr_push(insert->bindings, ((UnquoteDirectiveBinding) {
+                            .symbol = sym,
+                            .value = (AstNode *) binding
+                        }));
+
+                        if (parser->curr->type != '}')
+                            consume_token_if_next(parser, ';');
+                    }
+                }
+
                 retval = (AstTyped *) insert;
                 break;
             }

core/builtin.onyx

@@ -533,7 +533,7 @@ __For_Expansion_Flags :: enum #flags {
 }
 
 /// All for-loops in Onyx are actually defined as an overload to this procedure.
-/// All overloads are macros that accept 3 arguments: the iteratable, flags, and the body
+/// All overloads are macros that accept 3 arguments: the iterable, flags, and the body
 /// of the loop. Examples of how to use this overloaded procedure can be found in `operations.onyx`
 /// next to this file.
 __for_expansion :: #match -> void {}

core/container/array.onyx

@@ -306,8 +306,7 @@ Array.filter :: macro (arr: &[..] $T, body: Code) {
 
 
 #overload #order 100
-__for_expansion :: macro (_s: &[..] $T, $flags: __For_Expansion_Flags, $body: Code) where
-    !(flags & .BY_POINTER)
+__for_expansion :: macro (_s: &[..] $T, $flags: __For_Expansion_Flags, $body: Code)
 {
     __s     := _s
     __data  := __s.data
@@ -317,37 +316,19 @@ __for_expansion :: macro (_s: &[..] $T, $flags: __For_Expansion_Flags, $body: Co
     while __i < __count {
         defer __i += 1
 
-        remove_code :: [] {
-            Array.delete(__s, __i)
-            __i -= 1
-            __count -= 1
+        #if flags & .BY_POINTER {
+            v := &__data[__i]
+        } else {
+            v := __data[__i]
         }
 
-        v := __data[__i]
-        #unquote body(v, __i, remove_code) #skip_scope(1)
-    }
-}
-
-#overload #order 100
-__for_expansion :: macro (_s: &[..] $T, $flags: __For_Expansion_Flags, $body: Code) where
-    (flags & .BY_POINTER)
-{
-    __s     := _s
-    __data  := __s.data
-    __count := __s.count
-
-    __i := 0
-    while __i < __count {
-        defer __i += 1
-
-        remove_code :: [] {
-            Array.delete(__s, __i)
-            __i -= 1
-            __count -= 1
+        #unquote body(v, __i) #skip_scope(1) #inject {
+            remove_element :: macro () {
+                Array.delete(__s, __i)
+                __i -= 1
+                __count -= 1
+            }
         }
-
-        v := &__data[__i]
-        #unquote body(v, __i, remove_code) #skip_scope(1)
     }
 }