Implement implicit constructors in mixin applications.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 290 matching lines @@
         if (isConstructor) {
           if (tree.returnType != null) {
             error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
           }
           resolveConstructorImplementation(element, tree);
         }
         ResolverVisitor visitor = visitorFor(element);
         visitor.useElement(tree, element);
         visitor.setupFunction(tree, element);
 
-        if (isConstructor) {
+        if (isConstructor && !element.isForwardingConstructor) {
           // Even if there is no initializer list we still have to do the
           // resolution in case there is an implicit super constructor call.
           InitializerResolver resolver = new InitializerResolver(visitor);
           FunctionElement redirection =
               resolver.resolveInitializers(element, tree);
           if (redirection != null) {
             resolveRedirectingConstructor(resolver, tree, element, redirection);
           }
+        } else if (element.isForwardingConstructor) {
+          // Initializers will be checked on the original constructor.
         } else if (tree.initializers != null) {
           error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
         }
         visitBody(visitor, tree.body);
 
         // Get the resolution tree and check that the resolved
         // function doesn't use 'super' if it is mixed into another
         // class. This is the part of the 'super' mixin check that
         // happens when a function is resolved after the mixin
         // application has been performed.
@@ skipping 2238 matching lines @@
     resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
     compiler.withCurrentElement(constructor, () {
-      FunctionExpression tree = constructor.parseNode(compiler);
+      FunctionElement target = constructor;
+      if (constructor.isForwardingConstructor) {
+        target = constructor.targetConstructor;
+      }
+      FunctionExpression tree = target.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
 
     if (constructor.defaultImplementation != constructor) {
       // Support for deprecated interface support.
       // TODO(ngeoffray): Remove once we remove such support.
       world.registerStaticUse(constructor.declaration);
       world.registerInstantiatedClass(
           constructor.getEnclosingClass().declaration, mapping);
       constructor = constructor.defaultImplementation;
@@ skipping 683 matching lines @@
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
         element.parseNode(compiler),
         Modifiers.EMPTY);  // TODO(kasperl): Should this be abstract?
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
+  bool isDefaultConstructor(FunctionElement constructor) {
+    return constructor.name == constructor.getEnclosingClass().name &&
+        constructor.computeSignature(compiler).parameterCount == 0;
+  }
+
+  FunctionElement createForwardingConstructor(FunctionElement constructor,
+                                              ClassElement target) {
+    ClassElement cls = constructor.getEnclosingClass();
+    SourceString constructorName;
+    if (constructor.name == cls.name) {
+      constructorName = target.name;
+    } else {
+      SourceString selector =
+          Elements.deconstructConstructorName(constructor.name, cls);
+      constructorName =
+          Elements.constructConstructorName(target.name, selector);
+    }
+    return new SynthesizedConstructorElementX.forwarding(constructorName,
+                                                         constructor,
+                                                         target);
+  }
+
   void doApplyMixinTo(MixinApplicationElement mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     assert(mixinApplication.supertype == null);
     mixinApplication.supertype = supertype;
 
+    Node node = mixinApplication.parseNode(compiler);
     // Named mixin application may have an 'implements' clause.
     NamedMixinApplication namedMixinApplication =
-        mixinApplication.parseNode(compiler).asNamedMixinApplication();
+        node.asNamedMixinApplication();
     Link<DartType> interfaces = (namedMixinApplication != null)
         ? resolveInterfaces(namedMixinApplication.interfaces,
                             namedMixinApplication.superclass)
         : const Link<DartType>();
 
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in so always prepend
     // that to the interface list.
     interfaces = interfaces.prepend(mixinType);
     assert(mixinApplication.interfaces == null);
     mixinApplication.interfaces = interfaces;
 
     assert(mixinApplication.mixin == null);
     mixinApplication.mixin = resolveMixinFor(mixinApplication, mixinType);
+
+    // Create forwarding constructors for constructor defined in the superclass
+    // because they are now hidden by the mixin application.
+    ClassElement superclass = supertype.element;
+    superclass.forEachLocalMember((Element member) {
+      if (!member.isConstructor()) return;
+      if (member.isSynthesized && !member.isForwardingConstructor) return;
+      if (isDefaultConstructor(member)) return;
+      assert(invariant(node, !member.isFactoryConstructor(),
+             message: 'mixins cannot have factory constructors'));
+      // Skip forwarding constructors and use their target.
+      FunctionElement constructor =
+          member.isForwardingConstructor ? member.targetConstructor : member;
+      assert(invariant(node, !constructor.isForwardingConstructor));
+      FunctionElement forwarder =
+          createForwardingConstructor(constructor, mixinApplication);
+      mixinApplication.addConstructor(forwarder);
+    });
     mixinApplication.addDefaultConstructorIfNeeded(compiler);
     calculateAllSupertypes(mixinApplication);
   }
 
   ClassElement resolveMixinFor(MixinApplicationElement mixinApplication,
                                DartType mixinType) {
     ClassElement mixin = mixinType.element;
     mixin.ensureResolved(compiler);
 
     // Check for cycles in the mixin chain.
@@ skipping 686 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }