Update Element/navigation/outline to use Location.

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);
+    runReflectiveTests(AnalysisNotificationNavigationTest);
   });
 }
 
 
 @ReflectiveTestCase()
-class _AnalysisNotificationNavigationTest extends AbstractAnalysisTest {
-  List<_NavigationRegion> regions;
-  _NavigationRegion testRegion;
-  List<_NavigationTarget> testTargets;
-  _NavigationTarget testTarget;
+class AnalysisNotificationNavigationTest extends AbstractAnalysisTest {
+  List<NavigationRegion> regions;
+  NavigationRegion testRegion;
+  List<Element> testTargets;
+  Element testTarget;
 
   /**
    * 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 ==
+    for (Element target in testTargets) {
+      Location location = target.location;
+      if (location.file == file && location.offset == offset && location.length ==
           length) {
         testTarget = target;
         return;
       }
     }
     fail(
         'Expected to find target (file=$file; offset=$offset; length=$length) in\n'
         '${testRegion} in\n' '${regions.join('\n')}');
   }
 
@@ skipping 78 matching lines @@
    * 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) {
+    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 = [];
+        regions = <NavigationRegion>[];
         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 = [];
+          List<Element> targets = <Element>[];
           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)));
+            targets.add(new Element.fromJson(targetJson));
           }
-          var region = new _NavigationRegion(regionOffset, regionLength,
+          var region = new NavigationRegion(regionOffset, regionLength,
               targets);
           regions.add(region);
         }
       }
     }
   }
 
   @override
   void setUp() {
     super.setUp();
@@ skipping 270 matching lines @@
 
   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);
+      expect(testTarget.kind, ElementKind.CLASS);
+      expect(testTarget.name, 'AAA');
+      expect(testTarget.isAbstract, false);
+      expect(testTarget.parameters, isNull);
+      expect(testTarget.returnType, isNull);
     });
   }
 }
 
 
-class _NavigationRegion {
+class NavigationRegion {
   final int offset;
   final int length;
-  final List<_NavigationTarget> targets;
+  final List<Element> targets;
 
-  _NavigationRegion(this.offset, this.length, this.targets);
+  NavigationRegion(this.offset, this.length, this.targets);
+
+  @override
+  String toString() {
+    return 'NavigationRegion(offset=$offset; length=$length; targets=$targets';
+  }
 }
-
-
-class _NavigationTarget {
-  final String file;
-  final int offset;
-  final int length;
-  final Element element;
-
-  _NavigationTarget(this.file, this.offset, this.length, this.element);
-}