simplify constructors, fixes #564

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 736 matching lines @@
                     decl.name.name,
                     type: emitTypeRef(decl.element.type)),
                 null))
             .toList(growable: false));
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) {
     var element = node.element;
     var type = element.type;
-    var name = js.string(type.name);
 
     // Generate a class per section 13 of the spec.
     // TODO(vsm): Generate any accompanying metadata
 
     // Create constructor and initialize index
-    var constructor = new JS.Method(
-        name, js.call('function(index) { this.index = index; }') as JS.Fun);
+    var constructor = new JS.Method(_propertyName('new'),
+        js.call('function(index) { this.index = index; }') as JS.Fun);
     var fields = new List<FieldElement>.from(
         element.fields.where((f) => f.type == type));
 
     // Create toString() method
     var properties = new List<JS.Property>();
     for (var i = 0; i < fields.length; ++i) {
       properties.add(new JS.Property(
           js.number(i), js.string('${type.name}.${fields[i].name}')));
     }
     var nameMap = new JS.ObjectInitializer(properties, multiline: true);
@@ skipping 134 matching lines @@
       List<FieldDeclaration> fields,
       List<ClassElement> superclasses,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     var element = node.element;
     var type = element.type;
     var isObject = type.isObject;
 
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     var jsMethods = <JS.Method>[];
-    if (ctors.isEmpty && !isObject) {
+    if (isObject) {
+      // Implements Dart constructor behavior.
+      //
+      // Because of ES6 constructor restrictions (`this` is not available until
+      // `super` is called), we cannot emit an actual ES6 `constructor` on our
+      // classes and preserve the Dart initialization order.
+      //
+      // Instead we use the same trick as named constructors, and do them as
+      // instance methods that perform initialization.
+      //
+      // Therefore, dart:core Object gets the one real `constructor` and
+      // immediately bounces to the `new() { ... }` initializer, letting us
+      // bypass the ES6 restrictions.
+      //
+      // TODO(jmesserly): we'll need to rethink this.
+      // See <https://github.com/dart-lang/dev_compiler/issues/51>.
+      // This level of indirection will hurt performance.
+      jsMethods.add(new JS.Method(
+          _propertyName('constructor'),
+          js.call('function(...args) { return this.new.apply(this, args); }')
+          as JS.Fun));
+    } else if (ctors.isEmpty) {
       jsMethods.add(_emitImplicitConstructor(node, fields, virtualFields));
     }
 
     bool hasJsPeer = findAnnotation(element, isJsPeerInterface) != null;
 
     bool hasIterator = false;
     for (var m in node.members) {
       if (m is ConstructorDeclaration) {
         jsMethods
             .add(_emitConstructor(m, type, fields, virtualFields, isObject));
@@ skipping 180 matching lines @@
       body.add(
           js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
     }
   }
 
   void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
       List<JS.Statement> body, JS.Expression className) {
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
         body.add(js.statement('dart.defineNamedConstructor(#, #);',
-            [className, _emitMemberName(member.name.name, isStatic: true)]));
+            [className, _constructorName(member.element)]));
       }
     }
   }
 
   /// Emits static fields for a class, and initialize them eagerly if possible,
   /// otherwise define them as lazy properties.
   void _emitStaticFields(
       List<FieldDeclaration> staticFields,
       Set<FieldElement> staticFieldOverrides,
       ClassElement classElem,
@@ skipping 182 matching lines @@
   JS.Method _emitImplicitConstructor(
       ClassDeclaration node,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     assert(_hasUnnamedConstructor(node.element) == fields.isNotEmpty);
 
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
     if (fields.isEmpty && superCall == null) return null;
 
-    dynamic body = _initializeFields(node, fields, virtualFields);
+    var initFields = _initializeFields(node, fields, virtualFields);
+    List<JS.Statement> body = [initFields];
     if (superCall != null) {
-      body = [
-        [body, superCall]
-      ];
+      body.add(superCall);
     }
     var name = _constructorName(node.element.unnamedConstructor);
     return annotate(
-        new JS.Method(name, js.call('function() { #; }', body) as JS.Fun),
+        new JS.Method(name, js.call('function() { #; }', [body]) as JS.Fun),
         node,
         node.element);
   }
 
   JS.Method _emitConstructor(
       ConstructorDeclaration node,
       InterfaceType type,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields,
       bool isObject) {
@@ skipping 33 matching lines @@
       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(params, new JS.Block(body), returnType: returnType);
       return annotate(
           new JS.Method(name, fun, isStatic: true), node, node.element);
     }
 
     // Code generation for Object's constructor.
-    JS.Block body;
-    if (isObject &&
-        node.body is EmptyFunctionBody &&
-        node.constKeyword != null &&
-        node.name == null) {
-      // Implements Dart constructor behavior. Because of V8 `super`
-      // [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.
-      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].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;
-    }
+    var savedFunction = _currentFunction;
+    _currentFunction = node.body;
+    var body = _emitConstructorBody(node, fields, virtualFields);
+    _currentFunction = savedFunction;
 
     // 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(params, body, returnType: returnType)),
         node,
         node.element);
   }
 
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
-    if (name != '') {
-      return _emitMemberName(name, isStatic: true);
+    if (name == '') {
+      // Default constructors (factory or not) use `new` as their name.
+      return _propertyName('new');
     }
-
-    // Factory default constructors use `new` as their name, for readability
-    // Other default constructors use the class name, as they aren't called
-    // from call sites, but rather from Object's constructor.
-    // TODO(jmesserly): revisit in the context of Dart metaclasses, and cleaning
-    // up constructors to integrate more closely with ES6.
-    return _propertyName(ctor.isFactory ? 'new' : ctor.enclosingElement.name);
+    return _emitMemberName(name, isStatic: true);
   }
 
   JS.Block _emitConstructorBody(
       ConstructorDeclaration node,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     var body = <JS.Statement>[];
     ClassDeclaration cls = node.parent;
 
     // Generate optional/named argument value assignment. These can not have
@@ skipping 33 matching lines @@
     var jsSuper = _superConstructorCall(cls.element, superCall);
     if (jsSuper != null) body.add(jsSuper);
 
     body.add(_visit(node.body));
     return new JS.Block(body)..sourceInformation = node;
   }
 
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
-    var name = _constructorName(node.staticElement);
-    return js.statement('this.#(#);', [name, _visit(node.argumentList)]);
+    var ctor = node.staticElement;
+    var cls = ctor.enclosingElement as ClassElement;
+    // We can't dispatch to the constructor with `this.new` as that might hit a
+    // derived class constructor with the same name.
+    return js.statement('#.prototype.#.call(this, #);', [
+      new JS.Identifier(cls.name),
+      _constructorName(ctor),
+      _visit(node.argumentList)
+    ]);
   }
 
   JS.Statement _superConstructorCall(ClassElement element,
       [SuperConstructorInvocation node]) {
+    if (element.supertype == null) {
+      assert(element.type.isObject || options.unsafeForceCompile);
+      return null;
+    }
+
     ConstructorElement superCtor;
     if (node != null) {
       superCtor = node.staticElement;
     } else {
       // Get the supertype's unnamed constructor.
       superCtor = element.supertype.element.unnamedConstructor;
-      if (superCtor == null) {
-        // This will only happen if the code has errors:
-        // we're trying to generate an implicit constructor for a type where
-        // we don't have a default constructor in the supertype.
-        assert(options.unsafeForceCompile);
-        return null;
-      }
     }
 
     if (superCtor == null) {
-      print('Error generating: ${element.displayName}');
+      // This will only happen if the code has errors:
+      // we're trying to generate an implicit constructor for a type where
+      // we don't have a default constructor in the supertype.
+      assert(options.unsafeForceCompile);
+      return null;
     }
+
     if (superCtor.name == '' && !_shouldCallUnnamedSuperCtor(element)) {
       return null;
     }
 
     var name = _constructorName(superCtor);
     var args = node != null ? _visit(node.argumentList) : [];
     return annotate(js.statement('super.#(#);', [name, args]), node);
   }
 
   bool _shouldCallUnnamedSuperCtor(ClassElement e) {
@@ skipping 1540 matching lines @@
 
   JS.Expression _emitInstanceCreationExpression(
       ConstructorElement element,
       DartType type,
       SimpleIdentifier name,
       ArgumentList argumentList,
       bool isConst) {
     JS.Expression emitNew() {
       JS.Expression ctor;
       bool isFactory = false;
-      // var element = node.staticElement;
       if (element == null) {
         // TODO(jmesserly): this only happens if we had a static error.
         // Should we generate a throw instead?
         ctor = _emitType(type);
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
@@ skipping 1412 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';