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 2228 matching lines @@
     resolveSelector(node.send);
     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 @@
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
   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() || member.isSynthesized) return;

[kasperl, 2013/04/25 12:13:12]

Does this work if the superclass itself is a mixin application? Do you have a
test for that?

   class S { S.foo(); }
   class M1 { }
   class M2 { }
   class C extends S with M1, M2 { 
     C.foo() : super.foo();
   }

   main() {
     new C.foo();
   }

[karlklose, 2013/05/03 09:35:45]

I change it to work with these.

+      assert(invariant(node, !member.isFactoryConstructor(),
+             message: 'mixins cannot have factory constructors'));
+      FunctionElement constructor = member;
+      SourceString constructorName;

[kasperl, 2013/04/25 12:13:12]

Add a helper for computing the constructor name? ... and maybe a helper for
creating the forwarding constructor too?

That way, this loop becomes much more readable. Run through all the super class
constructors and create forwarders for them.

[karlklose, 2013/05/03 09:35:45]

I created a method to create the forwarding constructor.

+      if (constructor.name == superclass.name) {
+        if (constructor.computeSignature(compiler).parameterCount == 0) {
+          return;
+        }
+        constructorName = mixinApplication.name;
+      } else {
+        SourceString selector =
+            Elements.deconstructConstructorName(constructor.name, superclass);
+        constructorName =
+            Elements.constructConstructorName(mixinApplication.name, selector);
+      }
+      Element forwarder =
+          new SynthesizedConstructorElementX.forwarding(constructorName,
+              constructor, mixinApplication);
+      mixinApplication.addToScope(forwarder, compiler);

[kasperl, 2013/04/25 12:13:12]

I'd rather have a method for adding a new constructor to a mixin application.

[karlklose, 2013/05/03 09:35:45]

Done.

+    });
     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 678 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }