Don't reorder arguments in the formatter.

mint-lang · gdotdesign · Sep 17, 2023 · Jun 12, 2023 · Jun 13, 2023 · Jun 13, 2023
commit dd254f8bed6f1077c88346a1eccb59a55f7d1447
diff --git a/src/compiler.cr b/src/compiler.cr
@@ -4,7 +4,7 @@ module Mint
 
     delegate lookups, checked, cache, component_records, to: @artifacts
     delegate ast, types, variables, resolve_order, to: @artifacts
-    delegate record_field_lookup, locales, to: @artifacts
+    delegate record_field_lookup, locales, argument_order, to: @artifacts
 
     getter js, style_builder, static_components, static_components_pool
     getter build, relative

diff --git a/src/compilers/call.cr b/src/compilers/call.cr
@@ -5,7 +5,7 @@ module Mint
         compile node.expression
 
       arguments =
-        compile node.arguments, ", "
+        compile node.arguments.sort_by! { |item| argument_order.index(item) || -1 }, ", "
 
       case
       when node.expression.is_a?(Ast::InlineFunction)

diff --git a/src/formatters/call.cr b/src/formatters/call.cr
@@ -1,9 +1,5 @@
 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/formatters/call_expression.cr b/src/formatters/call_expression.cr
@@ -0,0 +1,14 @@
+module Mint
+  class Formatter
+    def format(node : Ast::CallExpression)
+      expression =
+        format node.expression
+
+      if name = node.name
+        "#{name.value}: #{expression}"
+      else
+        expression
+      end
+    end
+  end
+end
diff --git a/src/messages/call_not_found_argument.cr b/src/messages/call_not_found_argument.cr
@@ -2,10 +2,12 @@ message CallNotFoundArgument do
   title "Type Error"
 
   block do
-    text "I was looking for the name argument:"
+    text "I was looking for the argument:"
     bold name
     text "but it's not there."
   end
 
+  type_with_text function_type, "The type of the function is:"
+
   snippet node, "The call is here:"
 end
diff --git a/src/type_checker.cr b/src/type_checker.cr
@@ -43,7 +43,7 @@ module Mint
 
     delegate checked, record_field_lookup, component_records, to: artifacts
     delegate types, variables, ast, lookups, cache, to: artifacts
-    delegate assets, resolve_order, locales, to: artifacts
+    delegate assets, resolve_order, locales, argument_order, to: artifacts
 
     delegate component?, component, stateful?, current_top_level_entity?, to: scope
     delegate format, to: formatter

diff --git a/src/type_checker/artifacts.cr b/src/type_checker/artifacts.cr
@@ -3,6 +3,7 @@ module Mint
     class Artifacts
       getter ast, lookups, cache, checked, record_field_lookup, assets
       getter types, variables, component_records, resolve_order, locales
+      getter argument_order
 
       def initialize(@ast : Ast,
                      @component_records = {} of Ast::Component => Record,
@@ -13,6 +14,7 @@ module Mint
                      @types = {} of Ast::Node => Checkable,
                      @cache = {} of Ast::Node => Checkable,
                      @locales = {} of String => Hash(String, Ast::Node),
+                     @argument_order = [] of Ast::Node,
                      @resolve_order = [] of Ast::Node,
                      @checked = Set(Ast::Node).new)
       end

diff --git a/src/type_checker/type.cr b/src/type_checker/type.cr
@@ -22,6 +22,7 @@ module Mint
             parameters.map do |param|
               pretty =
                 param.to_pretty.as(String)
+
               if param.label
                 "#{param.label}: #{pretty}"
               else

diff --git a/src/type_checkers/call.cr b/src/type_checkers/call.cr
@@ -8,7 +8,7 @@ module Mint
     type_error CallNotAFunction
 
     def check(node : Ast::CallExpression)
-      resolve(node.expression).tap do |item|
+      resolve(node.expression).dup.tap do |item|
         item.label = node.name.try(&.value)
       end
     end
@@ -46,29 +46,33 @@ 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,
+      args =
+        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, {
-            raise CallNotFoundArgument, {
+            raise ArgumentNameMismatch, {
-            raise CallNotFoundArgument, {
+            raise ArgumentNameMismatch, {
+              "function_type" => function_type,
+              "name"          => argument.name.try(&.value).to_s,
+              "node"          => node,
+            } unless index
+
+            index
+          end
+        else
+          raise CallMixedArguments, {
             "node" => node,
-          } unless index
-
-          index
+          }
         end
-      else
-        raise CallMixedArguments, {
-          "node" => node,
-        }
-      end
 
-      node.arguments.each_with_index do |argument, index|
+      argument_order.concat args
+
+      args.each_with_index do |argument, index|
         argument_type =
           resolve argument
 
@@ -86,8 +90,8 @@ module Mint
         parameters << argument_type
       end
 
-      if (optional_param_count = argument_size - node.arguments.size) > 0
-        parameters.concat(function_type.parameters[node.arguments.size, optional_param_count])
+      if (optional_param_count = argument_size - args.size) > 0
+        parameters.concat(function_type.parameters[args.size, optional_param_count])
       end
 
       call_type =