Use destructuring assignments for named parameters (#180)

lib/src/js/nodes.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of js_ast;
 
 abstract class NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 64 matching lines @@
   T visitComment(Comment node);
   T visitCommentExpression(CommentExpression node);
 
   T visitInterpolatedExpression(InterpolatedExpression node);
   T visitInterpolatedLiteral(InterpolatedLiteral node);
   T visitInterpolatedParameter(InterpolatedParameter node);
   T visitInterpolatedSelector(InterpolatedSelector node);
   T visitInterpolatedStatement(InterpolatedStatement node);
   T visitInterpolatedMethod(InterpolatedMethod node);
   T visitInterpolatedIdentifier(InterpolatedIdentifier node);
+
+  T visitArrayDestructuring(ArrayDestructuring node);
+  T visitObjectDestructuring(ObjectDestructuring node);
+  T visitDestructuredVariable(DestructuredVariable node);
 }
 
 class BaseVisitor<T> implements NodeVisitor<T> {
   T visitNode(Node node) {
     node.visitChildren(this);
     return null;
   }
 
   T visitProgram(Program node) => visitNode(node);
 
@@ skipping 95 matching lines @@
       => visitInterpolatedNode(node);
   T visitInterpolatedIdentifier(InterpolatedIdentifier node)
       => visitInterpolatedNode(node);
 
   // Ignore comments by default.
   T visitComment(Comment node) => null;
   T visitCommentExpression(CommentExpression node) => null;
 
   T visitAwait(Await node) => visitExpression(node);
   T visitDartYield(DartYield node) => visitStatement(node);
+
+  T visitDestructuring(Destructuring node) => visitNode(node);
+  T visitArrayDestructuring(ArrayDestructuring node)
+      => visitDestructuring(node);
+  T visitObjectDestructuring(ObjectDestructuring node)
+      => visitDestructuring(node);
+  T visitDestructuredVariable(DestructuredVariable node) => visitNode(node);
 }
 
 abstract class Node {
   /// Sets the source location of this node. For performance reasons, we allow
   /// setting this after construction.
   Object sourceInformation;
 
   ClosureAnnotation _closureAnnotation;
   /// Closure annotation of this node.
   ClosureAnnotation get closureAnnotation => _closureAnnotation;
 
   accept(NodeVisitor visitor);
   void visitChildren(NodeVisitor visitor);
 
   // Shallow clone of node.  Does not clone positions since the only use of this
   // private method is create a copy with a new position.
   Node _clone();
 
   withClosureAnnotation(ClosureAnnotation closureAnnotation) {
     if (this.closureAnnotation == closureAnnotation) return this;
-    
+
     return _clone()
         ..sourceInformation = sourceInformation
         .._closureAnnotation = closureAnnotation;
   }
   // Returns a node equivalent to [this], but with new source position and end
   // source position.
   Node withSourceInformation(sourceInformation) {
     if (sourceInformation == this.sourceInformation) {
       return this;
     }
@@ skipping 500 matching lines @@
     leftHandSide.accept(visitor);
     if (value != null) value.accept(visitor);
   }
 
   Assignment _clone() =>
       new Assignment.compound(leftHandSide, op, value);
 }
 
 class VariableInitialization extends Assignment {
   /** [value] may be null. */
-  VariableInitialization(Identifier declaration, Expression value)
+  VariableInitialization(Declarator declaration, Expression value)
       : super(declaration, value);
 
-  Identifier get declaration => leftHandSide;
+  Declarator get declaration => leftHandSide;
 
   accept(NodeVisitor visitor) => visitor.visitVariableInitialization(this);
 
   VariableInitialization _clone() =>
       new VariableInitialization(declaration, value);
 }
 
+abstract class Declarator extends Expression {

[Jennifer Messerly, 2015/12/01 02:10:27]

The ES6 spec calls this a "Binding", as in BindingIdentifier and BindingPattern
and LexicalBinding:
http://www.ecma-international.org/ecma-262/6.0/#sec-declarations-and-the-vari...,
so maybe "VariableBinding"?

Not sure it's better, but would allow reusing some spec terminology. That said,
the existing AST nodes don't reuse terminology (...otherwise
"VariableInitialization" would be called "LexicalBinding")

You could add a link to the spec too for easy look up. 

(yeah, I kind of love spec links :). But they're great in compilers to quickly
double check why something is implemented the way it is.)

[ochafik, 2015/12/02 20:05:46]

Done (thank you so much for all these links, I feel ashamed of being too lazy to
put them around at the first place :-S)

+}
+
+class DestructuredVariable extends Expression implements Parameter {
+  final Identifier name;
+  final Destructuring structure;
+  final Expression defaultValue;
+  DestructuredVariable({this.name, this.structure, this.defaultValue});
+
+  accept(NodeVisitor visitor) => visitor.visitDestructuredVariable(this);
+  void visitChildren(NodeVisitor visitor) {
+    name?.accept(visitor);
+    structure?.accept(visitor);
+    defaultValue?.accept(visitor);
+  }
+
+  @override int get precedenceLevel => DESTRUCTURING;
+  @override Node _clone() =>
+      new DestructuredVariable(
+          name: name, structure: structure, defaultValue: defaultValue);
+}
+
+abstract class Destructuring extends Expression implements Declarator {
+  final List<DestructuredVariable> variables;
+  Destructuring(this.variables);
+
+  void visitChildren(NodeVisitor visitor) {
+    for (DestructuredVariable v in variables) v.accept(visitor);
+  }
+}
+
+class ObjectDestructuring extends Destructuring {
+  ObjectDestructuring(List<DestructuredVariable> variables)
+      : super(variables);
+  accept(NodeVisitor visitor) => visitor.visitObjectDestructuring(this);
+
+  @override int get precedenceLevel => DESTRUCTURING;
+  @override Node _clone() => new ObjectDestructuring(variables);
+}
+
+class ArrayDestructuring extends Destructuring {
+  ArrayDestructuring(List<DestructuredVariable> variables)
+      : super(variables);
+  accept(NodeVisitor visitor) => visitor.visitArrayDestructuring(this);
+
+  @override int get precedenceLevel => DESTRUCTURING;
+  @override Node _clone() => new ObjectDestructuring(variables);
+}
+
 class Conditional extends Expression {
   final Expression condition;
   final Expression then;
   final Expression otherwise;
 
   Conditional(this.condition, this.then, this.otherwise);
 
   accept(NodeVisitor visitor) => visitor.visitConditional(this);
 
   void visitChildren(NodeVisitor visitor) {
@@ skipping 175 matching lines @@
 
   Postfix _clone() => new Postfix(op, argument);
 
   void visitChildren(NodeVisitor visitor) {
     argument.accept(visitor);
   }
 
   int get precedenceLevel => UNARY;
 }
 
-abstract class Parameter implements Expression {}
+abstract class Parameter implements Expression, Declarator {}
 
-class Identifier extends Expression implements Parameter {
+class Identifier extends Expression implements Parameter, Declarator {
   final String name;
   final bool allowRename;
 
   Identifier(this.name, {this.allowRename: true}) {
     assert(_identifierRE.hasMatch(name));
   }
   static RegExp _identifierRE = new RegExp(r'^[A-Za-z_$][A-Za-z_$0-9]*$');
 
   Identifier _clone() =>
       new Identifier(name, allowRename: allowRename);
@@ skipping 607 matching lines @@
   final Expression expression;
 
   CommentExpression(this.comment, this.expression);
 
   int get precedenceLevel => PRIMARY;
   accept(NodeVisitor visitor) => visitor.visitCommentExpression(this);
   CommentExpression _clone() => new CommentExpression(comment, expression);
 
   void visitChildren(NodeVisitor visitor) => expression.accept(visitor);
 }