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

pkg/analysis_server/test/analysis_notification_overrides_test.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 test.domain.analysis.notification.overrides;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/computer/computer_overrides.dart';
-import 'package:analysis_server/src/computer/element.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_services/constants.dart';
 import 'package:analysis_testing/reflective_tests.dart';
 import 'package:unittest/unittest.dart';
 
 import 'analysis_abstract.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisNotificationOverridesTest);
 }
 
 
 @ReflectiveTestCase()
 class AnalysisNotificationOverridesTest extends AbstractAnalysisTest {
   List<Override> overridesList;
   Override override;
 
   /**
-   * Asserts that there is an overridden interface [Element] at the offset of
-   * [search] in [override].
+   * Asserts that there is an overridden interface [OverriddenMember] at the
+   * offset of [search] in [override].
    */
-  void assertHasInterfaceElement(String search) {
+  void assertHasInterfaceMember(String search) {
     int offset = findOffset(search);
-    for (Element element in override.interfaceElements) {
-      if (element.location.offset == offset) {
+    for (OverriddenMember member in override.interfaceMembers) {
+      if (member.element.location.offset == offset) {
         return;
       }
     }
     fail(
-        'Expect to find an overridden interface elements at $offset in '
-            '${override.interfaceElements.join('\n')}');
+        'Expect to find an overridden interface members at $offset in '
+            '${override.interfaceMembers.join('\n')}');
   }
 
   /**
    * Validates that there is an [Override] at the offset of [search].
    *
    * If [length] is not specified explicitly, then length of an identifier
    * from [search] is used.
    */
   void assertHasOverride(String search, [int length = -1]) {
     int offset = findOffset(search);
     if (length == -1) {
       length = findIdentifierLength(search);
     }
     findOverride(offset, length, true);
   }
 
   /**
-   * Asserts that there is an overridden superclass [Element] at the offset of
-   * [search] in [override].
+   * Asserts that there is an overridden superclass [OverriddenMember] at the
+   * offset of [search] in [override].
    */
   void assertHasSuperElement(String search) {
     int offset = findOffset(search);
-    Element element = override.superclassElement;
-    expect(element.location.offset, offset);
+    OverriddenMember member = override.superclassMember;
+    expect(member.element.location.offset, offset);
   }
 
   /**
-   * Asserts that there are no overridden elements from interfaces.
+   * Asserts that there are no overridden members from interfaces.
    */
-  void assertNoInterfaceElements() {
-    expect(override.interfaceElements, isNull);
+  void assertNoInterfaceMembers() {
+    expect(override.interfaceMembers, isNull);
   }
 
   /**
-   * Asserts that there are no overridden elements from the superclass.
+   * Asserts that there are no overridden member from the superclass.
    */
-  void assertNoSuperElement() {
-    expect(override.superclassElement, isNull);
+  void assertNoSuperMember() {
+    expect(override.superclassMember, isNull);
   }
 
   /**
    * Finds an [Override] with the given [offset] and [length].
    *
    * If [exists] is `true`, then fails if such [Override] does not exist.
    * Otherwise remembers this it into [override].
    *
    * If [exists] is `false`, then fails if such [Override] exists.
    */
@@ skipping 18 matching lines @@
 
   Future prepareOverrides() {
     addAnalysisSubscription(AnalysisService.OVERRIDES, testFile);
     return waitForTasksFinished();
   }
 
   void processNotification(Notification notification) {
     if (notification.event == ANALYSIS_OVERRIDES) {
       String file = notification.getParameter(FILE);
       if (file == testFile) {
-        overridesList = <Override>[];
         List<Map<String, Object>> jsonList =
             notification.getParameter(OVERRIDES);
-        for (Map<String, Object> json in jsonList) {
-          overridesList.add(new Override.fromJson(json));
-        }
+        overridesList = jsonList.map(Override.fromJson).toList();
       }
     }
   }
 
   void setUp() {
     super.setUp();
     createProject();
   }
 
   test_afterAnalysis() {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B implements A {
   m() {} // in B
 }
 ''');
     return waitForTasksFinished().then((_) {
       return prepareOverrides().then((_) {
         assertHasOverride('m() {} // in B');
-        assertNoSuperElement();
-        assertHasInterfaceElement('m() {} // in A');
+        assertNoSuperMember();
+        assertHasInterfaceMember('m() {} // in A');
       });
     });
   }
 
   test_interface_method_direct_multiple() {
     addTestFile('''
 class IA {
   m() {} // in IA
 }
 class IB {
   m() {} // in IB
 }
 class A implements IA, IB {
   m() {} // in A
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('m() {} // in A');
-      assertNoSuperElement();
-      assertHasInterfaceElement('m() {} // in IA');
-      assertHasInterfaceElement('m() {} // in IB');
+      assertNoSuperMember();
+      assertHasInterfaceMember('m() {} // in IA');
+      assertHasInterfaceMember('m() {} // in IB');
     });
   }
 
   test_interface_method_direct_single() {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B implements A {
   m() {} // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('m() {} // in B');
-      assertNoSuperElement();
-      assertHasInterfaceElement('m() {} // in A');
+      assertNoSuperMember();
+      assertHasInterfaceMember('m() {} // in A');
     });
   }
 
   test_interface_method_indirect_single() {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
 }
 class C implements B {
   m() {} // in C
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('m() {} // in C');
-      assertNoSuperElement();
-      assertHasInterfaceElement('m() {} // in A');
+      assertNoSuperMember();
+      assertHasInterfaceMember('m() {} // in A');
     });
   }
 
   test_super_fieldByField() {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   int fff; // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff; // in B');
       assertHasSuperElement('fff; // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_fieldByGetter() {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   get fff => 0; // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff => 0; // in B');
       assertHasSuperElement('fff; // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_fieldByMethod() {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   fff() {} // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff() {} // in B');
       assertHasSuperElement('fff; // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_fieldBySetter() {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   set fff(x) {} // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff(x) {} // in B');
       assertHasSuperElement('fff; // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_getterByField() {
     addTestFile('''
 class A {
   get fff => 0; // in A
   set fff(x) {} // in A
 }
 class B extends A {
   int fff; // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff; // in B');
       assertHasSuperElement('fff => 0; // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_getterByGetter() {
     addTestFile('''
 class A {
   get fff => 0; // in A
 }
 class B extends A {
   get fff => 0; // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff => 0; // in B');
       assertHasSuperElement('fff => 0; // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_method_direct() {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
   m() {} // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('m() {} // in B');
       assertHasSuperElement('m() {} // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_method_indirect() {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
 }
 class C extends B {
   m() {} // in C
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('m() {} // in C');
       assertHasSuperElement('m() {} // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 
   test_super_setterBySetter() {
     addTestFile('''
 class A {
   set fff(x) {} // in A
 }
 class B extends A {
   set fff(x) {} // in B
 }
 ''');
     return prepareOverrides().then((_) {
       assertHasOverride('fff(x) {} // in B');
       assertHasSuperElement('fff(x) {} // in A');
-      assertNoInterfaceElements();
+      assertNoInterfaceMembers();
     });
   }
 }