Issue 25048. Ignore inner analysis roots which are already managed by outer roots.

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;
@@ skipping 163 matching lines @@
    */
   bool isPathToPackageDescription(String path) =>
       path == packageDescriptionPath;
 
   /**
    * Update the set of dependencies for this context.
    */
   void setDependencies(Iterable<String> newDependencies) {
     _dependencies = newDependencies.toSet();
   }
+
+  /**
+   * Return `true` if the given [path] is managed by this context or by
+   * any of its children.
+   */
+  bool _managesOrHasChildThatManages(String path) {
+    if (parent == null) {
+      for (ContextInfo child in children) {
+        if (child._managesOrHasChildThatManages(path)) {
+          return true;
+        }
+      }
+      return false;
+    } else {
+      if (!folder.isOrContains(path)) {
+        return false;
+      }
+      for (ContextInfo child in children) {
+        if (child._managesOrHasChildThatManages(path)) {
+          return true;
+        }
+      }
+      return !pathFilter.ignored(path);
+    }
+  }
 }
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 abstract class ContextManager {
   // TODO(brianwilkerson) Support:
   //   setting the default analysis options
   //   setting the default content cache
@@ skipping 224 matching lines @@
    */
   final InstrumentationService _instrumentationService;
 
   @override
   ContextManagerCallbacks callbacks;
 
   /**
    * Virtual [ContextInfo] which acts as the ancestor of all other
    * [ContextInfo]s.
    */
-  final ContextInfo _rootInfo = new ContextInfo._root();
+  final ContextInfo rootInfo = new ContextInfo._root();
 
   /**
    * 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) {
@@ skipping 35 matching lines @@
   ContextInfo getContextInfoFor(Folder folder) {
     ContextInfo info = _getInnermostContextInfoFor(folder.path);
     if (info != null && folder == info.folder) {
       return info;
     }
     return null;
   }
 
   @override
   bool isIgnored(String path) {
-    ContextInfo info = _rootInfo;
+    ContextInfo info = rootInfo;
     do {
       info = info.findChildInfoFor(path);
       if (info == null) {
         return false;
       }
       if (info.ignored(path)) {
         return true;
       }
     } while (true);
   }
 
   @override
   bool isInAnalysisRoot(String path) {
     // check if excluded
     if (_isExcluded(path)) {
       return false;
     }
     // check if in one of the roots
-    for (ContextInfo info in _rootInfo.children) {
+    for (ContextInfo info in rootInfo.children) {
       if (info.folder.contains(path)) {
         return true;
       }
     }
     // no
     return false;
   }
 
   /**
    * Process [options] for the given context [info].
@@ skipping 54 matching lines @@
     // Set ignore patterns.
     YamlList exclude = analyzer[AnalyzerOptions.exclude];
     if (exclude != null) {
       setIgnorePatternsForContext(info, exclude);
     }
   }
 
   @override
   void refresh(List<Resource> roots) {
     // Destroy old contexts
-    List<ContextInfo> contextInfos = _rootInfo.descendants.toList();
+    List<ContextInfo> contextInfos = rootInfo.descendants.toList();
     if (roots == null) {
       contextInfos.forEach(_destroyContext);
     } else {
       roots.forEach((Resource resource) {
         contextInfos.forEach((ContextInfo contextInfo) {
           if (resource is Folder &&
               resource.isOrContains(contextInfo.folder.path)) {
             _destroyContext(contextInfo);
           }
         });
@@ skipping 20 matching lines @@
     // Normalize all package root sources by mapping them to folders on the
     // filesystem.  Ignore any package root sources that aren't folders.
     normalizedPackageRoots = <String, String>{};
     packageRoots.forEach((String sourcePath, String targetPath) {
       Resource resource = resourceProvider.getResource(sourcePath);
       if (resource is Folder) {
         normalizedPackageRoots[resource.path] = targetPath;
       }
     });
 
-    List<ContextInfo> contextInfos = _rootInfo.descendants.toList();
+    List<ContextInfo> contextInfos = rootInfo.descendants.toList();
     // included
-    Set<Folder> includedFolders = new HashSet<Folder>();
-    for (int i = 0; i < includedPaths.length; i++) {
-      String path = includedPaths[i];
-      Resource resource = resourceProvider.getResource(path);
-      if (resource is Folder) {
-        includedFolders.add(resource);
-      } else if (!resource.exists) {
-        // Non-existent resources are ignored.  TODO(paulberry): we should set
-        // up a watcher to ensure that if the resource appears later, we will
-        // begin analyzing it.
-      } else {
-        // TODO(scheglov) implemented separate files analysis
-        throw new UnimplementedError('$path is not a folder. '
-            'Only support for folder analysis is implemented currently.');
+    List<Folder> includedFolders = <Folder>[];
+    {
+      // Sort paths to ensure that outer roots are handled before inner roots,
+      // so we can correctly ignore inner roots, which are already managed
+      // by outer roots.
+      LinkedHashSet<String> uniqueIncludedPaths =
+          new LinkedHashSet<String>.from(includedPaths);
+      List<String> sortedIncludedPaths = uniqueIncludedPaths.toList();
+      sortedIncludedPaths.sort((a, b) => a.length - b.length);
+      // Convert paths to folders.
+      for (String path in sortedIncludedPaths) {
+        Resource resource = resourceProvider.getResource(path);
+        if (resource is Folder) {
+          includedFolders.add(resource);
+        } else if (!resource.exists) {
+          // Non-existent resources are ignored.  TODO(paulberry): we should set
+          // up a watcher to ensure that if the resource appears later, we will
+          // begin analyzing it.
+        } else {
+          // TODO(scheglov) implemented separate files analysis
+          throw new UnimplementedError('$path is not a folder. '
+              'Only support for folder analysis is implemented currently.');
+        }
       }
     }
     this.includedPaths = includedPaths;
     // excluded
     List<String> oldExcludedPaths = this.excludedPaths;
     this.excludedPaths = excludedPaths;
     // destroy old contexts
     for (ContextInfo contextInfo in contextInfos) {
       bool isIncluded = includedFolders.any((folder) {
         return folder.isOrContains(contextInfo.folder.path);
       });
       if (!isIncluded) {
         _destroyContext(contextInfo);
       }
     }
     // Update package roots for existing contexts
-    for (ContextInfo info in _rootInfo.descendants) {
+    for (ContextInfo info in rootInfo.descendants) {
       String newPackageRoot = normalizedPackageRoots[info.folder.path];
       if (info.packageRoot != newPackageRoot) {
         info.packageRoot = newPackageRoot;
         _recomputeFolderDisposition(info);
       }
     }
     // create new contexts
     for (Folder includedFolder in includedFolders) {
-      bool wasIncluded = contextInfos.any((info) {
-        return info.folder.isOrContains(includedFolder.path);
-      });
-      if (!wasIncluded) {
+      String includedPath = includedFolder.path;
+      bool isManaged = rootInfo._managesOrHasChildThatManages(includedPath);
+      if (!isManaged) {
+        ContextInfo parent = _getParentForNewContext(includedPath);
         changeSubscriptions[includedFolder] =
             includedFolder.changes.listen(_handleWatchEvent);
-        _createContexts(_rootInfo, includedFolder, false);
+        _createContexts(parent, includedFolder, false);
       }
     }
     // remove newly excluded sources
-    for (ContextInfo info in _rootInfo.descendants) {
+    for (ContextInfo info in rootInfo.descendants) {
       // prepare excluded sources
       Map<String, Source> excludedSources = new HashMap<String, Source>();
       info.sources.forEach((String path, Source source) {
         if (_isExcludedBy(excludedPaths, path) &&
             !_isExcludedBy(oldExcludedPaths, path)) {
           excludedSources[path] = source;
         }
       });
       // apply exclusion
       ChangeSet changeSet = new ChangeSet();
       excludedSources.forEach((String path, Source source) {
         info.sources.remove(path);
         changeSet.removedSource(source);
       });
       callbacks.applyChangesToContext(info.folder, changeSet);
     }
     // add previously excluded sources
-    for (ContextInfo info in _rootInfo.descendants) {
+    for (ContextInfo info in rootInfo.descendants) {
       ChangeSet changeSet = new ChangeSet();
       _addPreviouslyExcludedSources(
           info, changeSet, info.folder, oldExcludedPaths);
       callbacks.applyChangesToContext(info.folder, changeSet);
     }
   }
 
   /**
    * Recursively adds all Dart and HTML files to the [changeSet].
    */
@@ skipping 116 matching lines @@
    * the set of sources in the removed context (context.sources), that are
    * orphaned by this context being removed (no other context includes this
    * file.)
    */
   List<String> _computeFlushedFiles(ContextInfo info) {
     AnalysisContext context = info.context;
     HashSet<String> flushedFiles = new HashSet<String>();
     for (Source source in context.sources) {
       flushedFiles.add(source.fullName);
     }
-    for (ContextInfo contextInfo in _rootInfo.descendants) {
+    for (ContextInfo contextInfo in rootInfo.descendants) {
       AnalysisContext contextN = contextInfo.context;
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
@@ skipping 239 matching lines @@
   /**
    * Return the [ContextInfo] for the "innermost" context whose associated
    * folder is or contains the given path.  ("innermost" refers to the nesting
    * of contexts, so if there is a context for path /foo and a context for
    * path /foo/bar, then the innermost context containing /foo/bar/baz.dart is
    * the context for /foo/bar.)
    *
    * If no context contains the given path, `null` is returned.
    */
   ContextInfo _getInnermostContextInfoFor(String path) {
-    ContextInfo info = _rootInfo.findChildInfoFor(path);
+    ContextInfo info = rootInfo.findChildInfoFor(path);
     if (info == null) {
       return null;
     }
     while (true) {
       ContextInfo childInfo = info.findChildInfoFor(path);
       if (childInfo == null) {
         return info;
       }
       info = childInfo;
     }
   }
 
+  /**
+   * Return the parent for a new [ContextInfo] with the given [path] folder.
+   */
+  ContextInfo _getParentForNewContext(String path) {
+    ContextInfo parent = _getInnermostContextInfoFor(path);
+    if (parent != null) {
+      return parent;
+    }
+    return rootInfo;
+  }
+
   void _handleWatchEvent(WatchEvent event) {
     // Figure out which context this event applies to.
     // TODO(brianwilkerson) If a file is explicitly included in one context
     // but implicitly referenced in another context, we will only send a
     // changeSet to the context that explicitly includes the file (because
     // that's the only context that's watching the file).
     ContextInfo info = _getInnermostContextInfoFor(event.path);
     if (info == null) {
       // This event doesn't apply to any context.  This could happen due to a
       // race condition (e.g. a context was removed while one of its events was
@@ skipping 434 matching lines @@
       ResourceProvider resourceProvider) {
     if (packages != null) {
       // Construct package map for the SdkExtUriResolver.
       Map<String, List<Folder>> packageMap = buildPackageMap(resourceProvider);
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
 }