Introduce _emitParameterReferences to avoid mixing params with param references.

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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.
 
 library js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1311 matching lines @@
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
   JS.Fun _emitNativeFunctionBody(
-      List<JS.Parameter> params, MethodDeclaration node) {
+      List<JS.Parameter> params, List<JS.Expression> paramRefs,
+      MethodDeclaration node) {
     if (node.isStatic) {
       // TODO(vsm): Do we need to handle this case?
       return null;
     }
 
     String name = node.name.name;
     var annotation = findAnnotation(node.element, isJsName);
     if (annotation != null) {
       name = getConstantField(annotation, 'name', types.stringType)
           ?.toStringValue();
     }
     if (node.isGetter) {
       return new JS.Fun(params, js.statement('{ return this.#; }', [name]));
     } else if (node.isSetter) {
       return new JS.Fun(
-          params, js.statement('{ this.# = #; }', [name, params.last]));
+          params, js.statement('{ this.# = #; }', [name, paramRefs.last]));
     } else {
       return new JS.Fun(
-          params, js.statement('{ return this.#(#); }', [name, params]));
+          params, js.statement('{ return this.#(#); }', [name, paramRefs]));
     }
   }
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract) {
       return null;
     }
 
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
+    var paramRefs = _emitParameterReferences(node.parameters);
 
     JS.Fun fn;
     if (_externalOrNative(node)) {
-      fn = _emitNativeFunctionBody(params, node);
+      fn = _emitNativeFunctionBody(params, paramRefs, node);
       // TODO(vsm): Remove if / when we handle the static case above.
       if (fn == null) return null;
     } else {
       var typeParams = _emitTypeParams(node.element).toList();
       var returnType = emitTypeRef(node.element.returnType);
-      fn = _emitFunctionBody(params, node.body, typeParams, returnType);
+      fn = _emitFunctionBody(
+          params, paramRefs, node.body, typeParams, returnType);
     }
 
     if (node.operatorKeyword != null &&
         node.name.name == '[]=' &&
         params.isNotEmpty) {
       // []= methods need to return the value. We could also address this at
       // call sites, but it's cleaner to instead transform the operator method.
       var returnValue = new JS.Return(params.last);
       var body = fn.body;
       if (JS.Return.foundIn(fn)) {
@@ skipping 158 matching lines @@
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
 
     var parent = node.parent;
     var inStmt = parent.parent is FunctionDeclarationStatement;
     var typeParams = _emitTypeParams(node.element).toList();
     var returnType = emitTypeRef(node.element.returnType);
     if (parent is FunctionDeclaration) {
-      return _emitFunctionBody(params, node.body, typeParams, returnType);
+      var paramRefs = _emitParameterReferences(node.parameters);
+      return _emitFunctionBody(
+          params, paramRefs, node.body, typeParams, returnType);
     } else {
       // Chrome Canary does not accept default values with destructuring in
       // arrow functions yet (e.g. `({a} = {}) => 1`) but happily accepts them
       // with regular functions (e.g. `function({a} = {}) { return 1 }`).
       // Note that Firefox accepts both syntaxes just fine.
       // TODO(ochafik): Simplify this code when Chrome Canary catches up.
       var canUseArrowFun = !node.parameters.parameters.any(_isNamedParam);
 
       JS.Node jsBody;
       var body = node.body;
       if (body.isGenerator || body.isAsynchronous) {
-        jsBody = _emitGeneratorFunctionBody(params, body, returnType);
+        var paramRefs = _emitParameterReferences(node.parameters);
+        jsBody = _emitGeneratorFunctionBody(
+            params, paramRefs, body, returnType);
       } else if (body is ExpressionFunctionBody) {
         jsBody = _visit(body.expression);
       } else {
         jsBody = _visit(body);
       }
       if (jsBody is JS.Expression && !canUseArrowFun) {
         jsBody = js.statement("{ return #; }", [jsBody]);
       }
       var clos = canUseArrowFun
           ? new JS.ArrowFun(params, jsBody,
               typeParams: typeParams, returnType: returnType)
           : new JS.Fun(params, jsBody,
               typeParams: typeParams, returnType: returnType);
       if (!inStmt) {
         var type = getStaticType(node);
         return _emitFunctionTagged(clos, type,
             topLevel: _executesAtTopLevel(node));
       }
       return clos;
     }
   }
 
-  JS.Fun _emitFunctionBody(List<JS.Parameter> params, FunctionBody body,
+  JS.Fun _emitFunctionBody(List<JS.Parameter> params,
+      List<JS.Expression> paramRefs, FunctionBody body,
       List<JS.Identifier> typeParams, JS.TypeRef returnType) {
     // sync*, async, async*
     if (body.isAsynchronous || body.isGenerator) {
+      // TODO(ochafik): Refine params: we don't need default values in the
+      // nested function, so we'd need to generate a custom, simpler params
+      // list here.
       return new JS.Fun(
           params,
-          js.statement('{ return #; }',
-              [_emitGeneratorFunctionBody(params, body, returnType)]),
+          js.statement('{ return #; }', [
+            _emitGeneratorFunctionBody(params, paramRefs, body, returnType)
+          ]),
           returnType: returnType);
     }
     // normal function (sync)
     return new JS.Fun(params, _visit(body),
         typeParams: typeParams, returnType: returnType);
   }
 
   JS.Expression _emitGeneratorFunctionBody(
-      List<JS.Parameter> params, FunctionBody body, JS.TypeRef returnType) {
+      List<JS.Parameter> params, List<JS.Expression> paramRefs,
+      FunctionBody body, JS.TypeRef returnType) {
     var kind = body.isSynchronous ? 'sync' : 'async';
     if (body.isGenerator) kind += 'Star';
 
     // Transforms `sync*` `async` and `async*` function bodies
     // using ES6 generators.
     //
     // `sync*` wraps a generator in a Dart Iterable<T>:
     //
     // function name(<args>) {
     //   return dart.syncStar(function*(<args>) {
@@ skipping 33 matching lines @@
     JS.Expression gen = new JS.Fun(jsParams, _visit(body),
         isGenerator: true, returnType: returnType);
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
     _asyncStarController = savedController;
 
     var T = _emitTypeName(_getExpectedReturnType(body));
     return js.call('dart.#(#)', [
       kind,
-      [gen, T]..addAll(params)
+      [gen, T]..addAll(paramRefs)
     ]);
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
@@ skipping 491 matching lines @@
         _propertyName(node.name.label.name), _visit(node.expression));
   }
 
   bool _isNamedParam(FormalParameter param) =>
       param.kind == ParameterKind.NAMED;
 
   @override
   List<JS.Parameter> visitFormalParameterList(FormalParameterList node) =>
       _emitFormalParameterList(node);
 
+  // TODO(ochafik): Decouple Parameter from Identifier.
+  List<JS.Expression> _emitParameterReferences(FormalParameterList node) =>
+      node == null
+      ? <JS.Expression>[]
+      : _emitFormalParameterList(node, allowDestructuring: false)
+          .map((JS.Parameter p) {
+            if (p is JS.RestParameter) return new JS.Spread(p.parameter);
+            return p as JS.Identifier;
+          })
+          .toList();
+
   List<JS.Parameter> _emitFormalParameterList(FormalParameterList node,
       {bool allowDestructuring: true}) {
     var result = <JS.Parameter>[];
 
     var namedVars = <JS.DestructuredVariable>[];
     var destructure = allowDestructuring && options.destructureNamedParams;
     var hasNamedArgsConflictingWithObjectProperties = false;
     var needsOpts = false;
 
     for (FormalParameter param in node.parameters) {
@@ skipping 14 matching lines @@
           namedVars.add(new JS.DestructuredVariable(
               name: name,
               structure: structure,
               defaultValue: _defaultParamValue(param)));
         } else {
           needsOpts = true;
         }
       } else {
         var jsParam = _visit(param);
         result.add(
-            param is DefaultFormalParameter && options.destructureNamedParams
+            param is DefaultFormalParameter && destructure
                 ? new JS.DestructuredVariable(
                     name: jsParam, defaultValue: _defaultParamValue(param))
                 : jsParam);
       }
     }
 
     if (needsOpts) {
       result.add(_namedArgTemp);
     } else if (namedVars.isNotEmpty) {
       // Note: `var {valueOf} = {}` extracts `Object.prototype.valueOf`, so
@@ skipping 1543 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }