Remove UriReferencedElement with its uri/uriOffset/uriEnd properties.

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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 analyzer.test.src.task.dart_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 276 matching lines @@
     CompilationUnit libraryUnitA = context
         .getCacheEntry(new LibrarySpecificUnit(sourceA, sourceA))
         .getValue(RESOLVED_UNIT1);
     {
       ImportDirective importNode = libraryUnitA.directives[1];
       ImportElement importElement = importNode.element;
       expect(importElement, isNotNull);
       expect(importElement.importedLibrary, libraryElementB);
       expect(importElement.prefix, isNull);
       expect(importElement.nameOffset, 14);
-      expect(importElement.uriOffset, 21);
-      expect(importElement.uriEnd, 32);
     }
     {
       ExportDirective exportNode = libraryUnitA.directives[2];
       ExportElement exportElement = exportNode.element;
       expect(exportElement, isNotNull);
       expect(exportElement.exportedLibrary, libraryElementC);
       expect(exportElement.nameOffset, 34);
-      expect(exportElement.uriOffset, 41);
-      expect(exportElement.uriEnd, 52);
     }
     // validate LibraryElement
     expect(libraryElementA.hasExtUri, isFalse);
     // has an artificial "dart:core" import
     {
       List<ImportElement> imports = libraryElementA.imports;
       expect(imports, hasLength(2));
       expect(imports[1].importedLibrary.isDartCore, isTrue);
       expect(imports[1].isSynthetic, isTrue);
     }
@@ skipping 47 matching lines @@
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
     // Perform the task.
     computeResult(testSource, LIBRARY_ELEMENT2,
         matcher: isBuildDirectiveElementsTask);
     LibraryElement testLibrary = outputs[LIBRARY_ELEMENT2];
     // Validate the export element.
     ExportElement export = testLibrary.exports[0];
     expect(export.exportedLibrary.source, foo_io);
-    expect(export.uri, 'foo_io.dart');
   }
 
   test_perform_configurations_import() {
     context.declaredVariables.define('dart.library.io', 'true');
     context.declaredVariables.define('dart.library.html', 'true');
     newSource('/foo.dart', '');
     var foo_io = newSource('/foo_io.dart', '');
     newSource('/foo_html.dart', '');
     var testSource = newSource('/test.dart', r'''
 import 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
     // Perform the task.
     computeResult(testSource, LIBRARY_ELEMENT2,
         matcher: isBuildDirectiveElementsTask);
     LibraryElement testLibrary = outputs[LIBRARY_ELEMENT2];
     // Validate the import element.
     ImportElement import = testLibrary.imports[0];
     expect(import.importedLibrary.source, foo_io);
-    expect(import.uri, 'foo_io.dart');
   }
 
   test_perform_dartCoreContext() {
     List<Source> sources = newSources({'/libA.dart': ''});
     Source source = sources[0];
     // perform task
     computeResult(source, LIBRARY_ELEMENT2,
         matcher: isBuildDirectiveElementsTask);
     // prepare outputs
     LibraryElement libraryElement = outputs[LIBRARY_ELEMENT2];
@@ skipping 394 matching lines @@
     // LibraryElement references
     expect((libraryUnit.directives[0] as LibraryDirective).element,
         same(libraryElement));
     expect((partUnits[0].directives[0] as PartOfDirective).element,
         same(libraryElement));
     expect((partUnits[1].directives[0] as PartOfDirective).element,
         same(libraryElement));
     // CompilationUnitElement(s)
     CompilationUnitElement firstPart;
     CompilationUnitElement secondPart;
-    if (resolutionMap.elementDeclaredByCompilationUnit(partUnits[0]).uri ==
+    if (resolutionMap
+            .elementDeclaredByCompilationUnit(partUnits[0])
+            .source
+            .shortName ==
         'part1.dart') {
       firstPart = partUnits[0].element;
       secondPart = partUnits[1].element;
     } else {
       firstPart = partUnits[1].element;
       secondPart = partUnits[0].element;
     }
-    expect(firstPart.uri, 'part1.dart');
-    expect(firstPart.uriOffset, 18);
-    expect(firstPart.uriEnd, 30);
+    expect(firstPart.source.shortName, 'part1.dart');
     expect(
         (libraryUnit.directives[1] as PartDirective).element, same(firstPart));
 
-    expect(secondPart.uri, 'part2.dart');
-    expect(secondPart.uriOffset, 37);
-    expect(secondPart.uriEnd, 49);
+    expect(secondPart.source.shortName, 'part2.dart');
     expect(
         (libraryUnit.directives[2] as PartDirective).element, same(secondPart));
   }
 
   test_perform_error_missingLibraryDirectiveWithPart() {
     _performBuildTask({
       '/lib.dart': '''
 part 'partA.dart';
 part 'partB.dart';
 ''',
@@ skipping 4152 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result] as List<AnalysisError>;
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }