Remove UriReferencedElement with its uri/uriOffset/uriEnd properties.

pkg/analyzer/test/src/summary/resynthesize_common.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 test.src.serialization.elements_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 255 matching lines @@
     }
     compareTypes(r.type, o.type, desc);
     if (r is ClassElementImpl && o is ClassElementImpl) {
       expect(r.hasBeenInferred, o.hasBeenInferred, reason: desc);
     }
   }
 
   void compareCompilationUnitElements(CompilationUnitElementImpl resynthesized,
       CompilationUnitElementImpl original) {
     String desc = 'Compilation unit ${original.source.uri}';
-    compareUriReferencedElements(resynthesized, original, desc);
     expect(resynthesized.source, original.source);
     expect(resynthesized.librarySource, original.librarySource);
     compareLineInfo(resynthesized.lineInfo, original.lineInfo);
     expect(resynthesized.types.length, original.types.length,
         reason: '$desc.types.length');
     for (int i = 0; i < resynthesized.types.length; i++) {
       compareClassElements(
           resynthesized.types[i], original.types[i], original.types[i].name);
     }
     expect(resynthesized.topLevelVariables.length,
@@ skipping 469 matching lines @@
       compareTypeParameterElements(
           resynthesized.typeParameters[i],
           original.typeParameters[i],
           '$desc type parameter ${original.typeParameters[i].name}');
     }
     compareLocalElementsOfExecutable(resynthesized, original, desc);
   }
 
   void compareExportElements(ExportElementImpl resynthesized,
       ExportElementImpl original, String desc) {
-    compareUriReferencedElements(resynthesized, original, desc);
     expect(resynthesized.exportedLibrary.location,
         original.exportedLibrary.location);
     expect(resynthesized.combinators.length, original.combinators.length);
     for (int i = 0; i < resynthesized.combinators.length; i++) {
       compareNamespaceCombinators(
           resynthesized.combinators[i], original.combinators[i]);
     }
   }
 
   void compareFieldElements(
@@ skipping 61 matching lines @@
     compareTypeParameterElementLists(resynthesized.typeParameters,
         original.typeParameters, '$desc.typeParameters');
     compareParameterElementLists(
         resynthesized.parameters, original.parameters, '$desc.parameters');
     compareTypes(
         resynthesized.returnType, original.returnType, '$desc.returnType');
   }
 
   void compareImportElements(ImportElementImpl resynthesized,
       ImportElementImpl original, String desc) {
-    compareUriReferencedElements(resynthesized, original, desc);
     expect(resynthesized.importedLibrary.location,
         original.importedLibrary.location,
         reason: '$desc importedLibrary location');
     expect(resynthesized.prefixOffset, original.prefixOffset,
         reason: '$desc prefixOffset');
     if (original.prefix == null) {
       expect(resynthesized.prefix, isNull, reason: '$desc prefix');
     } else {
       comparePrefixElements(
           resynthesized.prefix, original.prefix, original.prefix.name);
@@ skipping 283 matching lines @@
     } else if (resynthesized is BottomTypeImpl && original is BottomTypeImpl) {
       expect(resynthesized, same(original));
     } else if (resynthesized.runtimeType != original.runtimeType) {
       fail('Type mismatch: expected ${original.runtimeType},'
           ' got ${resynthesized.runtimeType} ($desc)');
     } else {
       fail('Unimplemented comparison for ${original.runtimeType}');
     }
   }
 
-  void compareUriReferencedElements(UriReferencedElementImpl resynthesized,
-      UriReferencedElementImpl original, String desc) {
-    compareElements(resynthesized, original, desc);
-    expect(resynthesized.uri, original.uri, reason: '$desc.uri');
-    expect(resynthesized.uriOffset, original.uriOffset,
-        reason: '$desc.uriOffset');
-    expect(resynthesized.uriEnd, original.uriEnd, reason: '$desc.uriEnd');
-  }
-
   void compareVariableElements(
       VariableElement resynthesized, VariableElement original, String desc) {
     compareElements(resynthesized, original, desc);
     compareTypes(resynthesized.type, original.type, '$desc.type');
     VariableElementImpl resynthesizedActual =
         getActualElement(resynthesized, desc);
     VariableElementImpl originalActual = getActualElement(original, desc);
     compareFunctionElements(resynthesizedActual.initializer,
         originalActual.initializer, '$desc.initializer');
     if (originalActual is ConstVariableElement) {
@@ skipping 5218 matching lines @@
 ''');
     if (isStrongMode) {
       checkElementText(library, r'''
 export 'foo.dart';
 ''');
     } else {
       checkElementText(library, r'''
 export 'foo.dart';
 ''');
     }
-    expect(library.exports[0].uri, 'foo.dart');
     expect(library.exports[0].exportedLibrary.source.shortName, 'foo.dart');
   }
 
   test_export_configurations_useFirst() async {
     context.declaredVariables.define('dart.library.io', 'true');
     context.declaredVariables.define('dart.library.html', 'true');
     addLibrarySource('/foo.dart', 'class A {}');
     addLibrarySource('/foo_io.dart', 'class A {}');
     addLibrarySource('/foo_html.dart', 'class A {}');
     var library = await checkLibrary(r'''
 export 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
     if (isStrongMode) {
       checkElementText(library, r'''
 export 'foo_io.dart';
 ''');
     } else {
       checkElementText(library, r'''
 export 'foo_io.dart';
 ''');
     }
-    expect(library.exports[0].uri, 'foo_io.dart');
     expect(library.exports[0].exportedLibrary.source.shortName, 'foo_io.dart');
   }
 
   test_export_configurations_useSecond() async {
     context.declaredVariables.define('dart.library.io', 'false');
     context.declaredVariables.define('dart.library.html', 'true');
     addLibrarySource('/foo.dart', 'class A {}');
     addLibrarySource('/foo_io.dart', 'class A {}');
     addLibrarySource('/foo_html.dart', 'class A {}');
     var library = await checkLibrary(r'''
 export 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
     if (isStrongMode) {
       checkElementText(library, r'''
 export 'foo_html.dart';
 ''');
     } else {
       checkElementText(library, r'''
 export 'foo_html.dart';
 ''');
     }
     ExportElement export = library.exports[0];
-    expect(export.uri, 'foo_html.dart');
     expect(export.exportedLibrary.source.shortName, 'foo_html.dart');
   }
 
   test_export_function() async {
     addLibrarySource('/a.dart', 'f() {}');
     var library = await checkLibrary('export "a.dart";');
     if (isStrongMode) {
       checkElementText(library, r'''
 export 'a.dart';
 ''');
@@ skipping 1350 matching lines @@
     allowMissingFiles = true;
     shouldCompareLibraryElements = false;
     var library = await checkLibrary('''
 @foo
 import '';
 ''');
     if (isStrongMode) {
       checkElementText(library, r'''
 @
         foo/*location: null*/
-import '';
+import '<unresolved>';
 ''');
     } else {
       checkElementText(library, r'''
 @
         foo/*location: null*/
-import '';
+import '<unresolved>';
 ''');
     }
   }
 
   test_import_multiple_combinators() async {
     addLibrary('dart:async');
     var library = await checkLibrary('''
 import "dart:async" hide Stream show Future;
 Future f;
 ''');
@@ skipping 56 matching lines @@
 
   test_import_short_absolute() async {
     testFile = '/my/project/bin/test.dart';
     // Note: "/a.dart" resolves differently on Windows vs. Posix.
     var destinationPath =
         resourceProvider.pathContext.fromUri(Uri.parse('/a.dart'));
     addLibrarySource(destinationPath, 'class C {}');
     var library = await checkLibrary('import "/a.dart"; C c;');
     if (isStrongMode) {
       checkElementText(library, r'''
-import '/a.dart';
+import 'a.dart';
 C c;
 ''');
     } else {
       checkElementText(library, r'''
-import '/a.dart';
+import 'a.dart';
 C c;
 ''');
     }
   }
 
   test_import_show() async {
     addLibrary('dart:async');
     var library = await checkLibrary('''
 import "dart:async" show Future, Stream;
 Future f;
@@ skipping 986 matching lines @@
 
   test_invalidUri_part_emptyUri() async {
     allowMissingFiles = true;
     shouldCompareLibraryElements = false;
     var library = await checkLibrary(r'''
 part '';
 class B extends A {}
 ''');
     if (isStrongMode) {
       checkElementText(library, r'''
-part '';
+part '<unresolved>';
 class B {
 }
 --------------------
 unit: null
 
 ''');
     } else {
       checkElementText(library, r'''
-part '';
+part '<unresolved>';
 class B {
 }
 --------------------
 unit: null
 
 ''');
     }
   }
 
   test_invalidUris() async {
     allowMissingFiles = true;
     shouldCompareLibraryElements = false;
     var library = await checkLibrary(r'''
 import '[invalid uri]';
 import '[invalid uri]:foo.dart';
 import 'a1.dart';
 import '[invalid uri]';
 import '[invalid uri]:foo.dart';
 
 export '[invalid uri]';
 export '[invalid uri]:foo.dart';
 export 'a2.dart';
 export '[invalid uri]';
 export '[invalid uri]:foo.dart';
 
 part '[invalid uri]';
 part 'a3.dart';
 part '[invalid uri]';
 ''');
-    if (isStrongMode) {
-      checkElementText(library, r'''
-import '[invalid uri]';
-import '[invalid uri]:foo.dart';
+    checkElementText(library, r'''
+import '<unresolved>';
+import '<unresolved>';
 import 'a1.dart';
-import '[invalid uri]';
-import '[invalid uri]:foo.dart';
-export '[invalid uri]';
-export '[invalid uri]:foo.dart';
+import '<unresolved>';
+import '<unresolved>';
+export '<unresolved>';
+export '<unresolved>';
 export 'a2.dart';
-export '[invalid uri]';
-export '[invalid uri]:foo.dart';
-part '[invalid uri]';
+export '<unresolved>';
+export '<unresolved>';
+part '<unresolved>';
 part 'a3.dart';
-part '[invalid uri]';
+part '<unresolved>';
 --------------------
 unit: null
 
---------------------
-unit: a3.dart
-
---------------------
-unit: null
-
-''');
-    } else {
-      checkElementText(library, r'''
-import '[invalid uri]';
-import '[invalid uri]:foo.dart';
-import 'a1.dart';
-import '[invalid uri]';
-import '[invalid uri]:foo.dart';
-export '[invalid uri]';
-export '[invalid uri]:foo.dart';
-export 'a2.dart';
-export '[invalid uri]';
-export '[invalid uri]:foo.dart';
-part '[invalid uri]';
-part 'a3.dart';
-part '[invalid uri]';
---------------------
-unit: null
-
 --------------------
 unit: a3.dart
 
 --------------------
 unit: null
 
 ''');
-    }
   }
 
   test_library() async {
     var library = await checkLibrary('');
     if (isStrongMode) {
       checkElementText(library, r'''
 ''');
     } else {
       checkElementText(library, r'''
 ''');
@@ skipping 2038 matching lines @@
   }
 
   test_parts_invalidUri() async {
     allowMissingFiles = true;
     shouldCompareLibraryElements = false;
     addSource('/foo/bar.dart', 'part of my.lib;');
     var library = await checkLibrary('library my.lib; part "foo/";');
     if (isStrongMode) {
       checkElementText(library, r'''
 library my.lib;
-part 'foo/';
+part '<unresolved>';
 --------------------
 unit: null
 
 ''');
     } else {
       checkElementText(library, r'''
 library my.lib;
-part 'foo/';
+part '<unresolved>';
 --------------------
 unit: null
 
 ''');
     }
   }
 
   test_parts_invalidUri_nullStringValue() async {
     allowMissingFiles = true;
     shouldCompareLibraryElements = false;
     addSource('/foo/bar.dart', 'part of my.lib;');
     var library = await checkLibrary(r'''
 library my.lib;
 part "${foo}/bar.dart";
 ''');
     if (isStrongMode) {
       checkElementText(library, r'''
 library my.lib;
-part '';
+part '<unresolved>';
 --------------------
 unit: null
 
 ''');
     } else {
       checkElementText(library, r'''
 library my.lib;
-part '';
+part '<unresolved>';
 --------------------
 unit: null
 
 ''');
     }
   }
 
   test_propagated_type_refers_to_closure() async {
     var library = await checkLibrary('''
 void f() {
@@ skipping 773 matching lines @@
     }
   }
 
   test_type_reference_to_import_export_export_in_subdirs() async {
     addLibrarySource('/a/a.dart', 'export "b/b.dart";');
     addLibrarySource('/a/b/b.dart', 'export "../c/c.dart";');
     addLibrarySource('/a/c/c.dart', 'class C {} enum E { v } typedef F();');
     var library = await checkLibrary('import "a/a.dart"; C c; E e; F f;');
     if (isStrongMode) {
       checkElementText(library, r'''
-import 'a/a.dart';
+import 'a.dart';
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(library, r'''
-import 'a/a.dart';
+import 'a.dart';
 C c;
 E e;
 F f;
 ''');
     }
   }
 
   test_type_reference_to_import_export_in_subdirs() async {
     addLibrarySource('/a/a.dart', 'export "b/b.dart";');
     addLibrarySource('/a/b/b.dart', 'class C {} enum E { v } typedef F();');
     var library = await checkLibrary('import "a/a.dart"; C c; E e; F f;');
     if (isStrongMode) {
       checkElementText(library, r'''
-import 'a/a.dart';
+import 'a.dart';
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(library, r'''
-import 'a/a.dart';
+import 'a.dart';
 C c;
 E e;
 F f;
 ''');
     }
   }
 
   test_type_reference_to_import_part() async {
     addLibrarySource('/a.dart', 'library l; part "b.dart";');
     addSource('/b.dart', 'part of l; class C {} enum E { v } typedef F();');
@@ skipping 34 matching lines @@
 ''');
     }
   }
 
   test_type_reference_to_import_part_in_subdir() async {
     addLibrarySource('/a/b.dart', 'library l; part "c.dart";');
     addSource('/a/c.dart', 'part of l; class C {} enum E { v } typedef F();');
     var library = await checkLibrary('import "a/b.dart"; C c; E e; F f;');
     if (isStrongMode) {
       checkElementText(library, r'''
-import 'a/b.dart';
+import 'b.dart';
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(library, r'''
-import 'a/b.dart';
+import 'b.dart';
 C c;
 E e;
 F f;
 ''');
     }
   }
 
   test_type_reference_to_import_relative() async {
     addLibrarySource('/a.dart', 'class C {} enum E { v } typedef F();');
     var library = await checkLibrary('import "a.dart"; C c; E e; F f;');
@@ skipping 1159 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }