Implement implicit constructors in mixin applications.

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:uri';
 import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
@@ skipping 114 matching lines @@
 
   /**
    * Is [:true:] if this element introduces the entity of this element.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   bool get isDeclaration => !isPatch;
 
   bool get isSynthesized => false;
 
+  bool get isForwardingConstructor => false;
+
   /**
    * Returns the element which defines the implementation for the entity of this
    * element.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   Element get implementation => isPatched ? patch : this;
 
   /**
    * Returns the element which introduces the entity of this element.
@@ skipping 118 matching lines @@
   void setFixedBackendName(String name) {
     _fixedBackendName = name;
   }
 
   FunctionElement asFunctionElement() => null;
 
   static bool isInvalid(Element e) => e == null || e.isErroneous();
 
   bool isAbstract(Compiler compiler) => modifiers.isAbstract();
   bool isForeign(Compiler compiler) => getLibrary() == compiler.foreignLibrary;
+
+  FunctionElement get targetConstructor => null;
 }
 
 /**
  * Represents an unresolvable or duplicated element.
  *
  * An [ErroneousElement] is used instead of [null] to provide additional
  * information about the error that caused the element to be unresolvable
  * or otherwise invalid.
  *
  * Accessing any field or calling any method defined on [ErroneousElement]
@@ skipping 974 matching lines @@
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode != null);
     return cachedNode;
   }
 
   Token position() => constructor.position();
 }
 
+/**
+ * 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;
+
   SynthesizedConstructorElementX(Element enclosing)
-    : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
-            Modifiers.EMPTY, enclosing);
+      : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
+              Modifiers.EMPTY, enclosing),
+        target = null;
 
   SynthesizedConstructorElementX.forDefault(Element enclosing,
                                             Compiler compiler)
-    : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
-            Modifiers.EMPTY, enclosing) {
+      : super(enclosing.name, 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);
+
+  Token position() => enclosingElement.position();
+
   bool get isSynthesized => true;
 
-  Token position() => enclosingElement.position();
+  bool get isForwardingConstructor => target != null;
+
+  FunctionElement get targetConstructor => target;
+
+  FunctionSignature computeSignature(compiler) {
+    if (target != null) {
+      return target.computeSignature(compiler);
+    } else {
+      assert(cachedNode != null);
+      return super.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);
   DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
   bool impliesType() => true;
@@ skipping 531 matching lines @@
       return super.toString();
     }
   }
 }
 
 class MixinApplicationElementX extends BaseClassElementX
     implements MixinApplicationElement {
   final Node node;
   final Modifiers modifiers;
 
-  FunctionElement constructor;
+  Link<FunctionElement> constructors = new Link<FunctionElement>();
+
   ClassElement mixin;
 
   // TODO(kasperl): The analyzer complains when I don't have these two
   // fields. This is pretty weird. I cannot replace them with getters.
   final ClassElement patch = null;
   final ClassElement origin = null;
 
   MixinApplicationElementX(SourceString name, Element enclosing, int id,
                            this.node, this.modifiers)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
   bool get isMixinApplication => true;
-  bool get hasConstructor => constructor != null;
-  bool get hasLocalScopeMembers => false;
+  bool get hasConstructor => !constructors.isEmpty;
+  bool get hasLocalScopeMembers => !constructors.isEmpty;
 
   Token position() => node.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => node;
 
+  FunctionElement lookupLocalConstructor(SourceString name) {
+    for (Link<Element> link = constructors;
+         !link.isEmpty;
+         link = link.tail) {
+      if (link.head.name == name) return link.head;
+    }
+    return null;
+  }
+
   Element localLookup(SourceString name) {
-    if (this.name == name) return constructor;
+    Element constructor = lookupLocalConstructor(name);
+    if (constructor != null) return constructor;
     if (mixin == null) return null;
     Element mixedInElement = mixin.localLookup(name);
     if (mixedInElement == null) return null;
     return mixedInElement.isInstanceMember() ? mixedInElement : null;
   }
 
   void forEachLocalMember(void f(Element member)) {
+    constructors.forEach(f);
     if (mixin != null) mixin.forEachLocalMember((Element mixedInElement) {
       if (mixedInElement.isInstanceMember()) f(mixedInElement);
     });
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     throw new UnsupportedError("cannot add member to $this");
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
-    throw new UnsupportedError("cannot add to scope of $this");
+    listener.internalError('cannot add to scope of $this', element: this);
+  }
+
+  void addConstructor(FunctionElement constructor) {
+    constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     assert(!hasConstructor);
-    this.constructor = constructor;
+    addConstructor(constructor);
   }
 
   Link<DartType> computeTypeParameters(Compiler compiler) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) return const Link<DartType>();
     return TypeDeclarationElementX.createTypeVariables(
         this, named.typeParameters);
   }
 }
 
@@ skipping 121 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }