fixes #232, handling of arguments

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 dev_compiler.src.codegen.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 319 matching lines @@
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     var element = node.element;
 
     // Forward all generative constructors from the base class.
     var body = [];
 
     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.#(...#); }', [
-          _constructorName(parentCtor),
-          new JS.Identifier('arguments', allowRename: false)
-        ]);
+        var fun = js.call('function() { super.#(...arguments); }',
+            [_constructorName(parentCtor)]);
         body.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
     var classDecl = new JS.ClassDeclaration(new JS.ClassExpression(
         new JS.Identifier(element.name), _classHeritage(element), body));
 
     return _finishClassDef(element.type, classDecl);
   }
 
@@ skipping 484 matching lines @@
       // [constructor restrictions]
       // (https://code.google.com/p/v8/issues/detail?id=3330#c65)
       // we cannot currently emit actual ES6 constructors with super calls.
       // Instead we use the same trick as named constructors, and do them as
       // instance methods that perform initialization.
       // 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.
-      var args = new JS.Identifier('arguments', allowRename: false);
       body = js.statement('''{
         // Get the class name for this instance.
         let name = this.constructor.name;
         // Call the default constructor.
-        let init = this[name];
         let result = void 0;
-        if (init) result = init.apply(this, #);
+        if (name in this) result = this[name](...arguments);

[vsm, 2015/06/23 19:58:27]

Shouldn't this be something like:

if (this.__proto__.hasOwnProperty(name)) ....

?

I think we'd handle the following wrong otherwise:

class Base {
  Derived() => print("This shouldn't be called");
}

class Derived extends Base {}

main() => print(new Derived());

[Jennifer Messerly, 2015/06/23 20:08:35]

the problem, if it repros, already exists in old code. The solution would be to
make sure initialize method is generated in that case (it might already be. not
sure), and/or rename it (e.g. a dart.initialize symbol). I'd hate to need a
hasOwnProperty check here... that would probably add more overhead to this
already-crazy code path. Fortunately we have a few issues tracking cleanup here.

anyway, I can revert this if you want, just figured it would be nice to use
spread instead of .apply. I definitely don't want to get into the business of
fixing constructors in this CL, though :)

         return result === void 0 ? this : result;
-      }''', args);
+      }''');
     } 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 new JS.Method(name, new JS.Fun(_visit(node.parameters), body))
       ..sourceInformation = node;
   }
@@ skipping 1934 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);
 }