Starting destructuring.

lib/ast.js

@@ -359,13 +359,73 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     }
 }, AST_Scope);
 
+var AST_ArrowParametersOrSeq = DEFNODE("ArrowParametersOrSeq", "expressions", {
+    $documentation: "A set of arrow function parameters or a sequence expression. This is used because when the parser sees a \"(\" it could be the start of a seq, or the start of a parameter list of an arrow function.",
+    $propdoc: {
+        expressions: "[AST_Expression|AST_Destructuring*] array of expressions or argument names or destructurings."
+    },
+    as_params: function (croak) {
+        // We don't want anything which doesn't belong in a destructuring
+        var root = this;
+        return this.expressions.map(function to_fun_args(ex) {
+            if (ex instanceof AST_Object) {
+                if (ex.properties.length == 0)
+                    croak("Invalid destructuring function parameter", ex.start.line, ex.start.col);
+                return new AST_Destructuring({
+                    start: ex.start,
+                    end: ex.end,
+                    is_array: false,
+                    names: ex.properties.map(to_fun_args)
+                });
+            } else if (ex instanceof AST_ObjectSymbol) {
+                return new AST_SymbolFunarg({
+                    name: ex.symbol.name,
+                    start: ex.start,
+                    end: ex.end
+                });
+            } else if (ex instanceof AST_SymbolRef) {
+                return new AST_SymbolFunarg({
+                    name: ex.name,
+                    start: ex.start,
+                    end: ex.end
+                });
+            } else if (ex instanceof AST_Array) {
+                if (ex.elements.length === 0)
+                    croak("Invalid destructuring function parameter", ex.start.line, ex.start.col);
+                return new AST_Destructuring({
+                    start: ex.start,
+                    end: ex.end,
+                    is_array: true,
+                    names: ex.elements.map(to_fun_args)
+                });
+            } else {
+                console.log(ex.__proto__.TYPE)
+                croak("Invalid function parameter", ex.start.line, ex.start.col);
+            }
+        });
+    },
+    as_expr: function (croak) {
+        return AST_Seq.from_array(this.expressions);
+    }
+});
+
 var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
         name: "[AST_SymbolDeclaration?] the name of this function",
-        argnames: "[AST_SymbolFunarg*] array of function arguments",
+        argnames: "[AST_SymbolFunarg|AST_Destructuring*] array of function arguments or destructurings",
         uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
     },
+    args_as_names: function () {
+        var out = [];
+        this.walk(new TreeWalker(function (parm) {
+            var that = this;
+            if (parm instanceof AST_SymbolFunarg) {
+                out.push(parm);
+            }
+        }));
+        return out;
+    },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
             if (this.name) this.name._walk(visitor);
@@ -385,10 +445,26 @@ var AST_Function = DEFNODE("Function", null, {
     $documentation: "A function expression"
 }, AST_Lambda);
 
+var AST_Arrow = DEFNODE("Arrow", null, {
+    $documentation: "An ES6 Arrow function ((a) => b)"
+}, AST_Lambda);
+
 var AST_Defun = DEFNODE("Defun", null, {
     $documentation: "A function definition"
 }, AST_Lambda);
 
+/* -----[ DESTRUCTURING ]----- */
+var AST_Destructuring = DEFNODE("Destructuring", "names is_array", {
+    $documentation: "A destructuring of several names. Used in destructuring assignment and with destructuring function argument names",
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.names.forEach(function(name){
+                name._walk(visitor);
+            });
+        });
+    }
+});
+
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
@@ -774,6 +850,18 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
     }
 }, AST_ObjectProperty);
 
+var AST_ObjectSymbol = DEFNODE("ObjectSymbol", "symbol", {
+    $propdoc: {
+        symbol: "[AST_SymbolRef] what symbol it is"
+    },
+    $documentation: "A symbol in an object",
+    _walk: function (visitor) {
+        return visitor._visit(this, function(){
+            this.symbol._walk(visitor);
+        });
+    }
+}, AST_ObjectProperty);
+
 var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
     $documentation: "An object setter property",
 }, AST_ObjectProperty);