Check mixin of black-listed types.

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 get currentElement;
   Set<Node> get superUses;
 
@@ skipping 3588 matching lines @@
     resolveTypeVariableBounds(node.typeParameters);
 
     // Setup the supertype for the element (if there is a cycle in the
     // class hierarchy, it has already been set to Object).
     if (element.supertype == null && 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, resolveType(link.head), node);

[karlklose, 2013/10/03 07:50:01]

How about: 'resolveType' -> 'checkMixinType'?

[Johnni Winther, 2013/10/03 08:00:26]

Done.

+          TypeAnnotation mixinNode = link.head;
+          DartType mixinType = checkMixinType(mixinNode);
+          supertype = applyMixin(supertype, mixinType, mixinNode);
           link = link.tail;
         }
         element.supertype = supertype;
       } else {
         element.supertype = resolveSupertype(element, node.superclass);
       }
     }
     // If the super type isn't specified, we provide a default.  The language
     // specifies [Object] but the backend can pick a specific 'implementation'
     // of Object - the JavaScript backend chooses between Object and
@@ skipping 30 matching lines @@
             kind.error, arguments, const SourceString(''), element);
         compiler.backend.registerThrowNoSuchMethod(mapping);
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       element.setDefaultConstructor(constructor, compiler);
     }
     return element.computeType(compiler);
   }
 
+  /// Resolves the mixed type for [mixinNode] and checks that the the mixin type
+  /// is not black-listed. The mixin type is returned.
+  DartType checkMixinType(TypeAnnotation mixinNode) {
+    DartType mixinType = resolveType(mixinNode);
+    if (isBlackListed(mixinType)) {
+      compiler.reportError(mixinNode,
+          MessageKind.CANNOT_MIXIN, {'type': mixinType});
+    }
+    return mixinType;
+  }
+
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     compiler.ensure(element != null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // 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, resolveType(link.head), link.head);

[karlklose, 2013/10/03 07:50:01]

Ditto.

[Johnni Winther, 2013/10/03 08:00:26]

Done.

+      TypeAnnotation mixinNode = link.head;
+      DartType mixinType = checkMixinType(mixinNode);
+      supertype = applyMixin(supertype, mixinType, mixinNode);
       link = link.tail;
     }
-    doApplyMixinTo(element, supertype, resolveType(link.head));
+    doApplyMixinTo(element, supertype, checkMixinType(link.head));
     return element.computeType(compiler);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name.slowToString();
     String mixinName = mixinType.name.slowToString();
     ClassElement mixinApplication = new MixinApplicationElementX(
         new SourceString("${superName}+${mixinName}"),
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
@@ skipping 12 matching lines @@
 
   FunctionElement createForwardingConstructor(FunctionElement target,
                                               ClassElement enclosing) {
     return new SynthesizedConstructorElementX(
         target.name, target, enclosing, false);
   }
 
   void doApplyMixinTo(MixinApplicationElement mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
+

[karlklose, 2013/10/03 07:50:01]

Remove extra line.

[Johnni Winther, 2013/10/03 08:00:26]

Done.

     Node node = mixinApplication.parseNode(compiler);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
       assert(invariant(node, compiler.compilationFailed));
       supertype = mixinApplication.supertype;
       assert(invariant(node, supertype.element == compiler.objectClass));
     } else {
       mixinApplication.supertype = supertype;
     }
@@ skipping 766 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }