Get the most basic mixin applications working.

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 368 matching lines @@
     }
     return result;
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
-  void loadSupertypes(ClassElement cls, Node from) {
+  void loadSupertypes(ClassElement cls, Spannable from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         compiler.reportMessage(
           compiler.spanFromSpannable(from),
           MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
           Diagnostic.ERROR);
         cls.supertypeLoadState = STATE_DONE;
         cls.allSupertypes = const Link<DartType>().prepend(
             compiler.objectClass.computeType(compiler));
         // TODO(ahe): We should also set cls.supertype here to avoid
         // creating a malformed class hierarchy.
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       compiler.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
-        cls.parseNode(compiler).accept(new ClassSupertypeResolver(compiler,
-                                                                  cls));
+        cls.parseNode(compiler).accept(
+            new ClassSupertypeResolver(compiler, cls));
         if (cls.supertypeLoadState != STATE_DONE) {
           cls.supertypeLoadState = STATE_DONE;
         }
       });
     }));
   }
 
   // TODO(johnniwinther): Remove this queue when resolution has been split into
   // syntax and semantic resolution.
   ClassElement currentlyResolvedClass;
   Queue<ClassElement> pendingClassesToBeResolved = new Queue<ClassElement>();
 
-  void resolveMixinApplication(MixinApplicationElement element) {
-    // TODO(kasperl): Implement this.
-    assert(element.resolutionState == STATE_NOT_STARTED);
-    element.resolutionState = STATE_STARTED;
-    compiler.reportMessage(
-        compiler.spanFromSpannable(element.cachedNode),
-        MessageKind.GENERIC.error(['unimplemented mixin application']),
-        Diagnostic.ERROR);
-    element.resolutionState = STATE_DONE;
-  }
-
   /**
    * Resolve the class [element].
    *
    * Before calling this method, [element] was constructed by the
    * scanner and most fields are null or empty. This method fills in
    * these fields and also ensure that the supertypes of [element] are
    * resolved.
    *
    * Warning: Do not call this method directly. Instead use
    * [:element.ensureResolved(compiler):].
@@ skipping 16 matching lines @@
     } else {
       pendingClassesToBeResolved.add(element);
     }
   }
 
   void resolveClassInternal(ClassElement element) {
     if (!element.isPatch) {
       compiler.withCurrentElement(element, () => measure(() {
         assert(element.resolutionState == STATE_NOT_STARTED);
         element.resolutionState = STATE_STARTED;
-        ClassNode tree = element.parseNode(compiler);
+        Node tree = element.parseNode(compiler);
         loadSupertypes(element, tree);
 
         ClassResolverVisitor visitor =
             new ClassResolverVisitor(compiler, element);
         visitor.visit(tree);
         element.resolutionState = STATE_DONE;
       }));
       if (element.isPatched) {
         // Ensure handling patch after origin.
         element.patch.ensureResolved(compiler);
@@ skipping 2262 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);
 
-    // Find super type.
-    DartType supertype = null;
-    if (node.superclass != null) {
-      supertype = typeResolver.resolveTypeAnnotation(node.superclass, scope,
-          element, 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(node.superclass.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
-      } else if (isBlackListed(supertype)) {
-        error(node.superclass, MessageKind.CANNOT_EXTEND, [supertype]);
-      } else {
-        element.supertype = supertype;
-      }
-    }
+    // Resolve super type and deal with the Object class nicely.
+    element.supertype = resolveSupertype(element, node.superclass);
     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);
     }
+
     assert(element.interfaces == null);
     Link<DartType> interfaces = const Link<DartType>();
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty;
          link = link.tail) {
       DartType interfaceType = typeResolver.resolveTypeAnnotation(
           link.head, scope, element, onFailure: error);
       if (interfaceType != null) {
         if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
           // Error has already been reported.
@@ skipping 24 matching lines @@
           }
         }
       }
     }
     element.interfaces = interfaces;
     calculateAllSupertypes(element);
 
     if (node.defaultClause != null) {
       element.defaultClass = visit(node.defaultClause);
     }
-    addDefaultConstructorIfNeeded(element);
+    element.addDefaultConstructorIfNeeded(compiler);
     return element.computeType(compiler);
   }
 
+  DartType visitMixinApplication(MixinApplication node) {
+    compiler.ensure(element != null);
+    compiler.ensure(element.resolutionState == STATE_STARTED);
+
+    // Generate anonymous mixin application elements for the
+    // intermediate mixin applications (excluding the last).
+    DartType supertype = resolveSupertype(element, node.superclass);
+    Link<Node> link = node.mixins.nodes;
+    while (!link.tail.isEmpty) {
+      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}"),

[ahe, 2013/01/18 12:40:12]

I'm really concerned about this. We did something similar for constructors and
operators, and it has been a nightmare to get rid of it, and deal with the weird
situations that occur when a user defines a name that conflicts with the
generated name.

It would be much better if you could generate a synthetic name that isn't a
valid Dart identifier. In fact, if you always used the empty string, it would be
clear that you cannot use this identifier for looking it up elsewhere in the
system.

+        element.getCompilationUnit(),
+        compiler.getNextFreeClassId(),
+        fakeTree);
+    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);
+    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);
   }
 
   // TODO(johnniwinther): Remove when default class is no longer supported.
   DartType visitIdentifier(Identifier node) {
     Element element = scope.lookup(node.source);
     if (element == null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
@@ skipping 30 matching lines @@
     PrefixElement prefixElement = element;
     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);
+    }
+    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;
+      }
+    }
+    return supertype;
+  }
+
   void calculateAllSupertypes(ClassElement cls) {
-    // TODO(karlklose): check if type arguments match, if a classelement occurs
-    //                  more than once in the supertypes.
+    // TODO(karlklose): Check if type arguments match, if a class
+    // element occurs more than once in the supertypes.
     if (cls.allSupertypes != null) return;
     final DartType supertype = cls.supertype;
     if (supertype != null) {
       var allSupertypes = new LinkBuilder<DartType>();
       addAllSupertypes(allSupertypes, supertype);
       for (Link<DartType> interfaces = cls.interfaces;
            !interfaces.isEmpty;
            interfaces = interfaces.tail) {
         addAllSupertypes(allSupertypes, interfaces.head);
       }
@@ skipping 17 matching lines @@
     assert(invariant(element, supertypes != null,
         message: "Supertypes not computed on $classElement "
                  "during resolution of $element"));
     while (!supertypes.isEmpty) {
       DartType supertype = supertypes.head;
       builder.addLast(supertype.subst(typeArguments, typeVariables));
       supertypes = supertypes.tail;
     }
   }
 
-  /**
-   * Add a synthetic nullary constructor if there are no other
-   * constructors.
-   */
-  void addDefaultConstructorIfNeeded(ClassElement element) {
-    if (element.hasConstructor) return;
-    FunctionElement constructor =
-        new SynthesizedConstructorElementX.forDefault(element, compiler);
-    element.addToScope(constructor, compiler);
-  }
-
   isBlackListed(DartType type) {
     LibraryElement lib = element.getLibrary();
     return
       !identical(lib, compiler.coreLibrary) &&
       !identical(lib, compiler.jsHelperLibrary) &&
       !identical(lib, compiler.interceptorsLibrary) &&
       (identical(type.element, compiler.dynamicClass) ||
        identical(type.element, compiler.boolClass) ||
        identical(type.element, compiler.numClass) ||
        identical(type.element, compiler.intClass) ||
@@ skipping 11 matching lines @@
   ClassSupertypeResolver(Compiler compiler, ClassElement cls)
     : context = Scope.buildEnclosingScope(cls),
       this.classElement = cls,
       super(compiler);
 
   void loadSupertype(ClassElement element, Node from) {
     compiler.resolver.loadSupertypes(element, from);
     element.ensureResolved(compiler);
   }
 
+  void visitNodeList(NodeList node) {
+    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
+      link.head.accept(this);
+    }
+  }
+
   void visitClassNode(ClassNode node) {
     if (node.superclass == null) {
       if (!identical(classElement, compiler.objectClass)) {
         loadSupertype(compiler.objectClass, node);
       }
     } else {
       node.superclass.accept(this);
     }
-    for (Link<Node> link = node.interfaces.nodes;
-         !link.isEmpty;
-         link = link.tail) {
-      link.head.accept(this);
-    }
+    visitNodeList(node.interfaces);

[ahe, 2013/01/18 12:40:12]

Generally, I don't like calling the visitor methods directly. I removes dynamic
dispatch.

+  }
+
+  void visitMixinApplication(MixinApplication node) {
+    node.superclass.accept(this);
+    visitNodeList(node.mixins);

[ahe, 2013/01/18 12:40:12]

Ditto.

   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element == null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
@@ skipping 432 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }