Update 'analysis.override' notification to the latest spec.

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/computer/element.dart';
 import 'package:analysis_services/constants.dart';
 import 'package:analysis_services/json.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 49 matching lines @@
     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);
       }
     }
     // is there any override?
     if (superEngineElement != null || interfaceEngineElements.isNotEmpty) {
-      Element superElement = superEngineElement != null ?
-          new Element.fromEngine(superEngineElement) : null;
-      List<Element> interfaceElements = interfaceEngineElements.map(
-          (engineElement) {
-        return new Element.fromEngine(engineElement);
-      }).toList();
-      _overrides.add(new Override(offset, length, superElement,
-          interfaceElements));
+      OverriddenMember superMember = superEngineElement != null ?
+          OverriddenMember.fromEngine(superEngineElement) :
+          null;
+      List<OverriddenMember> interfaceMembers =
+          interfaceEngineElements.map(OverriddenMember.fromEngine).toList();
+      _overrides.add(
+          new Override(offset, length, superMember, interfaceMembers));
     }
   }
 
   static engine.Element _lookupMember(engine.ClassElement classElement,
       String name) {
     if (classElement == null) {
       return null;
     }
     engine.LibraryElement library = classElement.library;
     // method
@@ skipping 10 matching lines @@
     member = classElement.lookUpSetter(name + '=', library);
     if (member != null) {
       return member;
     }
     // not found
     return null;
   }
 }
 
 
+class OverriddenMember implements HasToJson {
+  final Element element;
+  final String className;
+
+  OverriddenMember(this.element, this.className);
+
+  Map<String, Object> toJson() {
+    return {
+      ELEMENT: element.toJson(),
+      CLASS_NAME: className
+    };
+  }
+
+  @override
+  String toString() => toJson().toString();
+
+  static OverriddenMember fromEngine(engine.Element member) {
+    Element element = new Element.fromEngine(member);
+    String className = member.enclosingElement.displayName;
+    return new OverriddenMember(element, className);
+  }
+
+  static OverriddenMember fromJson(Map<String, Object> json) {
+    Map<String, Object> elementJson = json[ELEMENT];
+    Element element = new Element.fromJson(elementJson);
+    String className = json[CLASS_NAME];
+    return new OverriddenMember(element, className);
+  }
+}
+
+
 class Override implements HasToJson {
   final int offset;
   final int length;
-  final Element superclassElement;
-  final List<Element> interfaceElements;
+  final OverriddenMember superclassMember;
+  final List<OverriddenMember> interfaceMembers;
 
-  Override(this.offset, this.length, this.superclassElement,
-      this.interfaceElements);
-
-  factory Override.fromJson(Map<String, Object> map) {
-    int offset = map[OFFSET];
-    int length = map[LENGTH];
-    // super
-    Element superclassElement = null;
-    {
-      Map<String, Object> superJson = map[SUPER_CLASS_ELEMENT];
-      if (superJson != null) {
-        superclassElement = new Element.fromJson(superJson);
-      }
-    }
-    // interfaces
-    List<Element> interfaceElements = null;
-    {
-      List<Map<String, Object>> jsonList = map[INTERFACE_ELEMENTS];
-      if (jsonList != null) {
-        interfaceElements = <Element>[];
-        for (Map<String, Object> json in jsonList) {
-          interfaceElements.add(new Element.fromJson(json));
-        }
-      }
-    }
-    // done
-    return new Override(offset, length, superclassElement, interfaceElements);
-  }
+  Override(this.offset, this.length, this.superclassMember,
+      this.interfaceMembers);
 
   Map<String, Object> toJson() {
     Map<String, Object> json = <String, Object>{};
     json[OFFSET] = offset;
     json[LENGTH] = length;
-    if (superclassElement != null) {
-      json[SUPER_CLASS_ELEMENT] = superclassElement.toJson();
+    if (superclassMember != null) {
+      json[SUPER_CLASS_MEMBER] = superclassMember.toJson();
     }
-    if (interfaceElements != null && interfaceElements.isNotEmpty) {
-      json[INTERFACE_ELEMENTS] = interfaceElements.map((element) {
-        return element.toJson();
-      }).toList();
+    if (interfaceMembers != null && interfaceMembers.isNotEmpty) {
+      json[INTERFACE_MEMBERS] = objectToJson(interfaceMembers);
     }
     return json;
   }
 
   @override
   String toString() => toJson().toString();
+
+  static Override fromJson(Map<String, Object> map) {
+    int offset = map[OFFSET];
+    int length = map[LENGTH];
+    // super
+    OverriddenMember superclassMember = null;
+    {
+      Map<String, Object> superJson = map[SUPER_CLASS_MEMBER];
+      if (superJson != null) {
+        superclassMember = OverriddenMember.fromJson(superJson);
+      }
+    }
+    // interfaces
+    List<OverriddenMember> interfaceElements = null;
+    {
+      List<Map<String, Object>> jsonList = map[INTERFACE_MEMBERS];
+      if (jsonList != null) {
+        interfaceElements = jsonList.map(OverriddenMember.fromJson).toList();
+      }
+    }
+    // done
+    return new Override(offset, length, superclassMember, interfaceElements);
+  }
 }