Support for replacing of the context folder.

pkg/analysis_server/lib/src/single_context_manager.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 analysis_server.src.single_context_manager;
 
 import 'dart:core' hide Resource;
 import 'dart:math' as math;
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analyzer/file_system/file_system.dart';
-import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/path_filter.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/util/glob.dart';
 import 'package:path/path.dart' as path;
 
 /**
+ * A function that will return a [UriResolver] that can be used to resolve
+ * `package:` URIs in [SingleContextManager].
+ */
+typedef UriResolver PackageResolverProvider();
+
+/**
  * Implementation of [ContextManager] that supports only one [AnalysisContext].
  * So, sources from all analysis roots are added to this single context. All
  * features that could otherwise cause creating additional contexts, such as
  * presence of `pubspec.yaml` or `.packages` files, or `.analysis_options` files
  * are ignored.
  */
 class SingleContextManager implements ContextManager {
   /**
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
   /**
    * The manager used to access the SDK that should be associated with a
    * particular context.
    */
   final DartSdkManager sdkManager;
 
   /**
    * A function that will return a [UriResolver] that can be used to resolve
-   * `package:` URI's within a given folder, or `null` if we should fall back
-   * to the standard URI resolver.
+   * `package:` URIs.
    */
-  final ResolverProvider packageResolverProvider;
+  final PackageResolverProvider packageResolverProvider;
 
   /**
    * A list of the globs used to determine which files should be analyzed.
    */
   final List<Glob> analyzedFilesGlobs;
 
   /**
    * The list of included paths (folders and files) most recently passed to
    * [setRoots].
    */
@@ skipping 87 matching lines @@
     }
   }
 
   @override
   void setRoots(List<String> includedPaths, List<String> excludedPaths,
       Map<String, String> packageRoots) {
     includedPaths = _nonOverlappingPaths(includedPaths);
     excludedPaths = _nonOverlappingPaths(excludedPaths);
     this.packageRoots = packageRoots;
     _updateNormalizedPackageRoots();
+    // Update context path.
+    {
+      String contextPath = _commonPrefix(includedPaths);
+      Folder contextFolder = resourceProvider.getFolder(contextPath);
+      if (contextFolder != this.contextFolder) {
+        if (context != null) {
+          callbacks.moveContext(this.contextFolder, contextFolder);
+        }
+        this.contextFolder = contextFolder;
+        // TODO(scheglov) watch for changes in `contextFolder`
+      }
+    }
     if (context == null) {
-      String contextPath = _commonPrefix(includedPaths);
-      contextFolder = resourceProvider.getFolder(contextPath);
-      // TODO(scheglov) watch for changes in `contextFolder`
-      pathFilter = new PathFilter(
-          contextFolder.path, null, resourceProvider.pathContext);
-      AnalysisOptions options = new AnalysisOptionsImpl();
-      FolderDisposition disposition = new CustomPackageResolverDisposition(
-          packageResolverProvider(contextFolder));
-      context = callbacks.addContext(contextFolder, options, disposition);
+      UriResolver packageResolver = packageResolverProvider();
+      context = callbacks.addContext(contextFolder, new AnalysisOptionsImpl(),
+          new CustomPackageResolverDisposition(packageResolver));
       ChangeSet changeSet =
           _buildChangeSet(added: _includedFiles(includedPaths, excludedPaths));
       callbacks.applyChangesToContext(contextFolder, changeSet);
     } else {
-      // TODO(scheglov) in general 'contextFolder' may be different now
       // TODO(brianwilkerson) Optimize this.
       List<File> oldFiles =
           _includedFiles(this.includedPaths, this.excludedPaths);
       List<File> newFiles = _includedFiles(includedPaths, excludedPaths);
       ChangeSet changeSet = _buildChangeSet(
           added: _diff(newFiles, oldFiles), removed: _diff(oldFiles, newFiles));
       callbacks.applyChangesToContext(contextFolder, changeSet);
     }
     this.includedPaths = includedPaths;
     this.excludedPaths = excludedPaths;
@@ skipping 102 matching lines @@
     }
     return max;
   }
 
   static String _commonPrefix(List<String> paths) {
     if (paths.isEmpty) {
       return '';
     }
     List<String> left = path.split(paths[0]);
     int count = left.length;
-    for (int i = 0; i < paths.length; i++) {
-      List<String> right = path.split(paths[0]);
+    for (int i = 1; i < paths.length; i++) {
+      List<String> right = path.split(paths[i]);
       count = _commonComponents(left, count, right);
     }
-    return path.joinAll(left);
+    return path.joinAll(left.sublist(0, count));
   }
 
   /**
    * Return a list of all the files in the [left] that are not in the [right].
    */
   static List<File> _diff(List<File> left, List<File> right) {
     List<File> diff = new List.from(left);
     for (File file in right) {
       diff.remove(file);
     }
@@ skipping 53 matching lines @@
       for (int j = 0; j < i; j++) {
         if (_isEqualOrWithin(path, sortedPaths[j])) {
           sortedPaths.removeAt(i);
           break;
         }
       }
     }
     return sortedPaths;
   }
 }