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

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
@@ skipping 1380 matching lines @@
 }
 
 /**
  * A constructor that is not defined in the source code but rather implied by
  * the language semantics.
  *
  * This class is used to represent default constructors and forwarding
  * constructors for mixin applications.
  */
 class SynthesizedConstructorElementX extends FunctionElementX {
-  /// The target constructor if this synthetic constructor is a forwarding
-  /// constructor in a mixin application.
-  final FunctionElement target;
+  final FunctionElement superMember;
 
-  SynthesizedConstructorElementX(Element enclosing)
-      : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
-              Modifiers.EMPTY, enclosing),
-        target = null;
+  SynthesizedConstructorElementX(SourceString name,
+                                 this.superMember,
+                                 Element enclosing)
+      : super(name,
+              ElementKind.GENERATIVE_CONSTRUCTOR,
+              Modifiers.EMPTY,
+              enclosing);
 
-  SynthesizedConstructorElementX.forDefault(Element enclosing,
-                                            Compiler compiler)
-      : super(const SourceString(''), ElementKind.GENERATIVE_CONSTRUCTOR,
-              Modifiers.EMPTY, enclosing),
-        target = null {
-    // TODO(karlklose): get rid of the fake AST.
-    type = new FunctionType(this,
-        compiler.types.voidType,
-        const Link<DartType>(),
-        const Link<DartType>(),
-        const Link<SourceString>(),
-        const Link<DartType>());
-    cachedNode = new FunctionExpression(
-        new Identifier(enclosing.position()),
-        new NodeList.empty(),
-        new Block(new NodeList.empty()),
-        null, Modifiers.EMPTY, null, null);
-  }
-
-  /**
-   * Create synthetic constructor that directly forwards to a constructor in the
-   * super class of a mixin application.
-   *
-   * In a mixin application `Base with M`, any constructor defined in `Base` is
-   * available as if they were a constructor defined in the mixin application
-   * with the same formal parameters that calls the constructor in the super
-   * class via a `super` initializer (see Ch. 9.1 in the specification).
-   */
-  SynthesizedConstructorElementX.forwarding(SourceString name, this.target,
-                                            Element enclosing)
-    : super(name, ElementKind.GENERATIVE_CONSTRUCTOR, Modifiers.EMPTY,
-            enclosing);
+  SynthesizedConstructorElementX.forDefault(superMember, Element enclosing)
+      : this(const SourceString(''), superMember, enclosing);
 
   Token position() => enclosingElement.position();
 
   bool get isSynthesized => true;
 
-  bool get isForwardingConstructor => target != null;
-
-  FunctionElement get targetConstructor => target;
+  FunctionElement get targetConstructor => superMember;
 
   FunctionSignature computeSignature(compiler) {
-    if (target != null) {
-      return target.computeSignature(compiler);
-    } else {
-      assert(cachedNode != null);
-      return super.computeSignature(compiler);
+    if (superMember.isErroneous()) {
+      return compiler.objectClass.localLookup(
+          const SourceString('')).computeSignature(compiler);
     }
+    return superMember.computeSignature(compiler);
   }
 
   get declaration => this;
   get implementation => this;
   get defaultImplementation => this;
 }
 
 class VoidElementX extends ElementX {
   VoidElementX(Element enclosing)
       : super(const SourceString('void'), ElementKind.VOID, enclosing);
@@ skipping 129 matching lines @@
 
   Link<DartType> get typeVariables => thisType.typeArguments;
 
   ClassElement ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
     return this;
   }
 
-  void addDefaultConstructorIfNeeded(Compiler compiler) {
-    if (hasConstructor) return;
-    FunctionElement constructor =
-        new SynthesizedConstructorElementX.forDefault(this, compiler);
-    setDefaultConstructor(constructor, compiler);
-  }
-
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
 
   void addBackendMember(Element member) {
     // TODO(ngeoffray): Deprecate this method.
     assert(member.isGenerativeConstructorBody());
     backendMembers = backendMembers.prepend(member);
   }
 
   void reverseBackendMembers() {
     backendMembers = backendMembers.reverse();
@@ skipping 595 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }