Start allowing mixin application extensions.

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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 2719 matching lines @@
     compiler.ensure(element != null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
-    // Resolve super type and deal with the Object class nicely.
-    element.supertype = resolveSupertype(element, node.superclass);
+    // Setup the supertype for the element.
+    assert(element.supertype == null);
+    if (node.superclass != null) {
+      MixinApplication superMixin = node.superclass.asMixinApplication();
+      if (superMixin != null) {
+        DartType supertype = resolveSupertype(element, superMixin.superclass);
+        Link<Node> link = superMixin.mixins.nodes;
+        while (!link.isEmpty) {
+          supertype = applyMixin(supertype, visit(link.head));
+          link = link.tail;
+        }
+        element.supertype = supertype;
+      } else {
+        element.supertype = resolveSupertype(element, node.superclass);
+      }
+    }
+
+    // If the super type isn't specified, we make it Object.
     final objectElement = compiler.objectClass;
     if (!identical(element, objectElement) && element.supertype == null) {
       if (objectElement == null) {
         compiler.internalError("Internal error: cannot resolve Object",
                                node: node);
       } else {
         objectElement.ensureResolved(compiler);
       }
       element.supertype = objectElement.computeType(compiler);
     }
@@ skipping 58 matching lines @@
       supertype = applyMixin(supertype, visit(link.head));
       link = link.tail;
     }
     doApplyMixinTo(element, supertype, visit(link.head));
     return element.computeType(compiler);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType) {
     String superName = supertype.name.slowToString();
     String mixinName = mixinType.name.slowToString();
-    // TODO(kasperl): This is a little bit weird. Maybe we should
-    // restructure the parsed nodes for mixin applications to better
-    // match the nesting implied by the list of mixins so that each
-    // mixin application element could get it's own proper node.
-    MixinApplication fakeTree = element.parseNode(compiler);
     ClassElement mixinApplication = new MixinApplicationElementX(
         new SourceString("${superName}_${mixinName}"),
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
-        fakeTree);
+        element.parseNode(compiler));
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
   void doApplyMixinTo(ClassElement mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     assert(mixinApplication.supertype == null);
     mixinApplication.supertype = supertype;
 
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in.
     Link<DartType> interfaces = const Link<DartType>();
     interfaces = interfaces.prepend(mixinType);
     assert(mixinApplication.interfaces == null);
     mixinApplication.interfaces = interfaces;
 
-    assert(element.mixin == null);
+    assert(mixinApplication.mixin == null);
     mixinApplication.mixin = mixinType.element;
     mixinApplication.mixin.ensureResolved(compiler);
     mixinApplication.addDefaultConstructorIfNeeded(compiler);
     calculateAllSupertypes(mixinApplication);
   }
 
 
   // TODO(johnniwinther): Remove when default class is no longer supported.
   DartType visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
@@ skipping 38 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType()) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
       return null;
     }
     return e.computeType(compiler);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
-    DartType supertype;
-    if (superclass != null) {
-      supertype = typeResolver.resolveTypeAnnotation(
-          superclass, scope, cls, onFailure: error);
-    }
+    DartType supertype = typeResolver.resolveTypeAnnotation(
+        superclass, scope, cls, onFailure: error);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
         // Error has already been reported.
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
         // TODO(johnniwinther): Handle dynamic.
         error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
         return null;
       } else if (isBlackListed(supertype)) {
         error(superclass, MessageKind.CANNOT_EXTEND, [supertype]);
         return null;
@@ skipping 538 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }