diff --git a/pkg/analyzer/lib/src/dart/element/inheritance_manager2.dart b/pkg/analyzer/lib/src/dart/element/inheritance_manager2.dart
index d523d07..799dbc8 100644
--- a/pkg/analyzer/lib/src/dart/element/inheritance_manager2.dart
+++ b/pkg/analyzer/lib/src/dart/element/inheritance_manager2.dart
@@ -30,6 +30,8 @@
 
 /// Manages knowledge about interface types and their members.
 class InheritanceManager2 {
+  static final _noSuchMethodName = Name(null, 'noSuchMethod');
+
   final TypeSystem _typeSystem;
 
   /// Cached instance interfaces for [InterfaceType].
@@ -39,12 +41,6 @@
   /// self-referencing cycles.
   final Set<ClassElement> _processingClasses = new Set<ClassElement>();
 
-  /// Cached implemented members for [InterfaceType].
-  final Map<InterfaceType, Map<Name, FunctionType>> _implemented = {};
-
-  /// Cached member implemented in the mixin.
-  final Map<InterfaceType, Map<Name, FunctionType>> _mixinMembers = {};
-
   InheritanceManager2(this._typeSystem);
 
   /// Return the member with the given [name] that the [type] inherits from the
@@ -74,49 +70,71 @@
     Map<Name, List<FunctionType>> namedCandidates = {};
     List<Map<Name, FunctionType>> superImplemented = [];
     Map<Name, FunctionType> declared;
+    Interface superInterface;
+    Map<Name, FunctionType> implemented;
+    Map<Name, FunctionType> implementedForMixing;
     try {
       // If a class declaration has a member declaration, the signature of that
       // member declaration becomes the signature in the interface.
       declared = _getTypeMembers(type);
 
       for (var interface in type.interfaces) {
-        _addCandidates(namedCandidates, interface);
+        var interfaceObj = getInterface(interface);
+        _addCandidates(namedCandidates, interfaceObj);
       }
 
-      if (type.element.isMixin) {
+      if (classElement.isMixin) {
         for (var constraint in type.superclassConstraints) {
-          _addCandidates(namedCandidates, constraint);
+          var interfaceObj = getInterface(constraint);
+          _addCandidates(namedCandidates, interfaceObj);
         }
 
+        implemented = {};
+
         // `mixin M on S1, S2 {}` can call using `super` any instance member
         // from its superclass constraints, whether it is abstract or concrete.
         Map<Name, FunctionType> mixinSuperClass = {};
         _findMostSpecificFromNamedCandidates(mixinSuperClass, namedCandidates);
         superImplemented.add(mixinSuperClass);
       } else {
-        Map<Name, FunctionType> implemented;
-
         if (type.superclass != null) {
-          _addCandidates(namedCandidates, type.superclass);
+          superInterface = getInterface(type.superclass);
+          _addCandidates(namedCandidates, superInterface);
 
-          implemented = _getImplemented(type.superclass);
+          implemented = superInterface.implemented;
           superImplemented.add(implemented);
+        } else {
+          implemented = {};
         }
 
+        implementedForMixing = {};
         for (var mixin in type.mixins) {
-          _addCandidates(namedCandidates, mixin);
+          var interfaceObj = getInterface(mixin);
+          _addCandidates(namedCandidates, interfaceObj);
 
-          var implementedInMixin = _getImplemented(mixin);
           implemented = <Name, FunctionType>{}
             ..addAll(implemented)
-            ..addAll(implementedInMixin);
+            ..addAll(interfaceObj.implementedForMixing);
           superImplemented.add(implemented);
+          implementedForMixing.addAll(interfaceObj.implementedForMixing);
         }
       }
     } finally {
       _processingClasses.remove(classElement);
     }
 
+    var thisImplemented = <Name, FunctionType>{};
+    _addImplemented(thisImplemented, type);
+
+    if (classElement.isMixin) {
+      implementedForMixing = thisImplemented;
+    } else {
+      implementedForMixing.addAll(thisImplemented);
+    }
+
+    implemented = <Name, FunctionType>{}..addAll(implemented);
+    _addImplemented(implemented, type);
+
     // If a class declaration does not have a member declaration with a
     // particular name, but some super-interfaces do have a member with that
     // name, it's a compile-time error if there is no signature among the
@@ -129,9 +147,31 @@
       namedCandidates,
     );
 
+    var noSuchMethodForwarders = Set<Name>();
+    if (classElement.isAbstract) {
+      if (superInterface != null) {
+        noSuchMethodForwarders = superInterface.noSuchMethodForwarders;
+      }
+    } else {
+      var noSuchMethod = implemented[_noSuchMethodName]?.element;
+      if (noSuchMethod != null && !_isDeclaredInObject(noSuchMethod)) {
+        var superForwarders = superInterface?.noSuchMethodForwarders;
+        for (var name in map.keys) {
+          if (!implemented.containsKey(name) ||
+              superForwarders != null && superForwarders.contains(name)) {
+            implemented[name] = map[name];
+            noSuchMethodForwarders.add(name);
+          }
+        }
+      }
+    }
+
     var interface = new Interface._(
       map,
       declared,
+      implemented,
+      noSuchMethodForwarders,
+      implementedForMixing,
       namedCandidates,
       superImplemented,
       conflicts ?? const [],
@@ -158,17 +198,18 @@
     int forMixinIndex: -1,
     bool forSuper: false,
   }) {
+    var interface = getInterface(type);
     if (forSuper) {
-      var superImplemented = getInterface(type)._superImplemented;
+      var superImplemented = interface._superImplemented;
       if (forMixinIndex >= 0) {
         return superImplemented[forMixinIndex][name];
       }
       return superImplemented.last[name];
     }
     if (concrete) {
-      return _getImplemented(type)[name];
+      return interface.implemented[name];
     }
-    return getInterface(type).map[name];
+    return interface.map[name];
   }
 
   /// Return all members of mixins, superclasses, and interfaces that a member
@@ -191,14 +232,33 @@
   }
 
   void _addCandidates(
-      Map<Name, List<FunctionType>> namedCandidates, InterfaceType type) {
-    var map = getInterface(type).map;
+      Map<Name, List<FunctionType>> namedCandidates, Interface interface) {
+    var map = interface.map;
     for (var name in map.keys) {
       var candidate = map[name];
       _addCandidate(namedCandidates, name, candidate);
     }
   }
 
+  void _addImplemented(
+      Map<Name, FunctionType> implemented, InterfaceType type) {
+    var libraryUri = type.element.librarySource.uri;
+
+    void addMember(ExecutableElement member) {
+      if (!member.isAbstract && !member.isStatic) {
+        var name = new Name(libraryUri, member.name);
+        implemented[name] = member.type;
+      }
+    }
+
+    void addMembers(InterfaceType type) {
+      type.methods.forEach(addMember);
+      type.accessors.forEach(addMember);
+    }
+
+    addMembers(type);
+  }
+
   /// Check that all [candidates] for the given [name] have the same kind, all
   /// getters, all methods, or all setter.  If a conflict found, return the
   /// new [Conflict] instance that describes it.
@@ -301,83 +361,6 @@
     return conflicts;
   }
 
-  Map<Name, FunctionType> _getImplemented(InterfaceType type) {
-    var implemented = _implemented[type];
-    if (implemented != null) {
-      return implemented;
-    }
-
-    _implemented[type] = const {};
-    implemented = <Name, FunctionType>{};
-
-    var libraryUri = type.element.librarySource.uri;
-
-    void addMember(ExecutableElement member) {
-      if (!member.isAbstract && !member.isStatic) {
-        var name = new Name(libraryUri, member.name);
-        implemented[name] = member.type;
-      }
-    }
-
-    void addMembers(InterfaceType type) {
-      type.methods.forEach(addMember);
-      type.accessors.forEach(addMember);
-    }
-
-    if (type.superclass != null) {
-      var superImplemented = _getImplemented(type.superclass);
-      implemented.addAll(superImplemented);
-    }
-
-    // Mixins override the nominal superclass and previous mixins.
-    for (var mixin in type.mixins) {
-      var superImplemented = _getImplementedInMixin(mixin);
-      implemented.addAll(superImplemented);
-    }
-
-    // This type overrides everything from its actual superclass.
-    addMembers(type);
-
-    _implemented[type] = implemented;
-    return implemented;
-  }
-
-  /// TODO(scheglov) This repeats a lot of code from [_getImplemented].
-  Map<Name, FunctionType> _getImplementedInMixin(InterfaceType type) {
-    var implemented = _mixinMembers[type];
-    if (implemented != null) {
-      return implemented;
-    }
-
-    _mixinMembers[type] = const {};
-    implemented = <Name, FunctionType>{};
-
-    var libraryUri = type.element.librarySource.uri;
-
-    void addMember(ExecutableElement member) {
-      if (!member.isAbstract && !member.isStatic) {
-        var name = new Name(libraryUri, member.name);
-        implemented[name] = member.type;
-      }
-    }
-
-    void addMembers(InterfaceType type) {
-      type.methods.forEach(addMember);
-      type.accessors.forEach(addMember);
-    }
-
-    for (var mixin in type.mixins) {
-      var superImplemented = _getImplementedInMixin(mixin);
-      implemented.addAll(superImplemented);
-    }
-
-    // This type overrides everything from its actual superclass.
-    addMembers(type);
-
-    _mixinMembers[type] = implemented;
-    return implemented;
-  }
-
   Map<Name, FunctionType> _getTypeMembers(InterfaceType type) {
     var declared = <Name, FunctionType>{};
     var libraryUri = type.element.librarySource.uri;
@@ -402,14 +385,24 @@
 
     return declared;
   }
+
+  static bool _isDeclaredInObject(ExecutableElement element) {
+    var enclosing = element.enclosingElement;
+    return enclosing is ClassElement &&
+        enclosing.supertype == null &&
+        !enclosing.isMixin;
+  }
 }
 
 /// The instance interface of an [InterfaceType].
 class Interface {
-  static const _empty = const Interface._(
+  static final _empty = Interface._(
     const {},
     const {},
     const {},
+    Set<Name>(),
+    const {},
+    const {},
     const [{}],
     const [],
   );
@@ -420,6 +413,16 @@
   /// The map of declared names to their signatures.
   final Map<Name, FunctionType> declared;
 
+  /// The map of names to their concrete implementations.
+  final Map<Name, FunctionType> implemented;
+
+  /// The set of names that are `noSuchMethod` forwarders in [implemented].
+  final Set<Name> noSuchMethodForwarders;
+
+  /// The map of names to their concrete implementations that can be mixed
+  /// when this type is used as a mixin.
+  final Map<Name, FunctionType> implementedForMixing;
+
   /// The map of names to their signatures from the mixins, superclasses,
   /// or interfaces.
   final Map<Name, List<FunctionType>> _overridden;
@@ -435,9 +438,12 @@
   /// members of the class.
   final List<Conflict> conflicts;
 
-  const Interface._(
+  Interface._(
     this.map,
     this.declared,
+    this.implemented,
+    this.noSuchMethodForwarders,
+    this.implementedForMixing,
     this._overridden,
     this._superImplemented,
     this.conflicts,
diff --git a/pkg/analyzer/lib/src/error/inheritance_override.dart b/pkg/analyzer/lib/src/error/inheritance_override.dart
index 10c6bf8..20ecec0 100644
--- a/pkg/analyzer/lib/src/error/inheritance_override.dart
+++ b/pkg/analyzer/lib/src/error/inheritance_override.dart
@@ -122,6 +122,10 @@
       return;
     }
 
+    if (_checkForRecursiveInterfaceInheritance(classElement)) {
+      return;
+    }
+
     InterfaceTypeImpl type = classElement.type;
 
     // Add all superinterfaces of the direct supertype.
@@ -183,15 +187,13 @@
         }
 
         var interfaceType = interface.map[name];
-        var concreteType = inheritance.getMember(type, name, concrete: true);
+        var concreteType = interface.implemented[name];
 
         // No concrete implementation of the name.
         if (concreteType == null) {
-          if (!classElement.hasNoSuchMethod) {
-            if (!_reportConcreteClassWithAbstractMember(name.name)) {
-              inheritedAbstract ??= [];
-              inheritedAbstract.add(interfaceType);
-            }
+          if (!_reportConcreteClassWithAbstractMember(name.name)) {
+            inheritedAbstract ??= [];
+            inheritedAbstract.add(interfaceType);
           }
           continue;
         }
@@ -404,6 +406,106 @@
     }
   }
 
+  /// Check that [classElement] is not a superinterface to itself.
+  /// The [path] is a list containing the potentially cyclic implements path.
+  ///
+  /// See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
+  /// [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_EXTENDS],
+  /// [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_IMPLEMENTS],
+  /// [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_ON],
+  /// [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_WITH].
+  bool _checkForRecursiveInterfaceInheritance(ClassElement element,
+      [List<ClassElement> path]) {
+    path ??= <ClassElement>[];
+
+    // Detect error condition.
+    int size = path.length;
+    // If this is not the base case (size > 0), and the enclosing class is the
+    // given class element then report an error.
+    if (size > 0 && classElement == element) {
+      String className = classElement.displayName;
+      if (size > 1) {
+        // Construct a string showing the cyclic implements path:
+        // "A, B, C, D, A"
+        String separator = ", ";
+        StringBuffer buffer = new StringBuffer();
+        for (int i = 0; i < size; i++) {
+          buffer.write(path[i].displayName);
+          buffer.write(separator);
+        }
+        buffer.write(element.displayName);
+        reporter.reportErrorForElement(
+            CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
+            classElement,
+            [className, buffer.toString()]);
+        return true;
+      } else {
+        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
+        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
+        // RECURSIVE_INTERFACE_INHERITANCE_ON or
+        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
+        reporter.reportErrorForElement(
+            _getRecursiveErrorCode(element), classElement, [className]);
+        return true;
+      }
+    }
+
+    if (path.indexOf(element) > 0) {
+      return false;
+    }
+    path.add(element);
+
+    // n-case
+    InterfaceType supertype = element.supertype;
+    if (supertype != null &&
+        _checkForRecursiveInterfaceInheritance(supertype.element, path)) {
+      return true;
+    }
+
+    for (InterfaceType type in element.mixins) {
+      if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
+        return true;
+      }
+    }
+
+    for (InterfaceType type in element.superclassConstraints) {
+      if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
+        return true;
+      }
+    }
+
+    for (InterfaceType type in element.interfaces) {
+      if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
+        return true;
+      }
+    }
+
+    path.removeAt(path.length - 1);
+    return false;
+  }
+
+  /// Return the error code that should be used when the given class [element]
+  /// references itself directly.
+  ErrorCode _getRecursiveErrorCode(ClassElement element) {
+    if (element.supertype?.element == classElement) {
+      return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_EXTENDS;
+    }
+
+    for (InterfaceType type in element.superclassConstraints) {
+      if (type.element == classElement) {
+        return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_ON;
+      }
+    }
+
+    for (InterfaceType type in element.mixins) {
+      if (type.element == classElement) {
+        return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_WITH;
+      }
+    }
+
+    return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_IMPLEMENTS;
+  }
+
   /// We identified that the current non-abstract class does not have the
   /// concrete implementation of a method with the given [name].  If this is
   /// because the class itself defines an abstract method with this [name],
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index bff4d6b..baee3b51 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -1342,7 +1342,6 @@
         !_checkForAllMixinErrorCodes(withClause)) {
       _checkForImplicitDynamicType(superclass);
       _checkForExtendsDeferredClass(superclass);
-      _checkForRecursiveInterfaceInheritance(_enclosingClass);
       _checkForConflictingClassMembers();
       _checkForRepeatedType(implementsClause?.interfaces,
           CompileTimeErrorCode.IMPLEMENTS_REPEATED);
@@ -4168,11 +4167,6 @@
       return false;
     }
 
-    ClassElementImpl nominalSuperClass =
-        AbstractClassElementImpl.getImpl(_enclosingClass.supertype?.element);
-    bool nominalSuperClassHasNoSuchMethodForwarders =
-        nominalSuperClass != null && !nominalSuperClass.isAbstract;
-
     InterfaceTypeImpl enclosingType = _enclosingClass.type;
     Uri mixinLibraryUri = mixinElement.librarySource.uri;
     for (var name in mixinElementImpl.superInvokedNames) {
@@ -4183,9 +4177,6 @@
           forMixinIndex: mixinIndex, concrete: true, forSuper: true);
 
       if (superMemberType == null) {
-        if (nominalSuperClassHasNoSuchMethodForwarders) {
-          continue;
-        }
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode
                 .MIXIN_APPLICATION_NO_CONCRETE_SUPER_INVOKED_MEMBER,
@@ -4713,86 +4704,6 @@
   }
 
   /**
-   * Check that [_enclosingClass] is not a superinterface to itself.
-   *  The [path] is a list containing the potentially cyclic implements path.
-   *
-   * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
-   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_EXTENDS],
-   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_IMPLEMENTS],
-   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_ON],
-   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_WITH].
-   */
-  bool _checkForRecursiveInterfaceInheritance(ClassElement element,
-      [List<ClassElement> path]) {
-    path ??= <ClassElement>[];
-
-    // Detect error condition.
-    int size = path.length;
-    // If this is not the base case (size > 0), and the enclosing class is the
-    // given class element then an error an error.
-    if (size > 0 && _enclosingClass == element) {
-      String enclosingClassName = _enclosingClass.displayName;
-      if (size > 1) {
-        // Construct a string showing the cyclic implements path:
-        // "A, B, C, D, A"
-        String separator = ", ";
-        StringBuffer buffer = new StringBuffer();
-        for (int i = 0; i < size; i++) {
-          buffer.write(path[i].displayName);
-          buffer.write(separator);
-        }
-        buffer.write(element.displayName);
-        _errorReporter.reportErrorForElement(
-            CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
-            _enclosingClass,
-            [enclosingClassName, buffer.toString()]);
-        return true;
-      } else {
-        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
-        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
-        // RECURSIVE_INTERFACE_INHERITANCE_ON or
-        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
-        _errorReporter.reportErrorForElement(_getBaseCaseErrorCode(element),
-            _enclosingClass, [enclosingClassName]);
-        return true;
-      }
-    }
-
-    if (path.indexOf(element) > 0) {
-      return false;
-    }
-    path.add(element);
-
-    // n-case
-    InterfaceType supertype = element.supertype;
-    if (supertype != null &&
-        _checkForRecursiveInterfaceInheritance(supertype.element, path)) {
-      return true;
-    }
-
-    for (InterfaceType type in element.mixins) {
-      if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
-        return true;
-      }
-    }
-
-    for (InterfaceType type in element.superclassConstraints) {
-      if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
-        return true;
-      }
-    }
-
-    for (InterfaceType type in element.interfaces) {
-      if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
-        return true;
-      }
-    }
-
-    path.removeAt(path.length - 1);
-    return false;
-  }
-
-  /**
    * Check that the given constructor [declaration] has a valid combination of
    * redirected constructor invocation(s), super constructor invocations and
    * field initializers.
@@ -5708,7 +5619,6 @@
     if (!_checkForOnClauseErrorCodes(onClause) &&
         !_checkForImplementsClauseErrorCodes(implementsClause)) {
 //      _checkForImplicitDynamicType(superclass);
-      _checkForRecursiveInterfaceInheritance(_enclosingClass);
       _checkForConflictingClassMembers();
       _checkForRepeatedType(
         onClause?.superclassConstraints,
@@ -5867,30 +5777,6 @@
   }
 
   /**
-   * Return the error code that should be used when the given class [element]
-   * references itself directly.
-   */
-  ErrorCode _getBaseCaseErrorCode(ClassElement element) {
-    if (element.supertype?.element == _enclosingClass) {
-      return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_EXTENDS;
-    }
-
-    for (InterfaceType type in element.superclassConstraints) {
-      if (type.element == _enclosingClass) {
-        return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_ON;
-      }
-    }
-
-    for (InterfaceType type in element.mixins) {
-      if (type.element == _enclosingClass) {
-        return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_WITH;
-      }
-    }
-
-    return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_IMPLEMENTS;
-  }
-
-  /**
    * Given an [expression] in a switch case whose value is expected to be an
    * enum constant, return the name of the constant.
    */
diff --git a/pkg/analyzer/lib/src/summary/link.dart b/pkg/analyzer/lib/src/summary/link.dart
index 5a9b656..b9b065e 100644
--- a/pkg/analyzer/lib/src/summary/link.dart
+++ b/pkg/analyzer/lib/src/summary/link.dart
@@ -700,6 +700,9 @@
       _unlinkedClass.interfaces.map(_computeInterfaceType).toList();
 
   @override
+  bool get isAbstract => _unlinkedClass.isAbstract;
+
+  @override
   bool get isEnum => false;
 
   @override
@@ -1011,6 +1014,9 @@
   bool get isMixin => false;
 
   @override
+  bool get isAbstract => false;
+
+  @override
   bool get isObject => false;
 
   @override
diff --git a/pkg/analyzer/test/src/dart/element/inheritance_manager2_test.dart b/pkg/analyzer/test/src/dart/element/inheritance_manager2_test.dart
index 4dddf19..60497d0 100644
--- a/pkg/analyzer/test/src/dart/element/inheritance_manager2_test.dart
+++ b/pkg/analyzer/test/src/dart/element/inheritance_manager2_test.dart
@@ -115,7 +115,7 @@
     );
   }
 
-  void test_getMember_() async {
+  test_getMember() async {
     addTestFile('''
 abstract class I1 {
   void f(int i);
@@ -136,7 +136,196 @@
     assertElementTypeString(memberType, '(Object) → void');
   }
 
-  test_preferLatest_mixin() async {
+  test_getMember_concrete() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('A', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  test_getMember_concrete_abstract() async {
+    addTestFile('''
+abstract class A {
+  void foo();
+}
+''');
+    await resolveTestFile();
+
+    expect(_getConcrete('A', 'foo'), isNull);
+  }
+
+  test_getMember_concrete_fromMixedClass() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+
+class X with A {}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('X', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  test_getMember_concrete_fromMixedClass2() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+
+class B = Object with A;
+
+class X with B {}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('X', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  test_getMember_concrete_fromMixedClass_skipObject() async {
+    addTestFile('''
+class A {
+  String toString() => 'A';
+}
+
+class B {}
+
+class X extends A with B {}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('X', 'toString'),
+      same(findElement.method('toString', of: 'A')),
+    );
+  }
+
+  test_getMember_concrete_fromMixin() async {
+    addTestFile('''
+mixin M {
+  void foo() {}
+}
+
+class X with M {}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('X', 'foo'),
+      same(findElement.method('foo', of: 'M')),
+    );
+  }
+
+  test_getMember_concrete_fromSuper() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+
+class B extends A {}
+
+abstract class C extends B {}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('B', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+
+    expect(
+      _getConcrete('C', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  test_getMember_concrete_missing() async {
+    addTestFile('''
+abstract class A {}
+''');
+    await resolveTestFile();
+
+    expect(_getConcrete('A', 'foo'), isNull);
+  }
+
+  test_getMember_concrete_noSuchMethod() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+
+class B implements A {
+  noSuchMethod(_) {}
+}
+
+abstract class C extends B {}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('B', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+
+    expect(
+      _getConcrete('C', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  test_getMember_concrete_noSuchMethod_mixin() async {
+    addTestFile('''
+class A {
+  void foo();
+
+  noSuchMethod(_) {}
+}
+
+abstract class B extends Object with A {}
+''');
+    await resolveTestFile();
+
+    // noSuchMethod forwarders are not mixed-in.
+    // https://github.com/dart-lang/sdk/issues/33553#issuecomment-424638320
+    expect(_getConcrete('B', 'foo'), isNull);
+  }
+
+  test_getMember_concrete_noSuchMethod_moreSpecificSignature() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+
+class B implements A {
+  noSuchMethod(_) {}
+}
+
+class C extends B {
+  void foo([a]);
+}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getConcrete('C', 'foo'),
+      same(findElement.method('foo', of: 'C')),
+    );
+  }
+
+  test_getMember_preferLatest_mixin() async {
     addTestFile('''
 class A {
   void foo() {}
@@ -165,7 +354,7 @@
     expect(member.element, findElement.method('foo', of: 'M2'));
   }
 
-  test_preferLatest_superclass() async {
+  test_getMember_preferLatest_superclass() async {
     addTestFile('''
 class A {
   void foo() {}
@@ -190,7 +379,7 @@
     expect(member.element, findElement.method('foo', of: 'B'));
   }
 
-  test_preferLatest_this() async {
+  test_getMember_preferLatest_this() async {
     addTestFile('''
 class A {
   void foo() {}
@@ -213,8 +402,103 @@
     expect(member.element, findElement.method('foo', of: 'X'));
   }
 
+  test_getMember_super_abstract() async {
+    addTestFile('''
+abstract class A {
+  void foo();
+}
+
+class B extends A {
+  noSuchMethod(_) {}
+}
+''');
+    await resolveTestFile();
+
+    expect(_getSuper('B', 'foo'), isNull);
+  }
+
+  test_getMember_super_fromMixin() async {
+    addTestFile('''
+mixin M {
+  void foo() {}
+}
+
+class X extends Object with M {
+  void foo() {}
+}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getSuper('X', 'foo'),
+      same(findElement.method('foo', of: 'M')),
+    );
+  }
+
+  test_getMember_super_fromSuper() async {
+    addTestFile('''
+class A {
+  void foo() {}
+}
+
+class B extends A {
+  void foo() {}
+}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getSuper('B', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  test_getMember_super_missing() async {
+    addTestFile('''
+class A {}
+
+class B extends A {}
+''');
+    await resolveTestFile();
+
+    expect(_getSuper('B', 'foo'), isNull);
+  }
+
+  test_getMember_super_noSuchMember() async {
+    addTestFile('''
+class A {
+  void foo();
+  noSuchMethod(_) {}
+}
+
+class B extends A {
+  void foo() {}
+}
+''');
+    await resolveTestFile();
+
+    expect(
+      _getSuper('B', 'foo'),
+      same(findElement.method('foo', of: 'A')),
+    );
+  }
+
+  ExecutableElement _getConcrete(String className, String name) {
+    var type = findElement.class_(className).type;
+    return manager
+        .getMember(type, new Name(null, name), concrete: true)
+        ?.element;
+  }
+
   ExecutableElement _getInherited(String className, String name) {
     var type = findElement.class_(className).type;
     return manager.getInherited(type, new Name(null, name)).element;
   }
+
+  ExecutableElement _getSuper(String className, String name) {
+    var type = findElement.class_(className).type;
+    return manager
+        .getMember(type, new Name(null, name), forSuper: true)
+        ?.element;
+  }
 }
diff --git a/pkg/analyzer/test/src/dart/resolution/class_test.dart b/pkg/analyzer/test/src/dart/resolution/class_test.dart
index 5650cdb..efcec88 100644
--- a/pkg/analyzer/test/src/dart/resolution/class_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/class_test.dart
@@ -1511,8 +1511,6 @@
     assertTestErrors([
       CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
       CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS,
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS,
     ]);
   }
 
@@ -1568,7 +1566,6 @@
     await resolveTestFile();
     assertTestErrors([
       CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_EXTENDS,
-      StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
     ]);
   }
 
diff --git a/pkg/analyzer/test/src/dart/resolution/mixin_test.dart b/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
index bc792f0..65cb6d7 100644
--- a/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
@@ -1026,6 +1026,32 @@
     assertNoTestErrors();
   }
 
+  test_error_mixinApplicationNoConcreteSuperInvokedMember_OK_hasNSM2() async {
+    addTestFile(r'''
+abstract class A {
+  void foo();
+}
+
+mixin M on A {
+  void bar() {
+    super.foo();
+  }
+}
+
+/// Class `B` has noSuchMethod forwarder for `foo`.
+class B implements A {
+  noSuchMethod(_) {}
+}
+
+/// Class `C` is abstract, but it inherits noSuchMethod forwarders from `B`.
+abstract class C extends B {}
+
+class X extends C with M {}
+''');
+    await resolveTestFile();
+    assertNoTestErrors();
+  }
+
   test_error_mixinApplicationNoConcreteSuperInvokedMember_OK_inPreviousMixin() async {
     addTestFile(r'''
 abstract class A {