Fix for computing overridden/implemented members from interfaces.

pkg/analysis_server/lib/src/computer/computer_overrides.dart

 // Copyright (c) 2014, 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.
 
 library computer.overrides;
 
 import 'package:analysis_server/src/collections.dart';
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart' as engine;
@@ skipping 27 matching lines @@
               SimpleIdentifier nameNode = field.name;
               _addOverride(nameNode.offset, nameNode.length, nameNode.name);
             }
           }
         }
       }
     }
     return _overrides;
   }
 
+  void _addInterfaceOverrides(List<engine.Element> elements, String name,
+      engine.InterfaceType type, bool checkType,
+      Set<engine.InterfaceType> visited) {
+    if (type == null) {
+      return;
+    }
+    if (!visited.add(type)) {
+      return;
+    }
+    // check type
+    if (checkType) {
+      engine.Element element = _lookupMember(type.element, name);
+      if (element != null) {
+        elements.add(element);
+      }
+    }
+    // check interfaces
+    for (engine.InterfaceType interfaceType in type.interfaces) {
+      _addInterfaceOverrides(elements, name, interfaceType, true, visited);
+    }
+    // check super
+    _addInterfaceOverrides(elements, name, type.superclass, true, visited);
+  }
+
   void _addOverride(int offset, int length, String name) {
     // super
     engine.Element superEngineElement;
     {
       engine.InterfaceType superType = _currentClass.supertype;
       if (superType != null) {
         superEngineElement = _lookupMember(superType.element, name);
       }
     }
     // interfaces
     List<engine.Element> interfaceEngineElements = <engine.Element>[];
-    for (engine.InterfaceType interfaceType in _currentClass.interfaces) {
-      engine.ClassElement interfaceElement = interfaceType.element;
-      engine.Element interfaceMember = _lookupMember(interfaceElement, name);
-      if (interfaceMember != null) {
-        interfaceEngineElements.add(interfaceMember);
-      }
+    if (superEngineElement == null) {
+      Set<engine.InterfaceType> visitedTypes = new Set<engine.InterfaceType>();
+      _addInterfaceOverrides(interfaceEngineElements, name, _currentClass.type,
+          false, visitedTypes);
     }
     // is there any override?
     if (superEngineElement != null || interfaceEngineElements.isNotEmpty) {
       OverriddenMember superMember = superEngineElement != null
           ? newOverriddenMember_fromEngine(superEngineElement)
           : null;
       List<OverriddenMember> interfaceMembers = interfaceEngineElements
           .map(
               (engine.Element member) => newOverriddenMember_fromEngine(member))
           .toList();
@@ skipping 21 matching lines @@
     }
     // setter
     member = classElement.lookUpSetter(name + '=', library);
     if (member != null) {
       return member;
     }
     // not found
     return null;
   }
 }