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 1270 matching lines @@
         new NodeList.empty(),
         new Block(new NodeList.empty()),
         null, Modifiers.EMPTY, null, null);
   }
 
   bool get isSynthesized => true;
 
   Token position() => enclosingElement.position();
 }
 
+/**
+ * A 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 language specification).
+ */
+class ForwardingConstructorElementX extends FunctionElementX
+                                    implements ForwardingConstructorElement {
+  final FunctionElement superConstructor;
+
+  ForwardingConstructorElementX(SourceString name,
+                                FunctionElement superConstructor,
+                                Element enclosing)
+    : super(name, superConstructor.kind, superConstructor.modifiers, enclosing),
+      this.superConstructor = superConstructor;
+
+  parseNode(compiler) { throw 'parseNode in synthetic constructor forward.'; }

[ahe, 2013/04/15 13:36:46]

compiler.internalErrorOnElement

[karlklose, 2013/04/25 11:25:53]

Removed.

+
+  get declaration => this;
+
+  get implementation => this;
+
+  get defaultImplementation => this;
+
+  FunctionSignature computeSignature(compiler) {
+    return superConstructor.computeSignature(compiler);
+  }
+
+  Token position() => superConstructor.position();

[ahe, 2013/04/15 13:36:46]

I'm not sure this is a good position.  Wouldn't the enclosing class be better?

[karlklose, 2013/04/25 11:25:53]

Removed.

+
+  get redirectionTarget => superConstructor.redirectionTarget;
+
+  bool get isSynthesized => true;
+}
+
 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 529 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;
 
   Element localLookup(SourceString name) {
-    if (this.name == name) return constructor;
+    for (Link<Element> link = constructors;
+         !link.isEmpty;
+         link = link.tail) {
+      if (link.head.name == name) return link.head;
+    }
     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)) {
     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");
+    if (!element.isConstructor()) {
+      listener.cancel('can only add constructors to mixin application scope,'

[ahe, 2013/04/15 13:36:46]

Please emit a proper error instead of calling cancel.

[karlklose, 2013/04/25 11:25:53]

Done.

+                      ' but got $element', element: this);
+    }
+    constructors = constructors.prepend(element);
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     assert(!hasConstructor);
-    this.constructor = constructor;
+    addToScope(constructor, compiler);
   }
 
   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)';
 }