More clean-up in 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 'dart:collection';
 import 'dart:io' as io;
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/context/builder.dart';
-import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/task/options.dart'
     show CONFIGURED_ERROR_PROCESSORS;
 import 'package:analyzer/src/util/glob.dart';
 import 'package:linter/src/plugin/linter_plugin.dart';
@@ skipping 435 matching lines @@
     expect(exampleSources, hasLength(1));
     expect(exampleSources.first.uri.toString(),
         'file:///my/proj/example/example.dart');
   }
 
   void test_setRoots_addFolderWithNestedPubspec() {
     String examplePath = newFolder([projPath, ContextManagerTest.EXAMPLE_NAME]);
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
 
     newFile([projPath, ContextManagerImpl.PUBSPEC_NAME]);
+    newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME], 'proj:lib/');
     newFile([libPath, 'main.dart']);
     newFile([examplePath, ContextManagerImpl.PUBSPEC_NAME]);
     newFile([examplePath, 'example.dart']);
 
-    packageMapProvider.packageMap['proj'] = <Folder>[
-      resourceProvider.getResource(libPath)
-    ];
-
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     expect(callbacks.currentContextPaths, hasLength(2));
 
     expect(callbacks.currentContextPaths, contains(projPath));
     Set<Source> projSources = callbacks.currentContextSources[projPath];
     expect(projSources, hasLength(1));
     expect(projSources.first.uri.toString(), 'package:proj/main.dart');
 
     expect(callbacks.currentContextPaths, contains(examplePath));
@@ skipping 70 matching lines @@
     callbacks.assertContextPaths([projPath]);
   }
 
   void test_setRoots_addFolderWithPubspecAndLib() {
     String binPath = newFolder([projPath, ContextManagerTest.BIN_NAME]);
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     String srcPath = newFolder([libPath, ContextManagerTest.SRC_NAME]);
     String testPath = newFolder([projPath, ContextManagerTest.TEST_NAME]);
 
     newFile([projPath, ContextManagerImpl.PUBSPEC_NAME]);
+    newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME], 'proj:lib/');
     String appPath = newFile([binPath, 'app.dart']);
     newFile([libPath, 'main.dart']);
     newFile([srcPath, 'internal.dart']);
     String testFilePath = newFile([testPath, 'main_test.dart']);
 
-    packageMapProvider.packageMap['proj'] = <Folder>[
-      resourceProvider.getResource(libPath)
-    ];
-
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     Set<Source> sources = callbacks.currentContextSources[projPath];
 
     expect(callbacks.currentContextPaths, hasLength(1));
     expect(callbacks.currentContextPaths, contains(projPath));
     expect(sources, hasLength(4));
     List<String> uris =
         sources.map((Source source) => source.uri.toString()).toList();
     expect(uris, contains('file://$appPath'));
     expect(uris, contains('package:proj/main.dart'));
@@ skipping 25 matching lines @@
     // verify files
     callbacks.assertContextFiles(root, [rootFile]);
     callbacks.assertContextFiles(subProjectA, [subProjectA_file]);
     callbacks.assertContextFiles(subProjectB, [subProjectB_file]);
   }
 
   void test_setRoots_addFolderWithPubspecFolders() {
     // prepare paths
     String root = '/root';
     String rootFile = '$root/root.dart';
-    String subProjectA = '$root/sub/aaa';
-    String subProjectB = '$root/sub/sub2/bbb';
-    String subProjectA_file = '$subProjectA/bin/a.dart';
-    String subProjectB_file = '$subProjectB/bin/b.dart';
+    String projectA = '$root/sub/aaa';
+    String projectALib = '$root/sub/aaa/lib';
+    String subProjectA_file = '$projectA/bin/a.dart';
+    String projectB = '$root/sub/sub2/bbb';
+    String projectBLib = '$root/sub/sub2/bbb/lib';
+    String subProjectB_file = '$projectB/bin/b.dart';
     // create files
-    resourceProvider.newFile('$subProjectA/pubspec.yaml', 'pubspec');
-    resourceProvider.newFile('$subProjectB/pubspec.yaml', 'pubspec');
+    newFile([projectA, ContextManagerImpl.PUBSPEC_NAME]);
+    newFile([projectA, ContextManagerImpl.PACKAGE_SPEC_NAME], 'foo:lib/');
+    newFile([projectB, ContextManagerImpl.PUBSPEC_NAME]);
+    newFile([projectB, ContextManagerImpl.PACKAGE_SPEC_NAME], 'bar:lib/');
     resourceProvider.newFile(rootFile, 'library root;');
     resourceProvider.newFile(subProjectA_file, 'library a;');
     resourceProvider.newFile(subProjectB_file, 'library b;');
-    // configure package maps
-    packageMapProvider.packageMaps = {
-      subProjectA: {
-        'foo': [resourceProvider.newFolder('/package/foo')]
-      },
-      subProjectB: {
-        'bar': [resourceProvider.newFolder('/package/bar')]
-      },
-    };
     // set roots
     manager.setRoots(<String>[root], <String>[], <String, String>{});
-    callbacks.assertContextPaths([root, subProjectA, subProjectB]);
+    callbacks.assertContextPaths([root, projectA, projectB]);
     // verify files
     callbacks.assertContextFiles(root, [rootFile]);
-    callbacks.assertContextFiles(subProjectA, [subProjectA_file]);
-    callbacks.assertContextFiles(subProjectB, [subProjectB_file]);
+    callbacks.assertContextFiles(projectA, [subProjectA_file]);
+    callbacks.assertContextFiles(projectB, [subProjectB_file]);
     // verify package maps
-    expect(_packageMap(root), isNull);
-    expect(_packageMap(subProjectA),
-        equals(packageMapProvider.packageMaps[subProjectA]));
-    expect(_packageMap(subProjectB),
-        equals(packageMapProvider.packageMaps[subProjectB]));
+    expect(_packageMap(root), isEmpty);
+    expect(
+        _packageMap(projectA),
+        equals({
+          'foo': [resourceProvider.getFolder(projectALib)]
+        }));
+    expect(
+        _packageMap(projectB),
+        equals({
+          'bar': [resourceProvider.getFolder(projectBLib)]
+        }));
   }
 
   void test_setRoots_addPackageRoot() {
     String packagePathFoo = '/package1/foo';
     String packageRootPath = '/package2/foo';
+    newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME],
+        'foo:file:///package1/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>{});
-    expect(_currentPackageMap, equals(packageMapProvider.packageMap));
+    expect(
+        _currentPackageMap,
+        equals({
+          'foo': [packageFolder]
+        }));
     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>[];
@@ skipping 225 matching lines @@
 
   void test_setRoots_newFolderWithPackageRoot() {
     String packageRootPath = '/package';
     manager.setRoots(<String>[projPath], <String>[],
         <String, String>{projPath: packageRootPath});
     _checkPackageRoot(projPath, equals(packageRootPath));
   }
 
   void test_setRoots_newlyAddedFoldersGetProperPackageMap() {
     String packagePath = '/package/foo';
+    newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME],
+        'foo:file:///package/foo');
     Folder packageFolder = resourceProvider.newFolder(packagePath);
-    packageMapProvider.packageMap = {
-      'foo': [packageFolder]
-    };
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(_currentPackageMap, equals(packageMapProvider.packageMap));
+    expect(
+        _currentPackageMap,
+        equals({
+          'foo': [packageFolder]
+        }));
   }
 
   void test_setRoots_noContext_excludedFolder() {
     // prepare paths
     String project = '/project';
     String excludedFolder = '$project/excluded';
     String excludedPubspec = '$excludedFolder/pubspec.yaml';
     // create files
     resourceProvider.newFile(excludedPubspec, 'name: ignore-me');
     // set "/project", and exclude "/project/excluded"
@@ skipping 16 matching lines @@
     String pubspecPath = posix.join(projPath, 'packages', 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'name: test');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     expect(callbacks.currentContextPaths, hasLength(1));
     expect(callbacks.currentContextPaths, contains(projPath));
     expect(callbacks.currentContextFilePaths[projPath], hasLength(0));
   }
 
   void test_setRoots_packageResolver() {
-    Uri uri = Uri.parse('package:foo/foo.dart');
-    Source source = new TestSource();
-    packageResolver = new TestUriResolver({uri: source});
-    String filePath = posix.join(projPath, 'foo.dart');
+    String filePath = posix.join(projPath, 'lib', 'foo.dart');
+    newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME], 'foo:lib/');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     List<AnalysisContext> contextsInAnalysisRoot =
         manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
     expect(contextsInAnalysisRoot, hasLength(1));
     AnalysisContext context = contextsInAnalysisRoot[0];
     expect(context, isNotNull);
-    Source result = context.sourceFactory.forUri2(uri);
-    expect(result, same(source));
+    Source result = context.sourceFactory.forUri('package:foo/foo.dart');
+    expect(result.fullName, filePath);
   }
 
   void test_setRoots_pathContainsDotFile() {
     // If the path to a file (relative to the context root) contains a folder
     // whose name begins with '.', then the file is ignored.
     String project = '/project';
     String fileA = '$project/foo.dart';
     String fileB = '$project/.pub/bar.dart';
     resourceProvider.newFile(fileA, '');
     resourceProvider.newFile(fileB, '');
@@ skipping 108 matching lines @@
     manager.setRoots(<String>[projectA], <String>[], <String, String>{});
     callbacks.assertContextPaths([projectA, subProjectA]);
     callbacks.assertContextFiles(projectA, [projectA_file]);
     callbacks.assertContextFiles(subProjectA, [subProjectA_file]);
   }
 
   void test_setRoots_removePackageRoot() {
     String packagePathFoo = '/package1/foo';
     String packageRootPath = '/package2/foo';
     Folder packageFolder = resourceProvider.newFolder(packagePathFoo);
-    packageMapProvider.packageMap = {
-      'foo': [packageFolder]
-    };
+    newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME],
+        'foo:file:///package1/foo');
     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>{});
-    expect(_currentPackageMap, equals(packageMapProvider.packageMap));
+    expect(
+        _currentPackageMap,
+        equals({
+          'foo': [packageFolder]
+        }));
   }
 
   void test_setRoots_rootPathContainsDotFile() {
     // If the path to the context root itself contains a folder whose name
     // begins with '.', then that is not sufficient to cause any files in the
     // context to be ignored.
     String project = '/.pub/project';
     String fileA = '$project/foo.dart';
     resourceProvider.newFile(fileA, '');
     manager.setRoots(<String>[project], <String>[], <String, String>{});
@@ skipping 488 matching lines @@
     expect(filePaths, contains(filePath));
     expect(filePaths[filePath], equals(callbacks.now));
     // update the file
     callbacks.now++;
     resourceProvider.modifyFile(filePath, 'new contents');
     return pumpEventQueue().then((_) {
       return expect(filePaths[filePath], equals(callbacks.now));
     });
   }
 
-  test_watch_modifyPackageMapDependency() {
+  test_watch_modifyPackageMapDependency_fail() async {
     // 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(_currentPackageMap, isEmpty);
-    // configure package map
-    String packagePath = '/package/foo';
-    resourceProvider.newFolder(packagePath);
-    packageMapProvider.packageMap = {
-      'foo': [resourceProvider.newFolder(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(_currentPackageMap, isEmpty);
-      // However, changing the package map dependency should.
-      resourceProvider.modifyFile(dependencyPath, 'new contents');
-      return pumpEventQueue().then((_) {
-        expect(_currentPackageMap, 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(_currentPackageMap, 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(_currentPackageMap, isNull);
-    });
+    await pumpEventQueue();
+    // The package map should have been changed to null.
+    expect(_currentPackageMap, isEmpty);
   }
 
   test_watch_modifyPackagespec() {
     String packagesPath = '$projPath/.packages';
     String filePath = '$projPath/bin/main.dart';
 
     resourceProvider.newFile(packagesPath, '');
     resourceProvider.newFile(filePath, 'library main;');
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
@@ skipping 965 matching lines @@
   List<String> lastFlushedFiles;
 
   TestContextManagerCallbacks(this.resourceProvider);
 
   /**
    * Iterable of the paths to contexts that currently exist.
    */
   Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
   @override
-  AnalysisContext addContext(
-      Folder folder, AnalysisOptions options, FolderDisposition disposition) {
+  AnalysisContext addContext(Folder folder, AnalysisOptions options) {
     String path = folder.path;
     expect(currentContextPaths, isNot(contains(path)));
     currentContextTimestamps[path] = now;
     currentContextFilePaths[path] = <String, int>{};
     currentContextSources[path] = new HashSet<Source>();
-    currentContext = AnalysisEngine.instance.createAnalysisContext();
-    List<UriResolver> resolvers = [];
-    if (currentContext is InternalAnalysisContext) {
-      EmbedderYamlLocator embedderYamlLocator =
-          disposition.getEmbedderLocator(resourceProvider);
-      EmbedderSdk sdk =
-          new EmbedderSdk(resourceProvider, embedderYamlLocator.embedderYamls);
-      if (sdk.libraryMap.size() > 0) {
-        // We have some embedder dart: uri mappings, add the resolver
-        // to the list.
-        resolvers.add(new DartUriResolver(sdk));
-      }
-    }
-    resolvers.addAll(disposition.createPackageUriResolvers(resourceProvider));
-    resolvers.add(new ResourceUriResolver(resourceProvider));
-    currentContext.analysisOptions = options;
-    currentContext.sourceFactory =
-        new SourceFactory(resolvers, disposition.packages);
+
+    ContextBuilder builder = createContextBuilder(folder, options);
+    currentContext = builder.buildContext(folder.path);
     return currentContext;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
     Set<Source> sources = currentContextSources[contextFolder.path];
 
     for (Source source in changeSet.addedSources) {
       expect(filePaths, isNot(contains(source.fullName)));
@@ skipping 80 matching lines @@
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }