Avoid issuing incorrect errors when super mixins are enabled

pkg/analyzer/lib/src/task/strong/checker.dart

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'dart:collection';
 import 'package:analyzer/analyzer.dart';
@@ skipping 1619 matching lines @@
     var interfaces = _collectInterfacesToCheck(element.type);
     var visitedClasses = new Set<InterfaceType>();
     var visitedMembers = new HashSet<String>();
 
     // Checks all most-derived concrete members on this `type`. We skip over
     // members that are already `visitedMembers`, because they were overridden
     // and we've already checked that member.
     //
     // Because of that, it is important we visit types in the order that they
     // will override members.
-    void checkType(InterfaceType type, AstNode location) {
+    // If checkingMixin is true, then we are checking [type] in a mixin position
+    // and hence should consider its own mixins and superclass as abstract.
+    void checkType(InterfaceType type, AstNode location,
+        {bool checkingMixin: false}) {
       // Skip `Object` because we don't need to check those members here.
       // (because `Object` is the root of everything, it will be checked in
       // _checkSuperOverrides for all classes).
       if (type == null || type.isObject || !visitedClasses.add(type)) return;
 
       // Check `member` against all `interfaces`.
       void checkOverride(ExecutableElement member, [AstNode loc]) {
         if (!visitedMembers.add(member.name)) return;
         for (var interface in interfaces) {
           if (_checkMemberOverride(member, interface, loc ?? location) ==
@@ skipping 11 matching lines @@
       // Otherwise, we'll use the `extends` or `with` clause.
       var isRootClass = identical(location, node);
 
       // Check direct overrides on the class.
       if (isRootClass) {
         _checkClassMembers(node, checkOverride);
       } else {
         _checkTypeMembers(type, checkOverride);
       }
 
-      // Check mixin members against interfaces.
-      //
-      // We visit mixins in reverse order to reflect how they override
-      // eachother.
-      for (int i = type.mixins.length - 1; i >= 0; i--) {
-        checkType(type.mixins[i],
-            isRootClass ? _withClause(node).mixinTypes[i] : location);
+      // If we are currently checking a mixin, then its own mixins and
+      // superclass are abstract, and we should not check their members.
+      // This should only happen when super mixins is enabled, and we
+      // don't do proper checking for super mixins (we don't check that
+      // the contract implied by the mixin declaration is satisfied by
+      // the mixin use), but this prevents us from erroneously
+      // rejecting some super mixin patterns.
+      // If this is a mixin application (class A = Object with B)
+      // however, then we do still need to treat the mixin as concrete.
+      if (!checkingMixin || type.element.isMixinApplication) {
+        // Check mixin members against interfaces.
+        //
+        // We visit mixins in reverse order to reflect how they override
+        // eachother.
+        for (int i = type.mixins.length - 1; i >= 0; i--) {
+          checkType(type.mixins[i],
+              isRootClass ? _withClause(node).mixinTypes[i] : location,
+              checkingMixin: true);
+        }
+
+        // Check members on the superclass.
+        checkType(type.superclass,
+            isRootClass ? _extendsErrorLocation(node) : location,
+            checkingMixin: checkingMixin);
       }
-
-      // Check members on the superclass.
-      checkType(type.superclass,
-          isRootClass ? _extendsErrorLocation(node) : location);
     }
 
     checkType(element.type, node);
   }
 
   /// Gets the set of all interfaces on [type] that should be checked to see
   /// if type's members are overriding them correctly.
   ///
   /// In particular, we need to check these overrides for the definitions in
   /// the class itself and each its superclasses (and mixins).
@@ skipping 264 matching lines @@
   }
 
   /// If node is a [ClassDeclaration] returns its members, otherwise if node is
   /// a [ClassTypeAlias] this returns an empty list.
   WithClause _withClause(Declaration node) {
     return node is ClassDeclaration
         ? node.withClause
         : (node as ClassTypeAlias).withClause;
   }
 }