fixed: over-cloning things that don't need to be cloned

Author: brendanfh

compiler/include/astnodes.h

@@ -1956,6 +1956,7 @@ typedef struct CheckerData {
 typedef struct ClonerData {
     u32 clone_depth;
     b32 dont_copy_structs;
+    b32 cloning_code_block; // HACK
 
     bh_arr(AstNode *) captured_entities;
 } ClonerData;

compiler/src/checker.c

@@ -3267,19 +3267,12 @@ CHECK_FUNC(insert_directive, AstDirectiveInsert** pinsert, b32 expected_expressi
         ERROR(code_block->token->pos, "Here is the code block being unquoted.");
     }
 
-
-    // HACK when cloning the inner part of a code block, we have to be able to handle
-    // inline functions (lambdas) that are polymorphic or have captures. With either
-    // of these things, we have to clone the functions so any closures/polyvars referenced
-    // in them can be resolved correctly. To do this tho, we have to artificially increase
-    // the clone depth to make the cloner think we are one layer deeper than we actually
-    // are to fall into the code path where we clone the body of the function.
-    context->cloner.clone_depth++;
+    context->cloner.cloning_code_block = 1;
     bh_arr(AstNode *) captured_entities = NULL;
-    bh_arr_new(context->ast_alloc, captured_entities, 2);
+    bh_arr_new(context->gp_alloc, captured_entities, 2);
     AstNode* cloned_block = ast_clone_with_captured_entities(context, code_block->code, &captured_entities);
     cloned_block->next = insert->next;
-    context->cloner.clone_depth--;
+    context->cloner.cloning_code_block = 0;
 
     bh_arr_each(AstNode *, pnode, captured_entities) {
         add_entities_for_node(
@@ -3291,6 +3284,8 @@ CHECK_FUNC(insert_directive, AstDirectiveInsert** pinsert, b32 expected_expressi
         );
     }
 
+    bh_arr_free(captured_entities);
+
     i32 skip_scope_index = get_expression_integer_value(context, insert->skip_scope_index, NULL);
     Scope *scope_for_cloned_block = NULL;
     if (skip_scope_index > 0) {

compiler/src/clone.c

@@ -507,6 +507,16 @@ AstNode* ast_clone(Context *context, void* n) {
             AstFunction* df = (AstFunction *) nn;
             AstFunction* sf = (AstFunction *) node;
 
+            // If we cloning a code block, we do not need to clone the
+            // function body unless there are captures, we could be related
+            // to the code block bindings.
+            if (context->cloner.cloning_code_block) {
+                if (!sf->captures) {
+                    context->cloner.clone_depth--;
+                    return node;
+                }
+            }
+
             // Check if we are cloning a function inside of a function.
             if (context->cloner.clone_depth > 1) {
                 // If we are, and the inner function has a scope, this means that