Report when members indirectly inherited through a mixin are not implemented (issue 26411)

pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 244 matching lines @@
    *         [ClassElement] superclass hierarchy, and the associated [ExecutableElement]
    */
   Map<String, ExecutableElement> _computeClassChainLookupMap(
       ClassElement classElt, Set<ClassElement> visitedClasses) {
     Map<String, ExecutableElement> resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
-    ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
-    if (supertype != null) {
-      superclassElt = supertype.element;
-    } else {
+    if (supertype == null) {
       // classElt is Object
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
+    ClassElement superclassElt = supertype.element;
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         visitedClasses.add(superclassElt);
         try {
           resultMap = new Map<String, ExecutableElement>.from(
               _computeClassChainLookupMap(superclassElt, visitedClasses));
           //
           // Substitute the super types down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, resultMap);
@@ skipping 18 matching lines @@
     // mixins will overwrite identically-named methods in earlier mixins.
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (InterfaceType mixin in mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
             Map<String, ExecutableElement> map =
-                new Map<String, ExecutableElement>.from(
-                    _computeClassChainLookupMap(mixinElement, visitedClasses));
+                new Map<String, ExecutableElement>();
             //
-            // Substitute the super types down the hierarchy.
-            //
-            _substituteTypeParametersDownHierarchy(mixin, map);
-            //
-            // Include the members from the superclass in the resultMap.
+            // Include the members from the mixin in the resultMap.
             //
             _recordMapWithClassMembers(map, mixin, false);
             //
             // Add the members from map into result map.
             //
             for (String memberName in map.keys) {
               ExecutableElement value = map[memberName];
               ClassElement definingClass = value
                   .getAncestor((Element element) => element is ClassElement);
               if (!definingClass.type.isObject) {
@@ skipping 271 matching lines @@
    * Record the passed map with the set of all members (methods, getters and setters) in the type
    * into the passed map.
    *
    * @param map some non-`null` map to put the methods and accessors from the passed
    *          [ClassElement] into
    * @param type the type that will be recorded into the passed map
    * @param doIncludeAbstract `true` if abstract members will be put into the map
    */
   void _recordMapWithClassMembers(Map<String, ExecutableElement> map,
       InterfaceType type, bool doIncludeAbstract) {
+    Set<InterfaceType> seenTypes = new HashSet<InterfaceType>();
+    while (type.element.isMixinApplication) {
+      List<InterfaceType> mixins = type.mixins;
+      if (!seenTypes.add(type) || mixins.isEmpty) {
+        // In the case of a circularity in the type hierarchy, just don't add
+        // any members to the map.
+        return;
+      }
+      type = mixins.last;
+    }
     List<MethodElement> methods = type.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) &&
           !method.isStatic &&
           (doIncludeAbstract || !method.isAbstract)) {
         map[method.name] = method;
       }
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
@@ skipping 222 matching lines @@
    * @param lookupMaps the maps to be unioned together.
    * @return the resulting union map.
    */
   HashMap<String, List<ExecutableElement>> _unionInterfaceLookupMaps(
       List<Map<String, ExecutableElement>> lookupMaps) {
     HashMap<String, List<ExecutableElement>> unionMap =
         new HashMap<String, List<ExecutableElement>>();
     for (Map<String, ExecutableElement> lookupMap in lookupMaps) {
       for (String memberName in lookupMap.keys) {
         // Get the list value out of the unionMap
-        List<ExecutableElement> list = unionMap[memberName];
-        // If we haven't created such a map for this key yet, do create it and
-        // put the list entry into the unionMap.
-        if (list == null) {
-          list = new List<ExecutableElement>();
-          unionMap[memberName] = list;
-        }
+        List<ExecutableElement> list = unionMap.putIfAbsent(
+            memberName, () => new List<ExecutableElement>());
         // Fetch the entry out of this lookupMap
         ExecutableElement newExecutableElementEntry = lookupMap[memberName];
         if (list.isEmpty) {
           // If the list is empty, just the new value
           list.add(newExecutableElementEntry);
         } else {
           // Otherwise, only add the newExecutableElementEntry if it isn't
           // already in the list, this covers situation where a class inherits
           // two methods (or two getters) that are identical.
           bool alreadyInList = false;
@@ skipping 359 matching lines @@
   }
 
   /**
    * Initializes [keys] and [values].
    */
   void _initArrays(int initialCapacity) {
     _keys = new List<String>(initialCapacity);
     _values = new List<ExecutableElement>(initialCapacity);
   }
 }