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

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.
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 945 matching lines @@
       var params =
           _emitFormalParameterList(node.parameters, allowDestructuring: false);
 
       var fun = js.call('function(#) { return $newKeyword #(#); }',
           [params, _visit(redirect), params]) as JS.Fun;
       return annotate(
           new JS.Method(name, fun, isStatic: true)..sourceInformation = node,
           node.element);
     }
 
+    // For const constructors we need to ensure default values are
+    // available for use by top-level constant initializers.
+    ClassDeclaration cls = node.parent;
+    if (node.constKeyword != null) _loader.startTopLevel(cls.element);
+    var params = _emitFormalParameterList(node.parameters);
+    if (node.constKeyword != null) _loader.finishTopLevel(cls.element);
+
     // Factory constructors are essentially static methods.
     if (node.factoryKeyword != null) {
       var body = <JS.Statement>[];
       var init = _emitArgumentInitializers(node, constructor: true);
       if (init != null) body.add(init);
       body.add(_visit(node.body));
-      var fun = new JS.Fun(
-          _visit(node.parameters) as List<JS.Parameter>, new JS.Block(body));
+      var fun = new JS.Fun(params, new JS.Block(body));
       return annotate(
           new JS.Method(name, fun, isStatic: true)..sourceInformation = node,
           node.element);
     }
 
     // Code generation for Object's constructor.
     JS.Block body;
     if (isObject &&
         node.body is EmptyFunctionBody &&
         node.constKeyword != null &&
@@ skipping 18 matching lines @@
         return result === void 0 ? this : result;
       }''') as JS.Block;
     } else {
       body = _emitConstructorBody(node, fields);
     }
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
     return annotate(
-        new JS.Method(name,
-            new JS.Fun(_visit(node.parameters) as List<JS.Parameter>, body))
-          ..sourceInformation = node,
+        new JS.Method(name, new JS.Fun(params, body))..sourceInformation = node,
         node.element);
   }
 
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
     if (name != '') {
       return _emitMemberName(name, isStatic: true);
     }
 
     // Factory default constructors use `new` as their name, for readability
@@ skipping 189 matching lines @@
     if (node is ConstructorDeclaration != constructor) return null;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
       var jsParam = _visit(param.identifier);
 
       if (param.kind == ParameterKind.NAMED) {
-        if (!_isDestructurableNamedParam(param)) {
+        if (!options.destructureNamedParams) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
 
           // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
           body.add(js.statement('let # = # && # in # ? #.# : #;', [
             jsParam,
             _namedArgTemp,
             paramName,
             _namedArgTemp,
             _namedArgTemp,
             paramName,
             _defaultParamValue(param),
           ]));
         }
-      } else if (param.kind == ParameterKind.POSITIONAL) {
+      } else if (param.kind == ParameterKind.POSITIONAL &&
+          !options.destructureNamedParams) {
         body.add(js.statement('if (# === void 0) # = #;',
             [jsParam, jsParam, _defaultParamValue(param)]));
       }
 
       // TODO(jmesserly): various problems here, see:
       // https://github.com/dart-lang/dev_compiler/issues/161
       var paramType = param.element.type;
       if (!constructor && _hasUnsoundTypeParameter(paramType)) {
         body.add(js
             .statement('dart.as(#, #);', [jsParam, _emitTypeName(paramType)]));
@@ skipping 786 matching lines @@
   @override
   JS.Property visitNamedExpression(NamedExpression node) {
     assert(node.parent is ArgumentList);
     return new JS.Property(
         _propertyName(node.name.label.name), _visit(node.expression));
   }
 
   bool _isNamedParam(FormalParameter param) =>
       param.kind == ParameterKind.NAMED;
 
-  /// We cannot destructure named params that clash with JS reserved names:
-  /// see discussion in https://github.com/dart-lang/dev_compiler/issues/392.
-  bool _isDestructurableNamedParam(FormalParameter param) =>
-      _isNamedParam(param) &&
-      !invalidVariableName(param.identifier.name) &&
-      options.destructureNamedParams;
-
   @override
   List<JS.Parameter> visitFormalParameterList(FormalParameterList node) =>
       _emitFormalParameterList(node);
 
   List<JS.Parameter> _emitFormalParameterList(FormalParameterList node,
       {bool allowDestructuring: true}) {
     var result = <JS.Parameter>[];
 
     var namedVars = <JS.DestructuredVariable>[];
-    var destructure = allowDestructuring &&
-        node.parameters.where(_isNamedParam).every(_isDestructurableNamedParam);
+    var destructure = allowDestructuring && options.destructureNamedParams;
     var hasNamedArgsConflictingWithObjectProperties = false;
     var needsOpts = false;
 
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
         if (destructure) {
           if (_jsObjectProperties.contains(param.identifier.name)) {
             hasNamedArgsConflictingWithObjectProperties = true;
           }
+          JS.Expression name;
+          JS.SimpleBindingPattern structure = null;
+          String paramName = param.identifier.name;
+          if (invalidVariableName(paramName)) {
+            name = js.string(paramName);
+            structure = new JS.SimpleBindingPattern(_visit(param.identifier));
+          } else {
+            name = _visit(param.identifier);
+          }
           namedVars.add(new JS.DestructuredVariable(
-              name: _visit(param.identifier),
+              name: name,
+              structure: structure,
               defaultValue: _defaultParamValue(param)));
         } else {
           needsOpts = true;
         }
       } else {
-        result.add(_visit(param));
+        var jsParam = _visit(param);
+        result.add(
+            param is DefaultFormalParameter && options.destructureNamedParams
+                ? 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
       // in case there are conflicting names we create an object without
       // any prototype.
       var defaultOpts = hasNamedArgsConflictingWithObjectProperties
@@ skipping 1520 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);
 }