Feature/inner destructuring

spec/compilers/case_with_array_destructuring

@@ -20,16 +20,19 @@ class A extends _C {
       } else if (_compare(a, [`a`])) {
         return ``
       } else if (Array.isArray(a) && a.length === 1) {
-        const [b] = a;
+        const a__arr = Array.from(a);
+        const b = a__arr[0];
         return ``;
       } else if (Array.isArray(a) && a.length === 2) {
-        const [c,d] = a;
+        const a__arr = Array.from(a);
+        const c = a__arr[0];
+        const d = a__arr[1];
         return ``;
-      } else if (Array.isArray(a) && a.length >= 2) {
-        const __ = Array.from(a);
-        const e = __.shift();
-        const f = __.pop();
-        const g = __;
+      } else if (Array.isArray(a) && a.length >== 2) {
+        const a__arr = Array.from(a);
+        const e = a__arr.shift();
+        const f = a__arr.pop();
+        const g = a__arr;
         return ``;
       };
     })();

spec/compilers/case_with_tuple_destructuring

@@ -23,7 +23,9 @@ class A extends _C {
       } else if (_compare(a, [`A`, 0, true])) {
         return `A`
       } else if (Array.isArray(a)) {
-        const [b,c,d] = a;
+        const b = a[0];
+        const c = a[1];
+        const d = a[2];
         return b;
       };
     })();

src/ast.cr

@@ -4,6 +4,8 @@ module Mint
 
     alias TypeOrVariable = Type | TypeVariable
 
+    alias DestructuringType = ArrayDestructuring | EnumDestructuring | TupleDestructuring
+
     alias Expression = ParenthesizedExpression |
                        NegatedExpression |
                        InlineFunction |

src/ast/array_destructuring.cr

@@ -1,9 +1,11 @@
 module Mint
   class Ast
     class ArrayDestructuring < Node
+      alias ArrayDestructuringItem = DestructuringType | Variable | Spread
+
       getter items
 
-      def initialize(@items : Array(Node),
+      def initialize(@items : Array(ArrayDestructuringItem),
                      @input : Data,
                      @from : Int32,
                      @to : Int32)

src/ast/enum_destructuring.cr

@@ -1,9 +1,11 @@
 module Mint
   class Ast
     class EnumDestructuring < Node
+      alias EnumDestructuringParameter = DestructuringType | TypeVariable
+
       getter name, option, parameters
 
-      def initialize(@parameters : Array(TypeVariable),
+      def initialize(@parameters : Array(EnumDestructuringParameter),
                      @option : String,
                      @name : String,
                      @input : Data,

src/ast/tuple_destructuring.cr

@@ -1,9 +1,11 @@
 module Mint
   class Ast
     class TupleDestructuring < Node
+      alias TupleDestructuringParameter = DestructuringType | Variable
+
       getter parameters
 
-      def initialize(@parameters : Array(Variable),
+      def initialize(@parameters : Array(TupleDestructuringParameter),
                      @input : Data,
                      @from : Int32,
                      @to : Int32)

src/compilers/array_destructuring.cr

@@ -1,36 +1,64 @@
 module Mint
   class Compiler
-    def _compile(node : Ast::ArrayDestructuring, value)
+    private macro compile_item!(initial_var, item = item, index = index1)
+      var_name = js.variable_of({{ item }})
+      vars = [
+        {{ initial_var }}
+      ]
+
+      res = _compile_destructuring {{ item }}, var_name, "#{condition_var_name}[#{{{ index }}}]"
+      if res
+        condition += " && " + res[1]
+        vars.concat(res[0])
+      end
+
+      vars
+    end
+
+    def _compile(node : Ast::ArrayDestructuring, start_variable : String, condition_variable : String? = nil)
+      variable = "#{start_variable}__arr"
+
+      condition_var_name = condition_variable || start_variable
       if node.spread?
-        statements = [
-          "const __ = Array.from(#{value})",
-        ]
-
-        node
-          .items
-          .take_while(&.is_a?(Ast::Variable))
-          .each do |var|
-            statements << "const #{js.variable_of(var)} = __.shift()"
-          end
-
-        node
-          .items
-          .reverse
-          .take_while(&.is_a?(Ast::Variable))
-          .each do |var|
-            statements << "const #{js.variable_of(var)} = __.pop()"
-          end
-
-        statements << "const #{js.variable_of(node.items.select(Ast::Spread).first.variable)} = __"
-        statements
+        condition = "Array.isArray(#{condition_var_name}) && #{condition_var_name}.length >== #{node.items.size - 1}"
       else
-        variables =
-          node
+        condition = "Array.isArray(#{condition_var_name}) && #{condition_var_name}.length === #{node.items.size}"
+      end
+
+      variables = [
+        "const #{variable} = Array.from(#{start_variable})",
+      ] + (
+        unless node.spread?
+          node.items.map_with_index do |item, index1|
+            compile_item! "const #{var_name} = #{variable}[#{index1}]"
+          end.flatten
+        else
+          tmp = [] of Array(String)
+
+          start_vars = node
             .items
-            .join(',') { |param| js.variable_of(param) }
+            .take_while { |item| !item.is_a?(Ast::Spread) }
+            .map_with_index do |item, index1|
+              compile_item! "const #{var_name} = #{variable}.shift()"
+            end
 
-        ["const [#{variables}] = #{value}"]
-      end
+          end_vars = node
+            .items
+            .reverse
+            .take_while { |item| !item.is_a?(Ast::Spread) }
+            .map_with_index do |item, index1|
+              compile_item! "const #{var_name} = #{variable}.pop()"
+            end
+
+          tmp += start_vars if start_vars
+          tmp += end_vars if end_vars
+
+          tmp << ["const #{js.variable_of(node.items.select(Ast::Spread).first.variable)} = #{variable}"]
+          tmp.flatten
+        end
+      )
+
+      {variables, condition}
     end
   end
 end

src/compilers/case_branch.cr

@@ -20,49 +20,21 @@ module Mint
         end
 
       if match = node.match
-        case match
-        when Ast::ArrayDestructuring
-          statements =
-            _compile(match, variable)
-
-          statements << expression
-
-          if match.spread?
-            {
-              "Array.isArray(#{variable}) && #{variable}.length >= #{match.items.size - 1}",
-              js.statements(statements),
-            }
-          else
-            {
-              "Array.isArray(#{variable}) && #{variable}.length === #{match.items.size}",
-              js.statements(statements),
-            }
-          end
-        when Ast::TupleDestructuring
-          variables =
-            match
-              .parameters
-              .join(',') { |param| js.variable_of(param) }
-
+        tmp = case match
+              when Ast::ArrayDestructuring
+                _compile match, variable
+              when Ast::TupleDestructuring
+                _compile match, variable
+              when Ast::EnumDestructuring
+                _compile match, variable
+              else
+              end
+        if tmp
           {
-            "Array.isArray(#{variable})",
-            js.statements([
-              "const [#{variables}] = #{variable}",
+            tmp[1],
+            js.statements(tmp[0].concat([
               expression,
-            ]),
-          }
-        when Ast::EnumDestructuring
-          variables =
-            match.parameters.map_with_index do |param, index1|
-              "const #{js.variable_of(param)} = #{variable}._#{index1}"
-            end
-
-          name =
-            js.class_of(lookups[match])
-
-          {
-            "#{variable} instanceof #{name}",
-            js.statements(variables + [expression]),
+            ])),
           }
         else
           compiled =

src/compilers/destructuring.cr

@@ -0,0 +1,16 @@
+module Mint
+  class Compiler
+    def _compile_destructuring(node : Ast::Node, variable : String, condition_variable : String? = nil)
+      case node
+      when Ast::ArrayDestructuring
+        _compile node, variable, condition_variable
+      when Ast::TupleDestructuring
+        _compile node, variable, condition_variable
+      when Ast::EnumDestructuring
+        _compile node, variable, condition_variable
+      else
+        # ignore
+      end
+    end
+  end
+end

src/compilers/enum_destructuring.cr

@@ -0,0 +1,27 @@
+module Mint
+  class Compiler
+    def _compile(node : Ast::EnumDestructuring, variable : String, condition_variable : String? = nil)
+      name =
+        js.class_of(lookups[node])
+
+      condition_var_name = condition_variable || variable
+      condition = "#{condition_var_name} instanceof #{name}"
+
+      variables = node.parameters.map_with_index do |param, index1|
+        var_name = js.variable_of(param)
+        vars = ["const #{var_name} = #{variable}._#{index1}"]
+
+        res = _compile_destructuring param, var_name, "#{condition_var_name}._#{index1}"
+
+        if res
+          condition += " && " + res[1]
+          vars.concat(res[0])
+        end
+
+        vars
+      end.flatten
+
+      {variables, condition}
+    end
+  end
+end

src/compilers/tuple_destructuring.cr

@@ -0,0 +1,25 @@
+module Mint
+  class Compiler
+    def _compile(node : Ast::TupleDestructuring, variable : String, condition_variable : String? = nil) : {Array(String), String}
+      condition_var_name = condition_variable || variable
+      condition = "Array.isArray(#{condition_var_name})"
+
+      variables =
+        node.parameters.map_with_index do |param, index1|
+          var_name = js.variable_of(param)
+          vars = ["const #{var_name} = #{variable}[#{index1}]"]
+
+          res = _compile_destructuring param, var_name, "#{condition_var_name}[#{index1}]"
+
+          if res
+            condition += " && " + res[1]
+            vars.concat(res[0])
+          end
+
+          vars
+        end.flatten
+
+      {variables, condition}
+    end
+  end
+end

src/messages/enum_destructuring_expected_closing_parentheses.cr

@@ -0,0 +1,11 @@
+message EnumDestructuringExpectedClosingParentheses do
+  title "Syntax Error"
+
+  block do
+    text "I was looing for the"
+    code ")"
+    text "after paranthesed parameter in enum destructuring, but found"
+    code got
+    text "instead."
+  end
+end

src/parsers/array_destructuring.cr

@@ -6,7 +6,7 @@ module Mint
       start do |start_position|
         head = start do
           skip unless char! '['
-          value = variable || spread
+          value = enum_destructuring || tuple_destructuring || array_destructuring || variable || spread
           whitespace
           keyword ","
           whitespace
@@ -16,8 +16,8 @@ module Mint
         skip unless head
 
         items =
-          [head.as(Ast::Node)].concat(list(terminator: ']', separator: ',') do
-            variable || spread
+          [head.as(Ast::ArrayDestructuring::ArrayDestructuringItem)].concat(list(terminator: ']', separator: ',') do
+            value = enum_destructuring || tuple_destructuring || array_destructuring || variable || spread
           end.compact)
 
         whitespace
@@ -31,5 +31,8 @@ module Mint
           input: data)
       end
     end
+
+    def parse_destructuring_item
+    end
   end
 end

src/parsers/enum_destructuring.cr

@@ -2,6 +2,7 @@ module Mint
   class Parser
     syntax_error EnumDestructuringExpectedDoubleColon
     syntax_error EnumDestructuringExpectedOption
+    syntax_error EnumDestructuringExpectedClosingParentheses
 
     def enum_destructuring
       start do |start_position|
@@ -11,7 +12,16 @@ module Mint
 
         option = type_id! EnumDestructuringExpectedOption
 
-        parameters = many { type_variable }.compact
+        parameters = (many do
+          if char == '('
+            parended = char! '('
+            param = enum_destructuring || tuple_destructuring || array_destructuring || type_variable
+            char(')', EnumDestructuringExpectedClosingParentheses) if parended
+          else
+            param = type_variable.try(&.as Ast::Node)
+          end
+          param
+        end).compact
 
         Ast::EnumDestructuring.new(
           parameters: parameters,

src/parsers/tuple_destructuring.cr

@@ -6,7 +6,7 @@ module Mint
       start do |start_position|
         head = start do
           skip unless char! '{'
-          value = variable
+          value = enum_destructuring || tuple_destructuring || array_destructuring || variable
           whitespace
           char! ','
           whitespace
@@ -16,7 +16,9 @@ module Mint
         skip unless head
 
         parameters = [head].concat(
-          list(terminator: '}', separator: ',') { variable }.compact)
+          list(terminator: '}', separator: ',') do
+            enum_destructuring || tuple_destructuring || array_destructuring || variable
+          end.compact)
 
         whitespace