Split Parameter and TypeParameter out of Identifier

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 195 matching lines @@
   }
 
   visitCommaSeparated(List<Node> nodes, int hasRequiredType,
                       {bool newInForInit, bool newAtStatementBegin}) {
     for (int i = 0; i < nodes.length; i++) {
       if (i != 0) {
         atStatementBegin = false;
         out(",");
         spaceOut();
       }
-      visitNestedExpression(nodes[i], hasRequiredType,
-                            newInForInit: newInForInit,
-                            newAtStatementBegin: newAtStatementBegin);
+      var node = nodes[i];
+      if (node is Expression) {
+        visitNestedExpression(node, hasRequiredType,
+                              newInForInit: newInForInit,
+                              newAtStatementBegin: newAtStatementBegin);
+      } else {
+        // TODO(ochafik): Precedence of Parameters?
+        visit(node);
+      }
     }
   }
 
   visitAll(List<Node> nodes) {
     nodes.forEach(visit);
   }
 
   visitProgram(Program program) {
     if (program.scriptTag != null) {
       out('#!${program.scriptTag}\n');
@@ skipping 642 matching lines @@
   visitThis(This node) {
     out("this");
   }
 
   visitSuper(Super node) {
     out("super");
   }
 
   visitIdentifier(Identifier node) {
     out(localNamer.getName(node));
+  }
+
+  visitParameter(Parameter node) {
+    if (node.isRest) out('...');
+    visit(node.binding);
     outTypeAnnotation(node.type);
   }
 
-  visitRestParameter(RestParameter node) {
-    out('...');
-    visitIdentifier(node.parameter);
+  visitTypeParameter(TypeParameter node) {
+    visit(node.name);
+    if (node.bound != null && options.shouldEmitTypes) {
+      out(" extends ");
+      visit(node.bound);
+    }
   }
 
   bool isDigit(int charCode) {
     return charCodes.$0 <= charCode && charCode <= charCodes.$9;
   }
 
   bool isValidJavaScriptId(String field) {
     if (field.length < 3) return false;
     // Ignore the leading and trailing string-delimiter.
     for (int i = 1; i < field.length - 1; i++) {
@@ skipping 40 matching lines @@
   visitNamedFunction(NamedFunction namedFunction) {
     functionOut(namedFunction.function, namedFunction.name);
   }
 
   visitFun(Fun fun) {
     functionOut(fun, null);
   }
 
   visitArrowFun(ArrowFun fun) {
     localNamer.enterScope(fun);
-    if (fun.params.length == 1 &&
+    if (fun.params.length == 1 && fun.params.single.binding is Expression &&
         (fun.params.single.type == null || !options.shouldEmitTypes)) {
-      visitNestedExpression(fun.params.single, SPREAD,
-          newInForInit: false, newAtStatementBegin: false);
+      visit(fun.params.single.binding);
+      // visitNestedExpression(fun.params.single, SPREAD,
+      //     newInForInit: false, newAtStatementBegin: false);
     } else {
       out("(");
       visitCommaSeparated(fun.params, SPREAD,
           newInForInit: false, newAtStatementBegin: false);
       out(")");
     }
     outTypeAnnotation(fun.returnType);
     spaceOut();
     out("=>");
     if (fun.body is Expression) {
@@ skipping 125 matching lines @@
     visit(node.tag);
     visit(node.template);
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     indent();
     visit(node.classExpr);
     lineOut();
   }
 
-  void outTypeParams(Iterable<Identifier> typeParams) {
+  void outTypeParams(Iterable<TypeParameter> typeParams) {
     if (typeParams != null && options.shouldEmitTypes && typeParams.isNotEmpty) {
       out("<");
       var first = true;
       for (var typeParam in typeParams) {
         if (!first) out(", ");
         first = false;
         visit(typeParam);
       }
       out(">");
     }
@@ skipping 277 matching lines @@
                    params = new Set<String>();
 
   void forEachVar(void fn(String v)) => vars.forEach(fn);
   void forEachParam(void fn(String p)) => params.forEach(fn);
 
   void collectVarsInFunction(FunctionExpression fun) {
     if (!nested) {
       nested = true;
       if (fun.params != null) {
         for (var param in fun.params) {
-          params.add(param.name);
+          collectBinding(Node node) {
+            if (node is Identifier) {
+              // TODO(ochafik): collect destructured
+              params.add(node.name);
+            } else if (node is DestructuredVariable) {
+              collectBinding(node.name);
+              collectBinding(node.structure);
+            } else if (node is BindingPattern) {
+              node.variables.forEach(collectBinding);
+            }
+          }
+          collectBinding(param.binding);
         }
       }
       fun.body.accept(this);
       nested = false;
     }
   }
 
   void visitFunctionDeclaration(FunctionDeclaration declaration) {
     // Note that we don't bother collecting the name of the function.
     collectVarsInFunction(declaration.function);
@@ skipping 232 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);
+    else if (d is Parameter) _scanVariableBinding(d.binding);
     else d.accept(this);
   }
 
-  visitRestParameter(RestParameter node) {
-    _scanVariableBinding(node.parameter);
-    super.visitRestParameter(node);
+  visitParameter(Parameter node) {
+    _scanVariableBinding(node.binding);
+    super.visitParameter(node);
   }
 
   visitDestructuredVariable(DestructuredVariable node) {
     var name = node.name;
     if (name is Identifier) _scanVariableBinding(name);
     super.visitDestructuredVariable(node);
   }
 
   visitSimpleBindingPattern(SimpleBindingPattern node) {
     _scanVariableBinding(node.name);
@@ skipping 19 matching lines @@
     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);
   }
 }