Issue 25538. Fix for notification and private methods.

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/dart/element/element.dart' as engine;
 import 'package:analyzer/dart/element/type.dart' as engine;
@@ skipping 35 matching lines @@
    */
   List<Override> compute() {
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         _currentClass = unitMember.element;
         for (ClassMember classMember in unitMember.members) {
           if (classMember is MethodDeclaration) {
             if (classMember.isStatic) {
               continue;
             }
-            SimpleIdentifier nameNode = classMember.name;
+            SimpleIdentifier name = classMember.name;
             List<ElementKind> kinds;
             if (classMember.isGetter) {
               kinds = GETTER_KINDS;
             } else if (classMember.isSetter) {
               kinds = SETTER_KINDS;
             } else {
               kinds = METHOD_KINDS;
             }
-            _addOverride(
-                nameNode.offset, nameNode.length, nameNode.name, kinds);
+            new _SingleOverrideComputer(_currentClass, name, kinds)
+                .addOverrideTo(_overrides);
           }
           if (classMember is FieldDeclaration) {
             if (classMember.isStatic) {
               continue;
             }
             List<VariableDeclaration> fields = classMember.fields.variables;
             for (VariableDeclaration field in fields) {
-              SimpleIdentifier nameNode = field.name;
-              _addOverride(
-                  nameNode.offset, nameNode.length, nameNode.name, FIELD_KINDS);
+              SimpleIdentifier name = field.name;
+              new _SingleOverrideComputer(_currentClass, name, FIELD_KINDS)
+                  .addOverrideTo(_overrides);
             }
           }
         }
       }
     }
     return _overrides;
   }
+}
+
+/**
+ * Computer for [Override] for a single declaration.
+ */
+class _SingleOverrideComputer {
+  final engine.LibraryElement currentLibrary;
+  final engine.ClassElement currentClass;
+  final SimpleIdentifier node;
+  final String name;
+  final List<ElementKind> kinds;
+
+  _SingleOverrideComputer(
+      engine.ClassElement currentClass, SimpleIdentifier node, this.kinds)
+      : currentClass = currentClass,
+        currentLibrary = currentClass.library,
+        node = node,
+        name = node.name;
+
+  /**
+   * Add a new [Override] for this declaration to the given [overrides].
+   */
+  void addOverrideTo(List<Override> overrides) {
+    // super
+    engine.Element superEngineElement;
+    {
+      engine.InterfaceType superType = currentClass.supertype;
+      if (superType != null) {
+        superEngineElement = _lookupMember(superType.element);
+      }
+    }
+    // interfaces
+    Set<engine.Element> interfaceEngineElements = new Set<engine.Element>();
+    _addInterfaceOverrides(interfaceEngineElements, currentClass.type, false,
+        new Set<engine.InterfaceType>());
+    interfaceEngineElements.remove(superEngineElement);
+    // is there any override?
+    if (superEngineElement != null || interfaceEngineElements.isNotEmpty) {
+      OverriddenMember superMember = superEngineElement != null
+          ? newOverriddenMember_fromEngine(superEngineElement)
+          : null;
+      List<OverriddenMember> interfaceMembers = interfaceEngineElements
+          .map((member) => newOverriddenMember_fromEngine(member))
+          .toList();
+      overrides.add(new Override(node.offset, node.length,
+          superclassMember: superMember,
+          interfaceMembers: nullIfEmpty(interfaceMembers)));
+    }
+  }
 
   void _addInterfaceOverrides(
       Set<engine.Element> elements,
-      String name,
-      List<ElementKind> kinds,
       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, kinds);
+      engine.Element element = _lookupMember(type.element);
       if (element != null) {
         elements.add(element);
         return;
       }
     }
     // check interfaces
     for (engine.InterfaceType interfaceType in type.interfaces) {
-      _addInterfaceOverrides(
-          elements, name, kinds, interfaceType, true, visited);
+      _addInterfaceOverrides(elements, interfaceType, true, visited);
     }
     // check super
-    _addInterfaceOverrides(
-        elements, name, kinds, type.superclass, checkType, visited);
+    _addInterfaceOverrides(elements, type.superclass, checkType, visited);
   }
 
-  void _addOverride(
-      int offset, int length, String name, List<ElementKind> kinds) {
-    // super
-    engine.Element superEngineElement;
-    {
-      engine.InterfaceType superType = _currentClass.supertype;
-      if (superType != null) {
-        superEngineElement = _lookupMember(superType.element, name, kinds);
-      }
-    }
-    // interfaces
-    Set<engine.Element> interfaceEngineElements = new Set<engine.Element>();
-    _addInterfaceOverrides(interfaceEngineElements, name, kinds,
-        _currentClass.type, false, new Set<engine.InterfaceType>());
-    interfaceEngineElements.remove(superEngineElement);
-    // is there any override?
-    if (superEngineElement != null || interfaceEngineElements.isNotEmpty) {
-      OverriddenMember superMember = superEngineElement != null
-          ? newOverriddenMember_fromEngine(superEngineElement)
-          : null;
-      List<OverriddenMember> interfaceMembers = interfaceEngineElements
-          .map((member) => newOverriddenMember_fromEngine(member))
-          .toList();
-      _overrides.add(new Override(offset, length,
-          superclassMember: superMember,
-          interfaceMembers: nullIfEmpty(interfaceMembers)));
-    }
-  }
-
-  static engine.Element _lookupMember(
-      engine.ClassElement classElement, String name, List<ElementKind> kinds) {
+  engine.Element _lookupMember(engine.ClassElement classElement) {
     if (classElement == null) {
       return null;
     }
-    engine.LibraryElement library = classElement.library;
     engine.Element member;
     // method
     if (kinds.contains(ElementKind.METHOD)) {
-      member = classElement.lookUpMethod(name, library);
+      member = classElement.lookUpMethod(name, currentLibrary);
       if (member != null) {
         return member;
       }
     }
     // getter
     if (kinds.contains(ElementKind.GETTER)) {
-      member = classElement.lookUpGetter(name, library);
+      member = classElement.lookUpGetter(name, currentLibrary);
       if (member != null) {
         return member;
       }
     }
     // setter
     if (kinds.contains(ElementKind.SETTER)) {
-      member = classElement.lookUpSetter(name + '=', library);
+      member = classElement.lookUpSetter(name + '=', currentLibrary);
       if (member != null) {
         return member;
       }
     }
     // not found
     return null;
   }
 }