Add package root support to analysis server.

pkg/analysis_server/test/context_manager_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.context.directory.manager;
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'reflective_tests.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/source/package_map_provider.dart';
+import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart';
 import 'package:unittest/unittest.dart';
 
 import 'mocks.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ContextManagerTest);
 }
@@ skipping 159 matching lines @@
       },
     };
     // set roots
     manager.setRoots(<String>[root], <String>[], <String, String>{});
     manager.assertContextPaths([root, subProjectA, subProjectB]);
     // verify files
     manager.assertContextFiles(root, [rootFile]);
     manager.assertContextFiles(subProjectA, [subProjectA_file]);
     manager.assertContextFiles(subProjectB, [subProjectB_file]);
     // verify package maps
-    expect(
-        manager.currentContextPackageMaps[root],
-        equals(packageMapProvider.packageMaps[root]));
-    expect(
-        manager.currentContextPackageMaps[subProjectA],
+    _checkPackageMap(root, equals(packageMapProvider.packageMaps[root]));
+    _checkPackageMap(subProjectA,
         equals(packageMapProvider.packageMaps[subProjectA]));
-    expect(
-        manager.currentContextPackageMaps[subProjectB],
+    _checkPackageMap(subProjectB,
         equals(packageMapProvider.packageMaps[subProjectB]));
   }
 
   void test_setRoots_addFolderWithoutPubspec() {
     packageMapProvider.packageMap = null;
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     expect(manager.currentContextPaths, hasLength(1));
     expect(manager.currentContextPaths, contains(projPath));
     expect(manager.currentContextFilePaths[projPath], hasLength(0));
   }
 
+  void test_setRoots_addPackageRoot() {
+    String packagePathFoo = '/package1/foo';
+    String packageRootPath = '/package2/foo';
+    Folder packageFolder = resourceProvider.newFolder(packagePathFoo);
+    packageMapProvider.packageMap = {
+      'foo': [packageFolder]
+    };
+    List<String> includedPaths = <String>[projPath];
+    List<String> excludedPaths = <String>[];
+    manager.setRoots(includedPaths, excludedPaths, <String, String>{});
+    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+    manager.setRoots(includedPaths, excludedPaths,
+        <String, String>{ projPath: packageRootPath });
+    _checkPackageRoot(projPath, equals(packageRootPath));
+  }
+
+  void test_setRoots_changePackageRoot() {
+    String packageRootPath1 = '/package1';
+    String packageRootPath2 = '/package2';
+    List<String> includedPaths = <String>[projPath];
+    List<String> excludedPaths = <String>[];
+    manager.setRoots(includedPaths, excludedPaths,
+        <String, String>{ projPath: packageRootPath1 });
+    _checkPackageRoot(projPath, equals(packageRootPath1));
+    manager.setRoots(includedPaths, excludedPaths,
+        <String, String>{ projPath: packageRootPath2 });
+    _checkPackageRoot(projPath, equals(packageRootPath2));
+  }
+
   void test_setRoots_exclude_newRoot_withExcludedFile() {
     // prepare paths
     String project = '/project';
     String file1 = '$project/file1.dart';
     String file2 = '$project/file2.dart';
     // create files
     resourceProvider.newFile(file1, '// 1');
     resourceProvider.newFile(file2, '// 2');
     // set roots
     manager.setRoots(<String>[project], <String>[file1], <String, String>{});
@@ skipping 113 matching lines @@
     manager.assertContextFiles(subProject, [subFile]);
   }
 
   void test_setRoots_newlyAddedFoldersGetProperPackageMap() {
     String packagePath = '/package/foo';
     Folder packageFolder = resourceProvider.newFolder(packagePath);
     packageMapProvider.packageMap = {
       'foo': [packageFolder]
     };
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(
-        manager.currentContextPackageMaps[projPath],
-        equals(packageMapProvider.packageMap));
+    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+  }
+
+  void test_setRoots_newFolderWithPackageRoot() {
+    String packageRootPath = '/package';
+    manager.setRoots(<String>[projPath], <String>[],
+        <String, String>{ projPath: packageRootPath });
+    _checkPackageRoot(projPath, equals(packageRootPath));
   }
 
   void test_setRoots_removeFolderWithPubspec() {
     // create a pubspec
     String pubspecPath = posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     // add one root - there is a context
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     expect(manager.currentContextPaths, hasLength(1));
     // set empty roots - no contexts
@@ skipping 40 matching lines @@
     packageMapProvider.packageMap = null;
     // add one root - there is a context
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     expect(manager.currentContextPaths, hasLength(1));
     // set empty roots - no contexts
     manager.setRoots(<String>[], <String>[], <String, String>{});
     expect(manager.currentContextPaths, hasLength(0));
     expect(manager.currentContextFilePaths, hasLength(0));
   }
 
+  void test_setRoots_removePackageRoot() {
+    String packagePathFoo = '/package1/foo';
+    String packageRootPath = '/package2/foo';
+    Folder packageFolder = resourceProvider.newFolder(packagePathFoo);
+    packageMapProvider.packageMap = {
+      'foo': [packageFolder]
+    };
+    List<String> includedPaths = <String>[projPath];
+    List<String> excludedPaths = <String>[];
+    manager.setRoots(includedPaths, excludedPaths,
+        <String, String>{ projPath: packageRootPath });
+    _checkPackageRoot(projPath, equals(packageRootPath));
+    manager.setRoots(includedPaths, excludedPaths, <String, String>{});
+    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+  }
+
   test_watch_addDummyLink() {
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // empty folder initially
     Map<String, int> filePaths = manager.currentContextFilePaths[projPath];
     expect(filePaths, isEmpty);
     // add link
     String filePath = posix.join(projPath, 'foo.dart');
     resourceProvider.newDummyLink(filePath);
     // the link was ignored
     return pumpEventQueue().then((_) {
@@ skipping 204 matching lines @@
   test_watch_modifyPackageMapDependency() {
     // create a dependency file
     String dependencyPath = posix.join(projPath, 'dep');
     resourceProvider.newFile(dependencyPath, 'contents');
     packageMapProvider.dependencies.add(dependencyPath);
     // create a Dart file
     String dartFilePath = posix.join(projPath, 'main.dart');
     resourceProvider.newFile(dartFilePath, 'contents');
     // the created context has the expected empty package map
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(manager.currentContextPackageMaps[projPath], isEmpty);
+    _checkPackageMap(projPath, isEmpty);
     // configure package map
     String packagePath = '/package/foo';
     resourceProvider.newFolder(packagePath);
     packageMapProvider.packageMap = {
       'foo': projPath
     };
     // Changing a .dart file in the project shouldn't cause a new
     // package map to be picked up.
     resourceProvider.modifyFile(dartFilePath, 'new contents');
     return pumpEventQueue().then((_) {
-      expect(manager.currentContextPackageMaps[projPath], isEmpty);
+      _checkPackageMap(projPath, isEmpty);
       // However, changing the package map dependency should.
       resourceProvider.modifyFile(dependencyPath, 'new contents');
       return pumpEventQueue().then((_) {
-        expect(
-            manager.currentContextPackageMaps[projPath],
-            equals(packageMapProvider.packageMap));
+        _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
       });
     });
   }
 
   test_watch_modifyPackageMapDependency_fail() {
     // create a dependency file
     String dependencyPath = posix.join(projPath, 'dep');
     resourceProvider.newFile(dependencyPath, 'contents');
     packageMapProvider.dependencies.add(dependencyPath);
     // create a Dart file
     String dartFilePath = posix.join(projPath, 'main.dart');
     resourceProvider.newFile(dartFilePath, 'contents');
     // the created context has the expected empty package map
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(manager.currentContextPackageMaps[projPath], isEmpty);
+    _checkPackageMap(projPath, isEmpty);
     // Change the package map dependency so that the packageMapProvider is
     // re-run, and arrange for it to return null from computePackageMap().
     packageMapProvider.packageMap = null;
     resourceProvider.modifyFile(dependencyPath, 'new contents');
     return pumpEventQueue().then((_) {
       // The package map should have been changed to null.
-      expect(manager.currentContextPackageMaps[projPath], isNull);
+      _checkPackageMap(projPath, isNull);
     });
   }
+
+  /**
+   * Verify that package URI's for source files in [path] will be resolved
+   * using a package map matching [expectation].
+   */
+  void _checkPackageMap(String path, expectation) {
+    UriResolver resolver = manager.currentContextPackageUriResolvers[path];
+    expect(resolver, new isInstanceOf<PackageMapUriResolver>());
+    PackageMapUriResolver packageMapUriResolver = resolver;
+    expect(packageMapUriResolver.packageMap, expectation);
+  }
+
+  /**
+   * Verify that package URI's for source files in [path] will be resolved
+   * using a package root maching [expectation].
+   */
+  void _checkPackageRoot(String path, expectation) {
+    UriResolver resolver = manager.currentContextPackageUriResolvers[path];
+    expect(resolver, new isInstanceOf<PackageUriResolver>());
+    PackageUriResolver packageUriResolver = resolver;
+    expect(packageUriResolver.packagesDirectory_forTesting, expectation);
+  }
 }
 
 
 class TestContextManager extends ContextManager {
   /**
    * Source of timestamps stored in [currentContextFilePaths].
    */
   int now = 0;
 
   /**
    * Map from context to the timestamp when the context was created.
    */
   Map<String, int> currentContextTimestamps = <String, int>{};
 
   /**
    * Iterable of the paths to contexts that currently exist.
    */
   Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
   /**
    * Map from context to (map from file path to timestamp of last event).
    */
   final Map<String, Map<String, int>> currentContextFilePaths = <String,
       Map<String, int>>{};
 
   /**
-   * Map from context to package map.
+   * Map from context to package URI resolver.
    */
-  final Map<String, Map<String, List<Folder>>> currentContextPackageMaps =
-      <String, Map<String, List<Folder>>>{};
+  final Map<String, UriResolver> currentContextPackageUriResolvers =
+      <String, UriResolver>{};
 
   TestContextManager(MemoryResourceProvider resourceProvider,
       PackageMapProvider packageMapProvider)
       : super(resourceProvider, packageMapProvider);
 
   @override
-  void addContext(Folder folder, Map<String, List<Folder>> packageMap) {
+  void addContext(Folder folder, UriResolver packageUriResolver) {
     String path = folder.path;
     expect(currentContextPaths, isNot(contains(path)));
     currentContextTimestamps[path] = now;
     currentContextFilePaths[path] = <String, int>{};
-    currentContextPackageMaps[path] = packageMap;
+    currentContextPackageUriResolvers[path] = packageUriResolver;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
     for (Source source in changeSet.addedSources) {
       expect(filePaths, isNot(contains(source.fullName)));
       filePaths[source.fullName] = now;
     }
     for (Source source in changeSet.removedSources) {
@@ skipping 14 matching lines @@
   void assertContextPaths(List<String> expected) {
     expect(currentContextPaths, unorderedEquals(expected));
   }
 
   @override
   void removeContext(Folder folder) {
     String path = folder.path;
     expect(currentContextPaths, contains(path));
     currentContextTimestamps.remove(path);
     currentContextFilePaths.remove(path);
-    currentContextPackageMaps.remove(path);
+    currentContextPackageUriResolvers.remove(path);
   }
 
   @override
-  void updateContextPackageMap(Folder contextFolder, Map<String,
-      List<Folder>> packageMap) {
-    currentContextPackageMaps[contextFolder.path] = packageMap;
+  void updateContextPackageUriResolver(Folder contextFolder,
+                                       UriResolver packageUriResolver) {
+    currentContextPackageUriResolvers[contextFolder.path] = packageUriResolver;
   }
 }