Update navigation computer to include Element instead of id.

pkg/analysis_server/test/analysis_notification_navigation_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.navigation;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.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:unittest/unittest.dart';
 
 import 'analysis_abstract.dart';
 import 'reflective_tests.dart';
 
 
 main() {
   group('notification.navigation', () {
     runReflectiveTests(_AnalysisNotificationNavigationTest);
   });
 }
 
 
 @ReflectiveTestCase()
 class _AnalysisNotificationNavigationTest extends AbstractAnalysisTest {
   List<_NavigationRegion> regions;
   _NavigationRegion testRegion;
   List<_NavigationTarget> testTargets;
+  _NavigationTarget testTarget;
 
-  @override
-  void setUp() {
-    super.setUp();
-    createProject();
+  /**
+   * Validates that there is a target in [testTargets]  with [file], at [offset]
+   * and with the given [length].
+   */
+  void assertHasFileTarget(String file, int offset, int length) {
+    for (_NavigationTarget target in testTargets) {
+      if (target.file == file && target.offset == offset && target.length ==
+          length) {
+        testTarget = target;
+        return;
+      }
+    }
+    fail(
+        'Expected to find target (file=$file; offset=$offset; length=$length) in\n'
+        '${testRegion} in\n' '${regions.join('\n')}');
   }
 
-  void processNotification(Notification notification) {
-    if (notification.event == ANALYSIS_NAVIGATION) {
-      String file = notification.getParameter(FILE);
-      if (file == testFile) {
-        regions = [];
-        List<Map<String, Object>> regionsJson = notification.getParameter(REGIONS);
-        for (Map<String, Object> regionJson in regionsJson) {
-          var regionOffset = regionJson['offset'];
-          var regionLength = regionJson['length'];
-          List<_NavigationTarget> targets = [];
-          for (Map<String, Object> targetJson in regionJson['targets']) {
-            var targetFile = targetJson['file'];
-            var targetOffset = targetJson['offset'];
-            var targetLength = targetJson['length'];
-            targets.add(new _NavigationTarget(targetFile, targetOffset, targetLength));
-          }
-          var region = new _NavigationRegion(regionOffset, regionLength, targets);
-          regions.add(region);
-        }
-      }
-    }
-  }
-
-  Future prepareNavigation(then()) {
-    addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
-    return waitForTasksFinished().then((_) {
-      then();
-    });
+  void assertHasOperatorRegion(String regionSearch, int regionLength,
+      String targetSearch, int targetLength) {
+    assertHasRegion(regionSearch, regionLength);
+    assertHasTarget(targetSearch, targetLength);
   }
 
   /**
-   * Finds the navigation region with the given [offset] and [length].
-   * If [length] is `-1`, then it is ignored.
-   *
-   * If [exists] is `true`, then fails if such region does not exist.
-   * Otherwise remembers this it into [testRegion].
-   * Also fills [testTargets] with its targets.
-   *
-   * If [exists] is `false`, then fails if such region exists.
-   */
-  void findRegion(int offset, int length, [bool exists]) {
-    for (_NavigationRegion region in regions) {
-      if (region.offset == offset &&
-          (length == -1 || region.length == length)) {
-        if (exists == false) {
-          fail('Not expected to find (offset=$offset; length=$length) in\n'
-               '${regions.join('\n')}');
-        }
-        testRegion = region;
-        testTargets = region.targets;
-        return;
-      }
-    }
-    if (exists == true) {
-      fail('Expected to find (offset=$offset; length=$length) in\n'
-           '${regions.join('\n')}');
-    }
-  }
-
-  /**
    * Validates that there is a region at the offset of [search] in [testFile].
    * If [length] is not specified explicitly, then length of an identifier
    * from [search] is used.
    */
   void assertHasRegion(String search, [int length = -1]) {
     int offset = findOffset(search);
     if (length == -1) {
       length = findIdentifierLength(search);
     }
     findRegion(offset, length, true);
   }
 
   /**
    * Validates that there is a region at the offset of [search] in [testFile]
    * with the length of [search].
    */
   void assertHasRegionString(String search) {
     int offset = findOffset(search);
     int length = search.length;
     findRegion(offset, length, true);
   }
 
   /**
+   * Validates that there is an identifier region at [regionSearch] with target
+   * at [targetSearch].
+   */
+  void assertHasRegionTarget(String regionSearch, String targetSearch) {
+    assertHasRegion(regionSearch);
+    assertHasTarget(targetSearch);
+  }
+
+  /**
    * Validates that there is a target in [testTargets]  with [testFile], at the
    * offset of [search] in [testFile], and with the given [length] or the length
    * of an leading identifier in [search].
    */
   void assertHasTarget(String search, [int length = -1]) {
     int offset = findOffset(search);
     if (length == -1) {
       length = findIdentifierLength(search);
     }
     assertHasFileTarget(testFile, offset, length);
   }
 
   /**
-   * Validates that there is a target in [testTargets]  with [file], at [offset]
-   * and with the given [length].
-   */
-  void assertHasFileTarget(String file, int offset, int length) {
-    for (_NavigationTarget target in testTargets) {
-      if (target.file == file &&
-          target.offset == offset &&
-          target.length == length) {
-        return;
-      }
-    }
-    fail('Expected to find target (file=$file; offset=$offset; length=$length) in\n'
-         '${testRegion} in\n'
-         '${regions.join('\n')}');
-  }
-
-  /**
-   * Validates that there is an identifier region at [regionSearch] with target
-   * at [targetSearch].
-   */
-  void assertHasRegionTarget(String regionSearch, String targetSearch) {
-    assertHasRegion(regionSearch);
-    assertHasTarget(targetSearch);
-  }
-
-  void assertHasOperatorRegion(String regionSearch, int regionLength,
-                               String targetSearch, int targetLength) {
-    assertHasRegion(regionSearch, regionLength);
-    assertHasTarget(targetSearch, targetLength);
-  }
-
-  /**
    * Validates that there is no a region at [search] and with the given
    * [length].
    */
   void assertNoRegion(String search, int length) {
     int offset = findOffset(search);
     findRegion(offset, length, false);
   }
 
   /**
    * Validates that there is no a region at [search] with any length.
    */
   void assertNoRegionAt(String search) {
     int offset = findOffset(search);
     findRegion(offset, -1, false);
   }
 
   /**
    * Validates that there is no a region for [search] string.
    */
   void assertNoRegionString(String search) {
     int offset = findOffset(search);
     int length = search.length;
     findRegion(offset, length, false);
   }
 
+  /**
+   * Finds the navigation region with the given [offset] and [length].
+   * If [length] is `-1`, then it is ignored.
+   *
+   * If [exists] is `true`, then fails if such region does not exist.
+   * Otherwise remembers this it into [testRegion].
+   * Also fills [testTargets] with its targets.
+   *
+   * If [exists] is `false`, then fails if such region exists.
+   */
+  void findRegion(int offset, int length, [bool exists]) {
+    for (_NavigationRegion region in regions) {
+      if (region.offset == offset && (length == -1 || region.length == length))
+          {
+        if (exists == false) {
+          fail('Not expected to find (offset=$offset; length=$length) in\n'
+              '${regions.join('\n')}');
+        }
+        testRegion = region;
+        testTargets = region.targets;
+        return;
+      }
+    }
+    if (exists == true) {
+      fail('Expected to find (offset=$offset; length=$length) in\n'
+          '${regions.join('\n')}');
+    }
+  }
+
+  Future prepareNavigation(then()) {
+    addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
+    return waitForTasksFinished().then((_) {
+      then();
+    });
+  }
+
+  void processNotification(Notification notification) {
+    if (notification.event == ANALYSIS_NAVIGATION) {
+      String file = notification.getParameter(FILE);
+      if (file == testFile) {
+        regions = [];
+        List<Map<String, Object>> regionsJson = notification.getParameter(
+            REGIONS);
+        for (Map<String, Object> regionJson in regionsJson) {
+          var regionOffset = regionJson[OFFSET];
+          var regionLength = regionJson[LENGTH];
+          List<_NavigationTarget> targets = [];
+          for (Map<String, Object> targetJson in regionJson[TARGETS]) {
+            var targetFile = targetJson[FILE];
+            var targetOffset = targetJson[OFFSET];
+            var targetLength = targetJson[LENGTH];
+            var elementJson = targetJson[ELEMENT];
+            targets.add(new _NavigationTarget(targetFile, targetOffset,
+                targetLength, new Element.fromJson(elementJson)));
+          }
+          var region = new _NavigationRegion(regionOffset, regionLength,
+              targets);
+          regions.add(region);
+        }
+      }
+    }
+  }
+
+  @override
+  void setUp() {
+    super.setUp();
+    createProject();
+  }
+
+  test_afterAnalysis() {
+    addTestFile('''
+class AAA {}
+AAA aaa;
+''');
+    return waitForTasksFinished().then((_) {
+      return prepareNavigation(() {
+        assertHasRegionTarget('AAA aaa;', 'AAA {}');
+      });
+    });
+  }
+
   test_constructor_named() {
     addTestFile('''
 class A {
   A.named(BBB p) {}
 }
 class BBB {}
 ''');
     return prepareNavigation(() {
       // has region for complete "A.named"
       assertHasRegionString('A.named');
@@ skipping 27 matching lines @@
 class AAA {
   int fff = 123;
   AAA(this.fff);
 }
 ''');
     return prepareNavigation(() {
       assertHasRegionTarget('fff);', 'fff = 123');
     });
   }
 
-  test_afterAnalysis() {
-    addTestFile('''
-class AAA {}
-AAA aaa;
-''');
-    return waitForTasksFinished().then((_) {
-      return prepareNavigation(() {
-        assertHasRegionTarget('AAA aaa;', 'AAA {}');
-      });
-    });
-  }
-
   test_identifier_resolved() {
     addTestFile('''
 class AAA {}
 main() {
   AAA aaa = null;
   print(aaa);
 }
 ''');
     return prepareNavigation(() {
       assertHasRegionTarget('AAA aaa', 'AAA {}');
@@ skipping 188 matching lines @@
     // TODO(scheglov) why do we throw MemoryResourceException here?
     // This Source/File does not exist.
 //    addTestFile('''
 //library lib;
 //part "test_unit.dart";
 //''');
 //    return prepareNavigation(() {
 //      assertNoRegionString('part "test_unit.dart"');
 //    });
   }
+
+  test_targetElement() {
+    addTestFile('''
+class AAA {}
+main() {
+  AAA aaa = null;
+}
+''');
+    return prepareNavigation(() {
+      assertHasRegionTarget('AAA aaa', 'AAA {}');
+      Element element = testTarget.element;
+      expect(element.kind, ElementKind.CLASS);
+      expect(element.name, 'AAA');
+      expect(element.isAbstract, false);
+      expect(element.parameters, isNull);
+      expect(element.returnType, isNull);
+    });
+  }
 }
 
 
 class _NavigationRegion {
   final int offset;
   final int length;
   final List<_NavigationTarget> targets;
 
   _NavigationRegion(this.offset, this.length, this.targets);
 }
 
 
 class _NavigationTarget {
   final String file;
   final int offset;
   final int length;
+  final Element element;
 
-  _NavigationTarget(this.file, this.offset, this.length);
+  _NavigationTarget(this.file, this.offset, this.length, this.element);
 }