Support 'implements' clause on typedef mixin applications.

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 2837 matching lines @@
       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.
-        } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
-          // TODO(johnniwinther): Handle dynamic.
-          TypeAnnotation typeAnnotation = link.head;
-          error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
-        } else {
-          if (interfaceType == element.supertype) {
-            compiler.reportMessage(
-                compiler.spanFromSpannable(node.superclass),
-                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
-                Diagnostic.ERROR);
-            compiler.reportMessage(
-                compiler.spanFromSpannable(link.head),
-                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
-                Diagnostic.ERROR);
-          }
-          if (interfaces.contains(interfaceType)) {
-            compiler.reportMessage(
-                compiler.spanFromSpannable(link.head),
-                MessageKind.DUPLICATE_IMPLEMENTS.error([interfaceType]),
-                Diagnostic.ERROR);
-          }
-          interfaces = interfaces.prepend(interfaceType);
-          if (isBlackListed(interfaceType)) {
-            error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
-          }
-        }
-      }
-    }
-    element.interfaces = interfaces;
+    element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     calculateAllSupertypes(element);
 
     if (node.defaultClause != null) {
       element.defaultClass = visit(node.defaultClause);
     }
     element.addDefaultConstructorIfNeeded(compiler);
     return element.computeType(compiler);
   }
 
   DartType visitMixinApplication(MixinApplication node) {
@@ skipping 26 matching lines @@
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
   void doApplyMixinTo(MixinApplicationElement mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     assert(mixinApplication.supertype == null);
     mixinApplication.supertype = supertype;
 
+    // Named mixin application may have an 'implements' clause.
+    NamedMixinApplication namedMixinApplication =
+        mixinApplication.parseNode(compiler).asNamedMixinApplication();
+    Link<DartType> interfaces = (namedMixinApplication != null)
+        ? resolveInterfaces(namedMixinApplication.interfaces,
+                            namedMixinApplication.superclass)
+        : const Link<DartType>();
+
     // 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>();
+    // the interface of the class that was mixed in so always prepend
+    // that to the interface list.
     interfaces = interfaces.prepend(mixinType);
     assert(mixinApplication.interfaces == null);
     mixinApplication.interfaces = interfaces;
 
     assert(mixinApplication.mixin == null);
     mixinApplication.mixin = resolveMixinFor(mixinApplication, mixinType);
     mixinApplication.addDefaultConstructorIfNeeded(compiler);
     calculateAllSupertypes(mixinApplication);
   }
 
@@ skipping 86 matching lines @@
         error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
         return null;
       } else if (isBlackListed(supertype)) {
         error(superclass, MessageKind.CANNOT_EXTEND, [supertype]);
         return null;
       }
     }
     return supertype;
   }
 
+  Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
+    Link<DartType> result = const Link<DartType>();
+    if (interfaces == null) return result;
+    for (Link<Node> link = 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.
+        } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
+          // TODO(johnniwinther): Handle dynamic.
+          TypeAnnotation typeAnnotation = link.head;
+          error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
+        } else {
+          if (interfaceType == element.supertype) {
+            compiler.reportMessage(
+                compiler.spanFromSpannable(superclass),
+                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
+                Diagnostic.ERROR);
+            compiler.reportMessage(
+                compiler.spanFromSpannable(link.head),
+                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
+                Diagnostic.ERROR);
+          }
+          if (result.contains(interfaceType)) {
+            compiler.reportMessage(
+                compiler.spanFromSpannable(link.head),
+                MessageKind.DUPLICATE_IMPLEMENTS.error([interfaceType]),
+                Diagnostic.ERROR);
+          }
+          result = result.prepend(interfaceType);
+          if (isBlackListed(interfaceType)) {
+            error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
   void calculateAllSupertypes(ClassElement cls) {
     // 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;
@@ skipping 523 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }