Implement labelled calls.

mint-lang · gdotdesign · Sep 17, 2023 · Jun 12, 2023 · Jun 13, 2023 · Jun 13, 2023
commit cb99c78c56c4930e1b3390482f5c3cf6f91e9c4a
diff --git a/spec/compilers/call_labelled b/spec/compilers/call_labelled
@@ -0,0 +1,21 @@
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(argument2: 0, argument1: "")
+  }
+}
+--------------------------------------------------------------------------------
+class A extends _C {
+  a(b, c) {
+    return _h("div", {});
+  }
+
+  render() {
+    return this.a(``, 0);
+  }
+};
+
+A.displayName = "Main";
diff --git a/spec/type_checking/function_call_labelled b/spec/type_checking/function_call_labelled
@@ -0,0 +1,39 @@
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(argument2: 0, argument1: "")
+  }
+}
+-------------------------------------------------------------CallMixedArguments
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(0, argument1: "")
+  }
+}
+-------------------------------------------------------------CallMixedArguments
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(argument2: 0, "")
+  }
+}
+-----------------------------------------------------------CallNotFoundArgument
+component Main {
+  fun test (argument1 : String, argument2: Number) : Html {
+    <div/>
+  }
+
+  fun render : Html {
+    test(argument3: 0, argument1: "")
+  }
+}
diff --git a/src/ast/call.cr b/src/ast/call.cr
@@ -3,7 +3,7 @@ module Mint
     class Call < Node
       getter arguments, expression
 
-      def initialize(@arguments : Array(Expression),
+      def initialize(@arguments : Array(CallExpression),
                      @expression : Expression,
                      @input : Data,
                      @from : Int32,

diff --git a/src/ast/call_expression.cr b/src/ast/call_expression.cr
@@ -0,0 +1,14 @@
+module Mint
+  class Ast
+    class CallExpression < Node
+      getter name, expression
+
+      def initialize(@expression : Expression,
+                     @name : Variable?,
+                     @input : Data,
+                     @from : Int32,
+                     @to : Int32)
+      end
+    end
+  end
+end
diff --git a/src/ast/pipe.cr b/src/ast/pipe.cr
@@ -11,19 +11,27 @@ module Mint
       end
 
       def call
+        arg =
+          Ast::CallExpression.new(
+            expression: argument,
+            input: argument.input,
+            from: argument.from,
+            to: argument.to,
+            name: nil)
+
         @call ||=
           case item = expression
           when Ast::Call
             Ast::Call.new(
-              arguments: [argument] + item.arguments,
+              arguments: [arg] + item.arguments,
               expression: item.expression,
               input: item.input,
               from: item.from,
               to: item.to)
           else
             Ast::Call.new(
               expression: expression,
-              arguments: [argument],
+              arguments: [arg],
               input: input,
               from: from,
               to: to)

diff --git a/src/compilers/call_expression.cr b/src/compilers/call_expression.cr
@@ -0,0 +1,7 @@
+module Mint
+  class Compiler
+    def _compile(node : Ast::CallExpression)
+      compile node.expression
+    end
+  end
+end
diff --git a/src/formatters/call.cr b/src/formatters/call.cr
@@ -1,5 +1,9 @@
 module Mint
   class Formatter
+    def format(node : Ast::CallExpression)
+      format node.expression
+    end
+
     def format(node : Ast::Call) : String
       expression =
         format node.expression

diff --git a/src/messages/call_mixed_arguments.cr b/src/messages/call_mixed_arguments.cr
@@ -0,0 +1,9 @@
+message CallMixedArguments do
+  title "Type Error"
+
+  block do
+    text "A call cannot have named and unamed arguments at the same time."
+  end
+
+  snippet node, "It is here:"
+end
diff --git a/src/messages/call_not_found_argument.cr b/src/messages/call_not_found_argument.cr
@@ -0,0 +1,11 @@
+message CallNotFoundArgument do
+  title "Type Error"
+
+  block do
+    text "I was looking for the name argument:"
+    bold name
+    text "but it's not there."
+  end
+
+  snippet node, "The call is here:"
+end
diff --git a/src/parsers/call.cr b/src/parsers/call.cr
@@ -10,7 +10,7 @@ module Mint
         arguments = list(
           terminator: ')',
           separator: ','
-        ) { expression.as(Ast::Expression?) }
+        ) { call_expression.as(Ast::CallExpression?) }
         whitespace
 
         char ')', CallExpectedClosingParentheses

diff --git a/src/parsers/call_expression.cr b/src/parsers/call_expression.cr
@@ -0,0 +1,27 @@
+module Mint
+  class Parser
+    def call_expression : Ast::CallExpression?
+      start do |start_position|
+        name =
+          start do
+            next unless key = variable
+            whitespace
+
+            next unless char! ':'
+            whitespace
+
+            key
+          end
+
+        return unless expression = self.expression
+
+        Ast::CallExpression.new(
+          expression: expression,
+          from: start_position,
+          to: position,
+          input: data,
+          name: name)
+      end
+    end
+  end
+end
diff --git a/src/type_checker/comparer.cr b/src/type_checker/comparer.cr
@@ -29,7 +29,7 @@ module Mint
           parameters =
             node.parameters.map { |param| fill(param, mapping).as(Checkable) }
 
-          Type.new(node.name, parameters)
+          Type.new(node.name, parameters, node.label)
         else
           node
         end
@@ -113,7 +113,7 @@ module Mint
       end
 
       def fresh(node : Variable)
-        Variable.new(node.name)
+        Variable.new(node.name, node.label)
       end
 
       def fresh(node : Type, mapping = {} of Int32 => Variable)
@@ -131,7 +131,7 @@ module Mint
               end
             end
 
-        Type.new(node.name, params)
+        Type.new(node.name, params, node.label)
       end
 
       def fresh(node : PartialRecord)
@@ -142,7 +142,7 @@ module Mint
               memo[key] = fresh value
             end
 
-        PartialRecord.new(node.name, fields)
+        PartialRecord.new(node.name, fields, label: node.label)
       end
 
       def fresh(node : Record)
@@ -153,7 +153,7 @@ module Mint
               memo[key] = fresh value
             end
 
-        Record.new(node.name, fields)
+        Record.new(node.name, fields, label: node.label)
       end
 
       def prune(node : Variable)

diff --git a/src/type_checker/record.cr b/src/type_checker/record.cr
@@ -2,12 +2,15 @@ module Mint
   class TypeChecker
     class Record
       property parameters = [] of Checkable
+      property label : String?
+
       getter name, fields, mappings
 
       def initialize(
         @name : String,
         @fields = {} of String => Checkable,
-        @mappings = {} of String => String?
+        @mappings = {} of String => String?,
+        @label = nil
       )
       end
 

diff --git a/src/type_checker/type.cr b/src/type_checker/type.cr
@@ -5,8 +5,9 @@ module Mint
       getter name : String
 
       property optional_count : Int32 = 0
+      property label : String?
 
-      def initialize(@name, @parameters = [] of Checkable)
+      def initialize(@name, @parameters = [] of Checkable, @label = nil)
       end
 
       def to_mint
@@ -18,7 +19,15 @@ module Mint
           name
         else
           params =
-            parameters.map(&.to_pretty.as(String))
+            parameters.map do |param|
+              pretty =
+                param.to_pretty.as(String)
+              if param.label
+                "#{param.label}: #{pretty}"
+              else
+                pretty
+              end
+            end
 
           if params.size > 1 || params[0].includes?("\n")
             "#{name}(\n#{params.join(",\n").indent})"

diff --git a/src/type_checker/variable.cr b/src/type_checker/variable.cr
@@ -5,10 +5,12 @@ module Mint
 
       property parameters = [] of Checkable
       property instance : Checkable?
+      property label : String?
+
       getter name : String
       getter id : Int32
 
-      def initialize(@name)
+      def initialize(@name, @label = nil)
         @id = (@@id += 1)
       end
 

diff --git a/src/type_checkers/argument.cr b/src/type_checkers/argument.cr
@@ -3,7 +3,9 @@ module Mint
     def check(node : Ast::Argument) : Checkable
       node.default.try { |default| resolve default }
 
-      resolve_type(resolve(node.type))
+      resolve_type(resolve(node.type)).tap do |item|
+        item.label = node.name.try(&.value)
+      end
     end
   end
 end
diff --git a/src/type_checkers/call.cr b/src/type_checkers/call.cr
@@ -2,9 +2,17 @@ module Mint
   class TypeChecker
     type_error CallArgumentSizeMismatch
     type_error CallArgumentTypeMismatch
+    type_error CallNotFoundArgument
+    type_error CallMixedArguments
     type_error CallTypeMismatch
     type_error CallNotAFunction
 
+    def check(node : Ast::CallExpression)
+      resolve(node.expression).tap do |item|
+        item.label = node.name.try(&.value)
+      end
+    end
+
     def check(node : Ast::Call)
       function_type =
         resolve node.expression
@@ -38,6 +46,28 @@ module Mint
       } if node.arguments.size > argument_size ||       # If it's more than the maximum
            node.arguments.size < required_argument_size # If it's less then the minimum
 
+      if node.arguments.all?(&.name.nil?)
+        node.arguments
+      elsif node.arguments.all?(&.name.!=(nil))
+        node.arguments.sort_by! do |argument|
+          index =
+            function_type
+              .parameters
+              .index { |param| param.label == argument.name.try(&.value) }
+
+          raise CallNotFoundArgument, {
+            "name" => argument.name.try(&.value).to_s,
+            "node" => node,
+          } unless index
+
+          index
+        end
+      else
+        raise CallMixedArguments, {
+          "node" => node,
+        }
+      end
+
       node.arguments.each_with_index do |argument, index|
         argument_type =
           resolve argument