Optimize work with absolute paths.

pkg/analysis_server/lib/src/context_manager.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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:core' hide Resource;
 
 import 'package:analysis_server/plugin/analysis/resolver_provider.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/path_filter.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/context.dart' as context;
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/task/options.dart';
+import 'package:analyzer/src/util/absolute_path.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 import 'package:yaml/yaml.dart';
 
 /**
  * Information tracked by the [ContextManager] for each context.
  */
@@ skipping 300 matching lines @@
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
   /**
    * The context used to work with file system paths.
    */
   pathos.Context pathContext;
 
   /**
+   * The context used to work with absolute file system paths.
+   *
+   * TODO(scheglov) remove [pathContext].
+   */
+  AbsolutePathContext absolutePathContext;
+
+  /**
    * The list of excluded paths (folders and files) most recently passed to
    * [setRoots].
    */
   List<String> excludedPaths = <String>[];
 
   /**
    * The list of included paths (folders and files) most recently passed to
    * [setRoots].
    */
   List<String> includedPaths = <String>[];
@@ skipping 43 matching lines @@
   /**
    * Stream subscription we are using to watch each analysis root directory for
    * changes.
    */
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
   ContextManagerImpl(this.resourceProvider, this.packageResolverProvider,
       this._packageMapProvider, this._instrumentationService) {
     pathContext = resourceProvider.pathContext;
+    absolutePathContext = new AbsolutePathContext(pathContext.separator);
   }
 
   @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     ContextInfo innermostContainingInfo =
         _getInnermostContextInfoFor(analysisRoot.path);
     void addContextAndDescendants(ContextInfo info) {
       contexts.add(info.context);
       info.children.forEach(addContextAndDescendants);
@@ skipping 307 matching lines @@
         analysisContext.invalidateCachedResults();
         callbacks.applyChangesToContext(info.folder, new ChangeSet());
       }
     }
   }
 
   void _checkForPackagespecUpdate(
       String path, ContextInfo info, Folder folder) {
     // Check to see if this is the .packages file for this context and if so,
     // update the context's source factory.
-    if (pathContext.basename(path) == PACKAGE_SPEC_NAME &&
+    if (absolutePathContext.basename(path) == PACKAGE_SPEC_NAME &&
         info.isPathToPackageDescription(path)) {
       File packagespec = resourceProvider.getFile(path);
       if (packagespec.exists) {
         Packages packages = _readPackagespec(packagespec);
         if (packages != null) {
           callbacks.updateContextPackageUriResolver(
               folder, new PackagesFileDisposition(packages));
         }
       }
     }
@@ skipping 62 matching lines @@
       // [setRoots] ignores any package roots that don't exist (or aren't
       // folders), the only way we should be able to get here is due to a race
       // condition.  In any case, the package root folder is gone, so we can't
       // resolve packages.
       return new NoPackageFolderDisposition(packageRoot: packageRoot);
     } else {
       PackageMapInfo packageMapInfo;
       callbacks.beginComputePackageMap();
       try {
         // Try .packages first.
-        if (pathContext.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
+        if (absolutePathContext.basename(packagespecFile.path) ==
+            PACKAGE_SPEC_NAME) {
           Packages packages = _readPackagespec(packagespecFile);
           return new PackagesFileDisposition(packages);
         }
         if (packageResolverProvider != null) {
           UriResolver resolver = packageResolverProvider(folder);
           if (resolver != null) {
             return new CustomPackageResolverDisposition(resolver);
           }
         }
 
@@ skipping 220 matching lines @@
       return;
     }
     if (info.ignored(path)) {
       return;
     }
     // handle the change
     switch (event.type) {
       case ChangeType.ADD:
         Resource resource = resourceProvider.getResource(path);
 
-        String directoryPath = pathContext.dirname(path);
+        String directoryPath = absolutePathContext.dirname(path);
 
         // Check to see if we need to create a new context.
         if (info.isTopLevel) {
           // Only create a new context if this is not the same directory
           // described by our info object.
           if (info.folder.path != directoryPath) {
             if (_isPubspec(path)) {
               // Check for a sibling .packages file.
               if (!resourceProvider
-                  .getFile(pathContext.join(directoryPath, PACKAGE_SPEC_NAME))
+                  .getFile(absolutePathContext.append(
+                      directoryPath, PACKAGE_SPEC_NAME))
                   .exists) {
                 _extractContext(info, resource);
                 return;
               }
             }
             if (_isPackagespec(path)) {
               // Check for a sibling pubspec.yaml file.
               if (!resourceProvider
-                  .getFile(pathContext.join(directoryPath, PUBSPEC_NAME))
+                  .getFile(
+                      absolutePathContext.append(directoryPath, PUBSPEC_NAME))
                   .exists) {
                 _extractContext(info, resource);
                 return;
               }
             }
           }
         }
 
         // If the file went away and was replaced by a folder before we
         // had a chance to process the event, resource might be a Folder.  In
         // that case don't add it.
         if (resource is File) {
           File file = resource;
           if (callbacks.shouldFileBeAnalyzed(file)) {
             ChangeSet changeSet = new ChangeSet();
             Source source = createSourceInContext(info.context, file);
             changeSet.addedSource(source);
             callbacks.applyChangesToContext(info.folder, changeSet);
             info.sources[path] = source;
           }
         }
         break;
       case ChangeType.REMOVE:
 
         // If package spec info is removed, check to see if we can merge contexts.
         // Note that it's important to verify that there is NEITHER a .packages nor a
         // lingering pubspec.yaml before merging.
         if (!info.isTopLevel) {
-          String directoryPath = pathContext.dirname(path);
+          String directoryPath = absolutePathContext.dirname(path);
 
           // Only merge if this is the same directory described by our info object.
           if (info.folder.path == directoryPath) {
             if (_isPubspec(path)) {
               // Check for a sibling .packages file.
               if (!resourceProvider
-                  .getFile(pathContext.join(directoryPath, PACKAGE_SPEC_NAME))
+                  .getFile(absolutePathContext.append(
+                      directoryPath, PACKAGE_SPEC_NAME))
                   .exists) {
                 _mergeContext(info);
                 return;
               }
             }
             if (_isPackagespec(path)) {
               // Check for a sibling pubspec.yaml file.
               if (!resourceProvider
-                  .getFile(pathContext.join(directoryPath, PUBSPEC_NAME))
+                  .getFile(
+                      absolutePathContext.append(directoryPath, PUBSPEC_NAME))
                   .exists) {
                 _mergeContext(info);
                 return;
               }
             }
           }
         }
 
         List<Source> sources = info.context.getSourcesWithFullName(path);
         if (!sources.isEmpty) {
@@ skipping 18 matching lines @@
     }
     _checkForPackagespecUpdate(path, info, info.folder);
     _checkForAnalysisOptionsUpdate(path, info, event.type);
   }
 
   /**
    * Determine whether the given [path], when interpreted relative to the
    * context root [root], contains a folder whose name starts with '.'.
    */
   bool _isContainedInDotFolder(String root, String path) {
-    String relativePath =
-        pathContext.relative(pathContext.dirname(path), from: root);
-    for (String pathComponent in pathContext.split(relativePath)) {
+    String pathDir = absolutePathContext.dirname(path);
+    String relativePath = absolutePathContext.relative(pathDir, root);
+    if (relativePath == null) {
+      return false;
+    }
+    for (String pathComponent in absolutePathContext.split(relativePath)) {
       if (pathComponent.startsWith('.') &&
           pathComponent != '.' &&
           pathComponent != '..') {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
   bool _isExcluded(String path) => _isExcludedBy(excludedPaths, path);
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
   bool _isExcludedBy(List<String> excludedPaths, String path) {
     return excludedPaths.any((excludedPath) {
-      if (pathContext.isWithin(excludedPath, path)) {
+      if (absolutePathContext.isWithin(excludedPath, path)) {
         return true;
       }
       return path == excludedPath;
     });
   }
 
   /**
    * Determine whether the given [path], when interpreted relative to the
    * context root [root], contains a 'packages' folder.
    */
   bool _isInPackagesDir(String root, String path) {
-    String relativePath = pathContext.relative(path, from: root);
-    List<String> pathParts = pathContext.split(relativePath);
+    String relativePath = absolutePathContext.relative(path, root);
+    if (relativePath == null) {
+      return false;
+    }
+    List<String> pathParts = absolutePathContext.split(relativePath);
     return pathParts.contains(PACKAGES_NAME);
   }
 
   /**
    * Determine whether the given [path] is in the direct 'doc' folder of the
    * context root [root].
    */
   bool _isInTopLevelDocDir(String root, String path) {
-    String relativePath = pathContext.relative(path, from: root);
+    String relativePath = absolutePathContext.relative(path, root);
+    if (relativePath == null) {
+      return false;
+    }
     return relativePath == DOC_DIR_NAME ||
-        relativePath.startsWith(DOC_DIR_NAME + pathContext.separator);
+        relativePath.startsWith(DOC_DIR_NAME + absolutePathContext.separator);
   }
 
   bool _isPackagespec(String path) =>
-      pathContext.basename(path) == PACKAGE_SPEC_NAME;
+      absolutePathContext.basename(path) == PACKAGE_SPEC_NAME;
 
-  bool _isPubspec(String path) => pathContext.basename(path) == PUBSPEC_NAME;
+  bool _isPubspec(String path) =>
+      absolutePathContext.basename(path) == PUBSPEC_NAME;
 
   /**
    * Merges [info] context into its parent.
    */
   void _mergeContext(ContextInfo info) {
     // destroy the context
     _destroyContext(info);
     // add files to the parent context
     ContextInfo parentInfo = info.parent;
     if (parentInfo != null) {
@@ skipping 215 matching lines @@
           var path = resourceProvider.pathContext.fromUri(uri);
           packageMap[name] = <Folder>[resourceProvider.getFolder(path)];
         }
       });
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
 }