Implement function captures. (#749)

Author: gdotdesign

spec/compilers/call_captured

@@ -0,0 +1,20 @@
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(_, _)("A", 0)
+  }
+}
+--------------------------------------------------------------------------------
+import { createElement as A } from "./runtime.js";
+
+export const B = () => {
+  const a = (b, c) => {
+    return A(`div`, {})
+  };
+  return ((d, e) => {
+    a(d, e)
+  })(`A`, 0)
+};

spec/compilers/call_labelled_captured

@@ -0,0 +1,18 @@
+component Main {
+  fun test (argument1 : String, argument2: Number) : String {
+    ""
+  }
+
+  fun render : String {
+    test(argument2: 0, argument1: _)("")
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const a = (b, c) => {
+    return ``
+  };
+  return ((d) => {
+    a(d, 0)
+  })(``)
+};

spec/examples/call

@@ -161,6 +161,36 @@ component Main {
   }
 }
 -------------------------------------------------------------------------------
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(_, _)("A", 0)
+  }
+}
+-------------------------------------------------------------------------------
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test("A", _)(0)
+  }
+}
+-------------------------------------------------------------------------------
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(_, 0)("A")
+  }
+}
+-------------------------------------------------------------------------------
 module Test {
   fun a (x : Bool, value : String) : String {
     value

src/compilers/call.cr

@@ -5,11 +5,21 @@ module Mint
         expression =
           compile node.expression
 
+        captures =
+          [] of Compiled
+
         arguments =
           node
             .arguments
             .sort_by { |item| resolve_order.index(item) || -1 }
-            .map { |item| compile item }
+            .map do |item|
+              case item.value
+              when Ast::Discard
+                [Variable.new.as(Item)].tap { |var| captures << var }
+              else
+                compile item
+              end
+            end
 
         receiver =
           case
@@ -19,7 +29,14 @@ module Mint
             expression
           end
 
-        js.call(receiver, arguments)
+        call =
+          js.call(receiver, arguments)
+
+        if captures.size > 0
+          ["("] + js.arrow_function(captures) { call } + [")"]
+        else
+          call
+        end
       end
     end
   end

src/parsers/call.cr

@@ -8,7 +8,7 @@ module Mint
         arguments = list(
           terminator: ')',
           separator: ','
-        ) { field(key_required: false) }
+        ) { field(key_required: false, discard: true) }
 
         whitespace
         next error :call_expected_closing_parenthesis do

src/parsers/field.cr

@@ -1,6 +1,6 @@
 module Mint
   class Parser
-    def field(*, key_required : Bool = true) : Ast::Field?
+    def field(*, key_required : Bool = true, discard : Bool = false) : Ast::Field?
       parse do |start_position|
         comment = self.comment
         whitespace
@@ -17,7 +17,13 @@ module Mint
           end
 
         next if key_required && !key
-        next unless value = expression
+
+        next unless value =
+                      if discard
+                        self.discard || expression
+                      else
+                        expression
+                      end
 
         Ast::Field.new(
           from: start_position,

src/type_checkers/call.cr

@@ -24,9 +24,6 @@ module Mint
           argument_size
         end
 
-      parameters =
-        [] of Checkable
-
       error! :call_argument_size_mismatch do
         block do
           text "The function you called takes"
@@ -71,13 +68,22 @@ module Mint
           end
         end
 
-      args.each_with_index do |argument, index|
-        argument_type =
-          resolve argument
+      parameters = [] of Checkable
+      captures = [] of Checkable
 
+      args.each_with_index do |argument, index|
         function_argument_type =
           function_type.parameters[index]
 
+        argument_type =
+          case argument.value
+          when Ast::Discard
+            captures << function_argument_type
+            function_argument_type
+          else
+            resolve argument
+          end
+
         error! :call_argument_type_mismatch do
           ordinal =
             ordinal(index + 1)
@@ -116,10 +122,14 @@ module Mint
 
       final = resolve_type(result.parameters.last)
 
-      if node.await && final.name == "Promise"
-        final.parameters.first
+      if captures.empty?
+        if node.await && final.name == "Promise"
+          final.parameters.first
+        else
+          final
+        end
       else
-        final
+        Type.new("Function", captures + [final])
       end
     end
   end