Issue 25244. Disable invalid overrides.

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;
 
 /**
  * A computer for class member overrides in a Dart [CompilationUnit].
  */
 class DartUnitOverridesComputer {
+  static const List<ElementKind> FIELD_KINDS = const <ElementKind>[
+    ElementKind.FIELD,
+    ElementKind.GETTER,
+    ElementKind.SETTER
+  ];
+
+  static const List<ElementKind> GETTER_KINDS = const <ElementKind>[
+    ElementKind.FIELD,
+    ElementKind.GETTER
+  ];
+
+  static const List<ElementKind> METHOD_KINDS = const <ElementKind>[
+    ElementKind.METHOD
+  ];
+
+  static const List<ElementKind> SETTER_KINDS = const <ElementKind>[
+    ElementKind.FIELD,
+    ElementKind.SETTER
+  ];
+
   final CompilationUnit _unit;
 
   final List<Override> _overrides = <Override>[];
   engine.ClassElement _currentClass;
 
   DartUnitOverridesComputer(this._unit);
 
   /**
    * Returns the computed occurrences, not `null`.
    */
   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;
-            _addOverride(nameNode.offset, nameNode.length, nameNode.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);
           }
           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);
+              _addOverride(
+                  nameNode.offset, nameNode.length, nameNode.name, FIELD_KINDS);
             }
           }
         }
       }
     }
     return _overrides;
   }
 
   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);
+      engine.Element element = _lookupMember(type.element, name, kinds);
       if (element != null) {
         elements.add(element);
         return;
       }
     }
     // check interfaces
     for (engine.InterfaceType interfaceType in type.interfaces) {
-      _addInterfaceOverrides(elements, name, interfaceType, true, visited);
+      _addInterfaceOverrides(
+          elements, name, kinds, interfaceType, true, visited);
     }
     // check super
-    _addInterfaceOverrides(elements, name, type.superclass, checkType, visited);
+    _addInterfaceOverrides(
+        elements, name, kinds, type.superclass, checkType, visited);
   }
 
-  void _addOverride(int offset, int length, String name) {
+  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);
+        superEngineElement = _lookupMember(superType.element, name, kinds);
       }
     }
     // interfaces
     Set<engine.Element> interfaceEngineElements = new Set<engine.Element>();
-    _addInterfaceOverrides(interfaceEngineElements, name, _currentClass.type,
-        false, new Set<engine.InterfaceType>());
+    _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) {
+      engine.ClassElement classElement, String name, List<ElementKind> kinds) {
     if (classElement == null) {
       return null;
     }
     engine.LibraryElement library = classElement.library;
+    engine.Element member;
     // method
-    engine.Element member = classElement.lookUpMethod(name, library);
-    if (member != null) {
-      return member;
+    if (kinds.contains(ElementKind.METHOD)) {
+      member = classElement.lookUpMethod(name, library);
+      if (member != null) {
+        return member;
+      }
     }
     // getter
-    member = classElement.lookUpGetter(name, library);
-    if (member != null) {
-      return member;
+    if (kinds.contains(ElementKind.GETTER)) {
+      member = classElement.lookUpGetter(name, library);
+      if (member != null) {
+        return member;
+      }
     }
     // setter
-    member = classElement.lookUpSetter(name + '=', library);
-    if (member != null) {
-      return member;
+    if (kinds.contains(ElementKind.SETTER)) {
+      member = classElement.lookUpSetter(name + '=', library);
+      if (member != null) {
+        return member;
+      }
     }
     // not found
     return null;
   }
 }