Remove final references to PackageUriResolver

pkg/analyzer/test/generated/resolver_test_case.dart

 // Copyright (c) 2016, 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.generated.resolver_test_case;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
-import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:unittest/unittest.dart';
 
 import 'analysis_context_factory.dart';
 import 'test_support.dart';
 
 /**
@@ skipping 438 matching lines @@
   void assertTypeOfMarkedExpression(String code, DartType expectedStaticType,
       DartType expectedPropagatedType) {
     SimpleIdentifier identifier = findMarkedIdentifier(code, "; // marker");
     if (expectedStaticType != null) {
       expect(identifier.staticType, expectedStaticType);
     }
     expect(identifier.propagatedType, expectedPropagatedType);
   }
 
   /**
-   * Cache the source file content in the source factory but don't add the source to the analysis
-   * context. The file path should be absolute.
-   *
-   * @param filePath the path of the file being cached
-   * @param contents the contents to be returned by the content provider for the specified file
-   * @return the source object representing the cached file
+   * Cache the [contents] for the file at the given [filePath] but don't add the
+   * source to the analysis context. The file path must be absolute.
    */
   Source cacheSource(String filePath, String contents) {
-    Source source = new FileBasedSource(FileUtilities2.createFile(filePath));
+    Source source =
+        PhysicalResourceProvider.INSTANCE.getFile(filePath).createSource();
     analysisContext2.setContents(source, contents);
     return source;
   }
 
   /**
    * Change the contents of the given [source] to the given [contents].
    */
   void changeSource(Source source, String contents) {
     analysisContext2.setContents(source, contents);
     ChangeSet changeSet = new ChangeSet();
@@ skipping 16 matching lines @@
    *
    * @return the library element that was created
    */
   LibraryElementImpl createDefaultTestLibrary() =>
       createTestLibrary(AnalysisContextFactory.contextWithCore(), "test");
 
   /**
    * Create a source object representing a file with the given [fileName] and
    * give it an empty content. Return the source that was created.
    */
-  FileBasedSource createNamedSource(String fileName) {
-    FileBasedSource source =
-        new FileBasedSource(FileUtilities2.createFile(fileName));
-    analysisContext2.setContents(source, "");
+  Source createNamedSource(String fileName) {
+    Source source =
+        PhysicalResourceProvider.INSTANCE.getFile(fileName).createSource();
+    analysisContext2.setContents(source, '');
     return source;
   }
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    *
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary(
       AnalysisContext context, String libraryName,
       [List<String> typeNames]) {
-    String fileName = "$libraryName.dart";
-    FileBasedSource definingCompilationUnitSource = createNamedSource(fileName);
+    String fileName = "/test/$libraryName.dart";
+    Source definingCompilationUnitSource = createNamedSource(fileName);
     List<CompilationUnitElement> sourcedCompilationUnits;
     if (typeNames == null) {
       sourcedCompilationUnits = CompilationUnitElement.EMPTY_LIST;
     } else {
       int count = typeNames.length;
       sourcedCompilationUnits = new List<CompilationUnitElement>(count);
       for (int i = 0; i < count; i++) {
         String typeName = typeNames[i];
         ClassElementImpl type =
             new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
@@ skipping 207 matching lines @@
       String typeArgs: '[]',
       String typeFormals: '[]'}) {
     typeParameters(Element element) {
       if (element is ExecutableElement) {
         return element.typeParameters;
       } else if (element is ParameterElement) {
         return element.typeParameters;
       }
       fail('Wrong element type: ${element.runtimeType}');
     }
+
     SimpleIdentifier identifier = findIdentifier(name);
     // Element is either ExecutableElement or ParameterElement.
     Element element = identifier.staticElement;
     FunctionTypeImpl functionType = identifier.staticType;
     expect(functionType.toString(), type);
     expect(typeParameters(element).toString(), elementTypeParams);
     expect(functionType.typeParameters.toString(), typeParams);
     expect(functionType.typeArguments.toString(), typeArgs);
     expect(functionType.typeFormals.toString(), typeFormals);
   }
@@ skipping 60 matching lines @@
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 }