avoid spread args

lib/src/compiler/code_generator.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 HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 538 matching lines @@
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
 
     // Forward all generative constructors from the base class.
     var methods = <JS.Method>[];
 
     var supertype = element.supertype;
     if (!supertype.isObject) {
       for (var ctor in element.constructors) {
         var parentCtor = supertype.lookUpConstructor(ctor.name, ctor.library);
-        var fun = js.call('function() { super.#(...arguments); }',
-            [_constructorName(parentCtor)]) as JS.Fun;
+        // TODO(jmesserly): this avoids spread args for perf. Revisit.
+        var jsParams = <JS.Identifier>[];
+        for (var p in ctor.parameters) {
+          if (p.parameterKind != ParameterKind.NAMED) {
+            jsParams.add(new JS.Identifier(p.name));
+          } else {
+            jsParams.add(new JS.TemporaryId('namedArgs'));
+            break;
+          }
+        }
+        var fun = js.call('function(#) { super.#(#); }',
+            [jsParams, _constructorName(parentCtor), jsParams]) as JS.Fun;
         methods.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
     var classExpr = _emitClassExpression(element, methods);
 
     var typeFormals = element.typeParameters;
     if (typeFormals.isNotEmpty) {
       return _defineClassTypeArguments(
           element, typeFormals, new JS.ClassDeclaration(classExpr));
@@ skipping 802 matching lines @@
       // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
       // settles. See <https://github.com/dart-lang/dev_compiler/issues/51>.
       // Performance of this pattern is likely to be bad.
       name = _propertyName('constructor');
       // Mark the parameter as no-rename.
       body = js.statement('''{
         // Get the class name for this instance.
         let name = this.constructor.name;
         // Call the default constructor.
         let result = void 0;
-        if (name in this) result = this[name](...arguments);
+        if (name in this) result = this[name].apply(this, arguments);
         return result === void 0 ? this : result;
       }''') as JS.Block;
     } else {
       var savedFunction = _currentFunction;
       _currentFunction = node.body;
       body = _emitConstructorBody(node, fields, virtualFields);
       _currentFunction = savedFunction;
     }
 
     // We generate constructors as initializer methods in the class;
@@ skipping 3034 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';