Get the most basic mixin applications working.

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 'elements.dart';
 import '../../compiler.dart' as api;
@@ skipping 1352 matching lines @@
   ClassElement get patch => super.patch;
   ClassElement get origin => super.origin;
   ClassElement get declaration => super.declaration;
   ClassElement get implementation => super.implementation;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   InterfaceType computeType(compiler) {
     if (thisType == null) {
       if (origin == null) {
-        ClassNode node = parseNode(compiler);
-        Link<DartType> parameters =
-            TypeDeclarationElementX.createTypeVariables(this,
-                                                        node.typeParameters);
+        Link<DartType> parameters = const Link<DartType>();
+        // TODO(kasperl): Figure out how to get the type parameters
+        // for a mixin application.
+        if (!isMixinApplication) {
+          ClassNode node = parseNode(compiler);
+          parameters = TypeDeclarationElementX.createTypeVariables(
+              this, node.typeParameters);
+        }
         thisType = new InterfaceType(this, parameters);
         if (parameters.isEmpty) {
           rawType = thisType;
         } else {
           var dynamicParameters = const Link<DartType>();
           parameters.forEach((_) {
             dynamicParameters =
                 dynamicParameters.prepend(compiler.types.dynamicType);
           });
           rawType = new InterfaceType(this, dynamicParameters);
         }
       } else {
         thisType = origin.computeType(compiler);
         rawType = origin.rawType;
       }
     }
     return thisType;
   }
 
   /**
    * Return [:true:] if this element is the [:Object:] class for the [compiler].
    */
   bool isObject(Compiler compiler) =>
       identical(declaration, compiler.objectClass);
 
   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) {
     backendMembers = backendMembers.prepend(member);
   }
 
   void reverseBackendMembers() {
     backendMembers = backendMembers.reverse();
   }
 
   /**
    * Lookup local members in the class. This will ignore constructors.
@@ skipping 272 matching lines @@
     return false;
   }
 
   bool isInterface() => false;
   bool isNative() => nativeTagInfo != null;
   void setNative(String name) {
     nativeTagInfo = new SourceString(name);
   }
 }
 
-
 abstract class ClassElementX extends BaseClassElementX {
   // Lazily applied patch of class members.
   ClassElement patch = null;
   ClassElement origin = null;
 
   Link<Element> localMembers = const Link<Element>();
   final ScopeX localScope = new ScopeX();
 
   ClassElementX(SourceString name, Element enclosing, int id, int initialState)
       : super(name, enclosing, id, initialState);
 
   ClassNode parseNode(Compiler compiler);
 
+  bool get isMixinApplication => false;
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
   bool get hasLocalScopeMembers => !localScope.isEmpty;
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
@@ skipping 13 matching lines @@
   }
 
   bool get hasConstructor {
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.values) {
       if (element.isConstructor()) return true;
     }
     return false;
   }
 
-  ClassElement ensureResolved(Compiler compiler) {
-    if (resolutionState == STATE_NOT_STARTED) {
-      compiler.resolver.resolveClass(this);
-    }
-    return this;
+  void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
+    addToScope(constructor, compiler);
   }
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
   String toString() {
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
 
 class MixinApplicationElementX extends BaseClassElementX {
   final MixinApplication cachedNode;
 
+  FunctionElement constructor;
+  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.cachedNode)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
-  bool get hasConstructor => false;
+  bool get isMixinApplication => true;
+  bool get hasConstructor => constructor != null;
   bool get hasLocalScopeMembers => false;
 
   Token position() => cachedNode.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => cachedNode;
 
-  ClassElement ensureResolved(Compiler compiler) {
-    if (resolutionState == STATE_NOT_STARTED) {
-      compiler.resolver.resolveMixinApplication(this);
-    }
-    return this;
-  }
-
   Element localLookup(SourceString name) {
-    // TODO(kasperl): Unimplemented for now.
-    return null;
+    if (this.name == name) return constructor;
+    if (mixin != null) return mixin.localLookup(name);
   }
 
   void forEachLocalMember(void f(Element member)) {
-    // TODO(kasperl): Unimplemented for now.
+    if (mixin != null) mixin.forEachLocalMember(f);
   }
 
   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");
   }
+
+  void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
+    assert(!hasConstructor);
+    this.constructor = constructor;
+  }
 }
 
 class LabelElementX extends ElementX implements LabelElement {
 
   // We store the original label here so it can be returned by [parseNode].
   final Label label;
   final String labelName;
   final TargetElement target;
   bool isBreakTarget = false;
   bool isContinueTarget = false;
@@ skipping 115 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }