added: closures inside of polymorphic procedures

diff --git a/compiler/src/astnodes.c b/compiler/src/astnodes.c
index a5324eff6db195a7fcb6b7867ce5e90abe4482fd..5730ca4c4f48ab96a817af191d3bf1f6ed8aa1b0 100644 (file)
--- a/compiler/src/astnodes.c
+++ b/compiler/src/astnodes.c
@@ -696,6 +696,13 @@ TypeMatch unify_node_and_type_(AstTyped** pnode, Type* type, b32 permanent) {
         node = *pnode;
     }
 
+    if (node->kind == Ast_Kind_Function) {
+        if (maybe_create_capture_builder_for_function_expression(pnode)) {
+            return TYPE_MATCH_SPECIAL;
+        }
+    }
+
+
     // HACK: NullProcHack
     // The null_proc matches any procedure, and because of that, will cause a runtime error if you
     // try to call it.

diff --git a/compiler/src/checker.c b/compiler/src/checker.c
index 2ea8471a901c4dad3c8a8bc9fe6264c5fc84ae51..874a69f299ce9b19ca00a400dbf54523f558f4f5 100644 (file)
--- a/compiler/src/checker.c
+++ b/compiler/src/checker.c
@@ -52,6 +52,7 @@
     TypeMatch type_name;                                                                        \
     type_name = unify_node_and_type(expr, type);                                                \
     if (type_name == TYPE_MATCH_YIELD) YIELD((*expr)->token->pos, "Waiting on type checking."); \
+    if (type_name == TYPE_MATCH_SPECIAL) return Check_Return_To_Symres;                         \
     if (type_name == TYPE_MATCH_FAILED)
 
 #define CONCAT(a, b) a##_##b
@@ -789,6 +790,10 @@ CheckStatus check_call(AstCall** pcall) {
         return Check_Error;
     }
 
+    if (tm == TYPE_MATCH_SPECIAL) {
+        return Check_Return_To_Symres;
+    }
+
     if (tm == TYPE_MATCH_YIELD) YIELD(call->token->pos, "Waiting on argument type checking.");
 
     call->flags   |= Ast_Flag_Has_Been_Checked;

diff --git a/compiler/src/parser.c b/compiler/src/parser.c
index 7aa9c6b18c858d5c3e2c93790d658033eebfdfb3..d1af248e50437591925404b7e61a2756fba50a4c 100644 (file)
--- a/compiler/src/parser.c
+++ b/compiler/src/parser.c
@@ -2580,6 +2580,7 @@ static AstOverloadedFunction* parse_overloaded_function(OnyxParser* parser, Onyx
         }
 
         AstTyped* option = parse_expression(parser, 0);
+        option->flags &= ~Ast_Flag_Function_Is_Lambda;
         add_overload_option(&ofunc->overloads, order++, option);
 
         if (parser->curr->type != '}')
@@ -3454,6 +3455,7 @@ static void parse_top_level_statement(OnyxParser* parser) {
                 }
 
                 add_overload->overload = parse_expression(parser, 0);
+                add_overload->overload->flags &= ~Ast_Flag_Function_Is_Lambda;
 
                 ENTITY_SUBMIT(add_overload);
                 return;

diff --git a/compiler/src/utils.c b/compiler/src/utils.c
index 298f6ed1eb7eabe74346855c543846945bc5c4b3..fc00cea5aae7936149e18492ecf2f2cb2d123a59 100644 (file)
--- a/compiler/src/utils.c
+++ b/compiler/src/utils.c
@@ -1070,6 +1070,7 @@ TypeMatch check_arguments_against_type(Arguments* args, TypeFunction* func_type,
                 assert(arg_arr[arg_pos]->kind == Ast_Kind_Argument);
                 TypeMatch tm = unify_node_and_type_(&arg_arr[arg_pos]->value, formal_params[arg_pos], permanent);
                 if (tm == TYPE_MATCH_YIELD) return tm;
+                if (tm == TYPE_MATCH_SPECIAL) return tm;
                 if (tm == TYPE_MATCH_FAILED) {
                     if (error != NULL) {
                         error->pos = arg_arr[arg_pos]->token->pos;