Rewrite how we handle synthesized constructors in the compiler. This was motivated by issue https:/…

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 321 matching lines @@
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       bool isConstructor =
           identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR);
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (elements != null) {
         assert(isConstructor);
         return elements;
       }
+      if (element.isSynthesized) {
+        Element target = element.targetConstructor;
+        if (!target.isErroneous()) {
+          compiler.enqueuer.resolution.registerStaticUse(
+              element.targetConstructor);
+        }
+        return new TreeElementMapping(element);
+      }
       if (element.isPatched) {
         checkMatchingPatchSignatures(element, element.patch);
         element = element.patch;
       }
       return compiler.withCurrentElement(element, () {
         FunctionExpression tree = element.parseNode(compiler);
         if (tree.modifiers.isExternal()) {
           error(tree, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
           return;
         }
@@ skipping 2177 matching lines @@
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
     // TODO(ahe): Check that this doesn't lead to a cycle.  For now,
     // just make sure that the redirection target isn't itself a
     // redirecting factory.
     { // This entire block is temporary code per the above TODO.
       FunctionElement targetImplementation = redirectionTarget.implementation;
       FunctionExpression function = targetImplementation.parseNode(compiler);
-      if (function.body != null && function.body.asReturn() != null
+      if (function != null
+          && function.body != null
+          && function.body.asReturn() != null
           && function.body.asReturn().isRedirectingFactoryBody) {
         unimplemented(node.expression, 'redirecting to redirecting factory');
       }
     }
     world.registerStaticUse(redirectionTarget);
     world.registerInstantiatedClass(
         redirectionTarget.enclosingElement.declaration, mapping);
     if (isSymbolConstructor) {
       // Make sure that collection_dev.Symbol.validated is registered.
       assert(invariant(node, compiler.symbolValidatedConstructor != null));
@@ skipping 716 matching lines @@
           superElement.ensureResolved(compiler);
         }
         element.supertype = superElement.computeType(compiler);
       }
     }
 
     assert(element.interfaces == null);
     element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     calculateAllSupertypes(element);
 
-    element.addDefaultConstructorIfNeeded(compiler);
+    if (!element.hasConstructor) {
+      Element superMember =
+          element.superclass.localLookup(const SourceString(''));
+      if (superMember == null || !superMember.isGenerativeConstructor()) {
+        MessageKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
+        Map arguments = {'constructorName': const SourceString('')};
+        compiler.reportErrorCode(node, kind, arguments);
+        superMember = new ErroneousElementX(
+            kind, arguments, const SourceString(''), element);
+        compiler.backend.registerThrowNoSuchMethod(mapping);
+      }
+      FunctionElement constructor =
+          new SynthesizedConstructorElementX.forDefault(superMember, element);
+      element.setDefaultConstructor(constructor, compiler);
+    }
     return element.computeType(compiler);
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     compiler.ensure(element != null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
@@ skipping 23 matching lines @@
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
     return constructor.name == const SourceString('') &&
         constructor.computeSignature(compiler).parameterCount == 0;
   }
 
-  FunctionElement createForwardingConstructor(FunctionElement constructor,
-                                              ClassElement target) {
-    return new SynthesizedConstructorElementX.forwarding(constructor.name,
-                                                         constructor,
-                                                         target);
+  FunctionElement createForwardingConstructor(FunctionElement target,
+                                              ClassElement enclosing) {
+    return new SynthesizedConstructorElementX(target.name,
+                                              target,
+                                              enclosing);
   }
 
   void doApplyMixinTo(MixinApplicationElement mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     Node node = mixinApplication.parseNode(compiler);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
       assert(invariant(node, compiler.compilationFailed));
@@ skipping 18 matching lines @@
     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));
+      if (!member.isGenerativeConstructor()) return;
       FunctionElement forwarder =
-          createForwardingConstructor(constructor, mixinApplication);
+          createForwardingConstructor(member, 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.
     ClassElement previous = mixinApplication;  // For better error messages.
@@ skipping 668 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }