Use default params when --destructure-named-params + fix renaming of reserved destructured params

lib/src/js/printer.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;
 
 
 class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
   final bool minifyLocalVariables;
@@ skipping 602 matching lines @@
                         newInForInit: false, newAtStatementBegin: false);
     out("]");
   }
   visitObjectBindingPattern(ObjectBindingPattern node) {
     out("{");
     visitCommaSeparated(node.variables, EXPRESSION,
                         newInForInit: false, newAtStatementBegin: false);
     out("}");
   }
 
   visitDestructuredVariable(DestructuredVariable node) {

[Jennifer Messerly, 2016/02/09 00:33:07]

this code looks a lot like propertyNameOut. Can they be unified cleanly?

if not, it may still be worth handling the invalid name issue on this side of
the world.

(Generally Printer is very easy to work with, unlike our Dart->JS transformer
where there's a lot of Dart->JS semantic knowledge we're trying to keep in
mind.)

[ochafik, 2016/02/09 01:51:20]

I agree in principle, but see the other comment: I think we need both a
LiteralString (for the matching pattern, with a computed / non computed printing
logic that differs from Printer's semantics of isValidJavaScriptId) and an
identifier. I think this + the different printing logic (add a ": identifier"
only if we printed the name in computed property style) makes it hard to unify.

-    var hasName = node.name != null;
-    if (hasName) visit(node.name);
+    var name = node.name;
+    var hasName = name != null;
+    if (hasName) {
+      if (name is LiteralString) {
+        out("[");
+        out(name.value);
+        out("]");
+      } else {
+        visit(name);
+      }
+    }
     if (node.structure != null) {
       if (hasName) {
         out(":");
         spaceOut();
       }
       visit(node.structure);
     }
     if (node.defaultValue != null) {
       spaceOut();
       out("=");
       spaceOut();
       visitNestedExpression(node.defaultValue, EXPRESSION,
                             newInForInit: false, newAtStatementBegin: false);
     }
   }
 
+  visitSimpleBindingPattern(SimpleBindingPattern node) {
+    visit(node.name);
+  }
+
   visitAssignment(Assignment assignment) {
     visitNestedExpression(assignment.leftHandSide, LEFT_HAND_SIDE,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     if (assignment.value != null) {
       spaceOut();
       String op = assignment.op;
       if (op != null) out(op);
       out("=");
       spaceOut();
@@ skipping 926 matching lines @@
 abstract class VariableDeclarationVisitor<T> extends BaseVisitor<T> {
   declare(Identifier node);
 
   visitFunctionExpression(FunctionExpression node) {
     node.params.forEach(_scanVariableBinding);
     node.body.accept(this);
   }
 
   _scanVariableBinding(VariableBinding d) {
     if (d is Identifier) declare(d);
-    if (d is RestParameter) _scanVariableBinding(d.parameter);
-    else if (d is BindingPattern) {
-      for (var v in d.variables) {
-        if (v.name != null) declare(v.name);
-        if (v.structure != null) _scanVariableBinding(v.structure);
-      }
-    }
+    else d.accept(this);
+  }
+
+  visitDestructuredVariable(DestructuredVariable node) {
+    var name = node.name;
+    if (name is Identifier) _scanVariableBinding(name);
+    super.visitDestructuredVariable(node);
+  }
+
+  visitSimpleBindingPattern(SimpleBindingPattern node) {
+    _scanVariableBinding(node.name);
+    super.visitSimpleBindingPattern(node);
   }
 
   visitVariableInitialization(VariableInitialization node) {
     _scanVariableBinding(node.declaration);
     if (node.value != null) node.value.accept(this);
   }
 
   visitCatch(Catch node) {
     declare(node.declaration);
     node.body.accept(this);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     declare(node.name);
     node.function.accept(this);
   }
 
   visitNamedFunction(NamedFunction node) {
     declare(node.name);
     node.function.accept(this);
   }
 
   visitClassExpression(ClassExpression node) {
     declare(node.name);
     if (node.heritage != null) node.heritage.accept(this);
     for (Method element in node.methods) element.accept(this);
   }
 }