Disallow mixing in classes that use 'super'.

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);
   bool isParameterChecked(Element element);
+  Set<Node> get superUses;
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
-  final Map<Node, Selector> selectors;
-  final Map<Node, DartType> types;
-  final Set<Element> checkedParameters;
+  final Map<Node, Selector> selectors = new LinkedHashMap<Node, Selector>();
+  final Map<Node, DartType> types = new LinkedHashMap<Node, DartType>();
+  final Set<Element> checkedParameters = new Set<Element>();
+  final Set<Node> superUses = new Set<Node>();
 
-  TreeElementMapping(this.currentElement)
-      : selectors = new LinkedHashMap<Node, Selector>(),
-        types = new LinkedHashMap<Node, DartType>(),
-        checkedParameters = new Set<Element>();
+  TreeElementMapping(this.currentElement);
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       if (node is FunctionExpression) {
         return !node.modifiers.isExternal();
       }
       return true;
     }));
     // TODO(johnniwinther): Simplify this invariant to use only declarations in
     // [TreeElements].
@@ skipping 227 matching lines @@
           FunctionElement redirection =
               resolver.resolveInitializers(element, tree);
           if (redirection != null) {
             resolveRedirectingConstructor(resolver, tree, element, redirection);
           }
         } else if (tree.initializers != null) {
           error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
         }
         visitBody(visitor, tree.body);
 
-        return visitor.mapping;
+        // Get the resolution tree and check that the resolved
+        // function doesn't use 'super' if it is mixed into another
+        // class. This is the part of the 'super' mixin check that
+        // happens when a function is resolved after the mixin
+        // application has been performed.
+        TreeElements resolutionTree = visitor.mapping;
+        ClassElement enclosingClass = element.getEnclosingClass();
+        if (enclosingClass != null) {
+          Set<MixinApplicationElement> mixinUses =
+              compiler.world.mixinUses[enclosingClass];
+          if (mixinUses != null) {
+            ClassElement mixin = enclosingClass;
+            for (MixinApplicationElement mixinApplication in mixinUses) {
+              checkMixinSuperUses(resolutionTree, mixinApplication, mixin);
+            }
+          }
+        }
+        return resolutionTree;
       });
     });
   }
 
   /// This method should only be used by this library (or tests of
   /// this library).
   ResolverVisitor visitorFor(Element element) {
     var mapping = new TreeElementMapping(element);
     return new ResolverVisitor(compiler, element, mapping);
   }
@@ skipping 233 matching lines @@
     ClassElement mixin = mixinApplication.mixin;
     if (mixin == null) return;
 
     // Check that the mixed in class has Object as its superclass.
     if (!mixin.superclass.isObject(compiler)) {
       CompilationError error = MessageKind.ILLEGAL_MIXIN_SUPERCLASS.error();
       compiler.reportMessage(compiler.spanFromElement(mixin),
                              error, Diagnostic.ERROR);
     }
 
-    // Check that the mixed in class doesn't have any constructors.
+    // Check that the mixed in class doesn't have any constructors and
+    // make sure we aren't mixing in methods that use 'super'.
     mixin.forEachLocalMember((Element member) {
       if (member.isGenerativeConstructor() && !member.isSynthesized) {
         CompilationError error = MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR.error();
         compiler.reportMessage(compiler.spanFromElement(member),
                                error, Diagnostic.ERROR);
+      } else {
+        // Get the resolution tree and check that the resolved member
+        // doesn't use 'super'. This is the part of the 'super' mixin
+        // check that happens when a function is resolved before the
+        // mixin application has been performed.
+        checkMixinSuperUses(
+            compiler.enqueuer.resolution.resolvedElements[member],
+            mixinApplication,
+            mixin);
       }
     });
   }
 
+  void checkMixinSuperUses(TreeElements resolutionTree,
+                           MixinApplicationElement mixinApplication,
+                           ClassElement mixin) {
+    if (resolutionTree == null) return;
+    Set<Node> superUses = resolutionTree.superUses;
+    if (superUses.isEmpty) return;
+    CompilationError error = MessageKind.ILLEGAL_MIXIN_WITH_SUPER.error(
+        [mixin.name]);
+    compiler.reportMessage(compiler.spanFromElement(mixinApplication),
+                           error, Diagnostic.ERROR);
+    // Show the user the problematic uses of 'super' in the mixin.
+    for (Node use in superUses) {
+      CompilationError error = MessageKind.ILLEGAL_MIXIN_SUPER_USE.error();
+      compiler.reportMessage(compiler.spanFromNode(use),
+                             error, Diagnostic.INFO);
+    }
+  }
+
   void checkClassMembers(ClassElement cls) {
     assert(invariant(cls, cls.isDeclaration));
     if (cls.isObject(compiler)) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     cls.forEachMember((holder, member) {
       compiler.withCurrentElement(member, () {
         // Perform various checks as side effect of "computing" the type.
         member.computeType(compiler);
 
@@ skipping 1220 matching lines @@
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
     return (identical(str, '&&') || str == '||' || str == '!');
   }
 
   Element resolveSend(Send node) {
     Selector selector = resolveSelector(node);
+    if (node.isSuperCall) mapping.superUses.add(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert()) {
         if (selector.argumentCount != 1) {
           error(node.selector,
                 MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
                 [selector.argumentCount]);
         } else if (selector.namedArgumentCount != 0) {
@@ skipping 1138 matching lines @@
         compiler.reportMessage(compiler.spanFromElement(mixinApplication),
                                error, Diagnostic.ERROR);
         // We have found a cycle in the mixin chain. Return null as
         // the mixin for this application to avoid getting into
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
+    compiler.world.registerMixinUse(mixinApplication, mixin);
     return mixin;
   }
 
   // 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) {
@@ skipping 595 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }