Fix for subscribing for notifications for files in packages.

pkg/analysis_server/lib/src/analysis_server.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 analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' show max;
 
@@ skipping 349 matching lines @@
   }
 
   /**
    * Return the preferred [AnalysisContext] for analyzing the given [path].
    * This will be the context that explicitly contains the path, if any such
    * context exists, otherwise it will be the first analysis context that
    * implicitly analyzes it.  Return `null` if no context is analyzing the
    * path.
    */
   AnalysisContext getAnalysisContext(String path) {
-    // try to find a containing context
-    Folder containingFolder = null;
-    for (Folder folder in folderMap.keys) {
-      if (folder.path == path || folder.contains(path)) {
-        if (containingFolder == null) {
-          containingFolder = folder;
-        } else if (containingFolder.path.length < folder.path.length) {
-          containingFolder = folder;
-        }
-      }
-    }
-    if (containingFolder != null) {
-      return folderMap[containingFolder];
-    }
-    Resource resource = resourceProvider.getResource(path);
-    if (resource is Folder) {
-      return null;
-    }
-    // check if there is a context that analyzed this source
-    return getAnalysisContextForSource(_getSourceWithoutContext(path));
+    return getContextSourcePair(path).context;
   }
 
   /**
+   * Return the [AnalysisContext] that contains the given [path].
+   * Return `null` if no context contains the [path].
+   */
+  AnalysisContext getContainingContext(String path) {
+    Folder containingFolder = null;
+    AnalysisContext containingContext = null;
+    folderMap.forEach((Folder folder, AnalysisContext context) {
+      if (folder.isOrContains(path)) {
+        if (containingFolder == null ||
+            containingFolder.path.length < folder.path.length) {
+          containingFolder = folder;
+          containingContext = context;
+        }
+      }
+    });
+    return containingContext;
+  }
+
+  /**
    * Return any [AnalysisContext] that is analyzing the given [source], either
    * explicitly or implicitly.  Return `null` if there is no such context.
    */
   AnalysisContext getAnalysisContextForSource(Source source) {
     for (AnalysisContext context in folderMap.values) {
       SourceKind kind = context.getKindOf(source);
       if (kind != SourceKind.UNKNOWN) {
         return context;
       }
     }
     return null;
   }
 
   /**
    * Return the [AnalysisContext]s that are being used to analyze the analysis
    * roots.
    */
   Iterable<AnalysisContext> getAnalysisContexts() {
     return folderMap.values;
   }
 
   /**
+   * Return the primary [ContextSourcePair] representing the given [path].
+   *
+   * The [AnalysisContext] of this pair will be the context that explicitly
+   * contains the path, if any such context exists, otherwise it will be the
+   * first context that implicitly analyzes it.
+   *
+   * If the [path] is not analyzed by any context, a [ContextSourcePair] with
+   * `null` context and `file` [Source] is returned.
+   *
+   * If the [path] dosn't represent a file, `null` is returned as a [Source].
+   *
+   * Does not return `null`.
+   */
+  ContextSourcePair getContextSourcePair(String path) {
+    // try SDK
+    {
+      Uri uri = resourceProvider.pathContext.toUri(path);
+      Source sdkSource = defaultSdk.fromFileUri(uri);
+      if (sdkSource != null) {
+        AnalysisContext anyContext = folderMap.values.first;
+        return new ContextSourcePair(anyContext, sdkSource);
+      }
+    }
+    // try to find the deep-most containing context
+    Resource resource = resourceProvider.getResource(path);
+    File file = resource is File ? resource : null;
+    {
+      Folder containingFolder = null;

[Brian Wilkerson, 2015/03/06 15:04:27]

This is very similar to getContainingContext; it would be nice to not duplicate
the logic.

[scheglov, 2015/03/06 21:47:03]

Done.

+      AnalysisContext containingContext = null;
+      folderMap.forEach((Folder folder, AnalysisContext context) {
+        if (folder.isOrContains(path)) {
+          if (containingFolder == null ||
+              containingFolder.path.length < folder.path.length) {
+            containingFolder = folder;
+            containingContext = context;
+          }
+        }
+      });
+      if (containingContext != null) {
+        Source source = file != null
+            ? ContextManager.createSourceInContext(containingContext, file)
+            : null;
+        return new ContextSourcePair(containingContext, source);
+      }
+    }
+    // try to find a context that analysed the file
+    for (AnalysisContext context in folderMap.values) {
+      Source source = file != null
+          ? ContextManager.createSourceInContext(context, file)
+          : null;
+      SourceKind kind = context.getKindOf(source);
+      if (kind != SourceKind.UNKNOWN) {
+        return new ContextSourcePair(context, source);
+      }
+    }
+    // file-based source
+    Source fileSource = file != null ? file.createSource() : null;
+    return new ContextSourcePair(null, fileSource);
+  }
+
+  /**
    * Returns [Element]s at the given [offset] of the given [file].
    *
    * May be empty if cannot be resolved, but not `null`.
    */
   List<Element> getElementsAtOffset(String file, int offset) {
     List<AstNode> nodes = getNodesAtOffset(file, offset);
     return getElementsOfNodes(nodes, offset);
   }
 
   /**
@@ skipping 28 matching lines @@
    * Returns `null` if [file] does not belong to any [AnalysisContext], or the
    * file does not exist.
    *
    * The array of errors will be empty if there are no errors in [file]. The
    * errors contained in the array can be incomplete.
    *
    * This method does not wait for all errors to be computed, and returns just
    * the current state.
    */
   AnalysisErrorInfo getErrors(String file) {
-    // prepare AnalysisContext
-    AnalysisContext context = getAnalysisContext(file);
+    ContextSourcePair contextSource = getContextSourcePair(file);
+    AnalysisContext context = contextSource.context;
+    Source source = contextSource.source;
     if (context == null) {
       return null;
     }
-    // prepare Source
-    Source source = getSource(file);
-    if (context.getKindOf(source) == SourceKind.UNKNOWN) {
+    if (!source.exists()) {
       return null;
     }
-    // get errors for the file
     return context.getErrors(source);
   }
 
-  /**
-   * Returns resolved [AstNode]s at the given [offset] of the given [file].
-   *
-   * May be empty, but not `null`.
-   */
-  List<AstNode> getNodesAtOffset(String file, int offset) {
-    List<CompilationUnit> units = getResolvedCompilationUnits(file);
-    List<AstNode> nodes = <AstNode>[];
-    for (CompilationUnit unit in units) {
-      AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
-      if (node != null) {
-        nodes.add(node);
-      }
-    }
-    return nodes;
-  }
-
 // TODO(brianwilkerson) Add the following method after 'prioritySources' has
 // been added to InternalAnalysisContext.
 //  /**
 //   * Return a list containing the full names of all of the sources that are
 //   * priority sources.
 //   */
 //  List<String> getPriorityFiles() {
 //    List<String> priorityFiles = new List<String>();
 //    folderMap.values.forEach((ContextDirectory directory) {
 //      InternalAnalysisContext context = directory.context;
 //      context.prioritySources.forEach((Source source) {
 //        priorityFiles.add(source.fullName);
 //      });
 //    });
 //    return priorityFiles;
 //  }
 
   /**
+   * Returns resolved [AstNode]s at the given [offset] of the given [file].
+   *
+   * May be empty, but not `null`.
+   */
+  List<AstNode> getNodesAtOffset(String file, int offset) {
+    List<CompilationUnit> units = getResolvedCompilationUnits(file);
+    List<AstNode> nodes = <AstNode>[];
+    for (CompilationUnit unit in units) {
+      AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
+      if (node != null) {
+        nodes.add(node);
+      }
+    }
+    return nodes;
+  }
+
+  /**
    * Returns resolved [CompilationUnit]s of the Dart file with the given [path].
    *
    * May be empty, but not `null`.
    */
   List<CompilationUnit> getResolvedCompilationUnits(String path) {
     List<CompilationUnit> units = <CompilationUnit>[];
+    ContextSourcePair contextSource = getContextSourcePair(path);
     // prepare AnalysisContext
-    AnalysisContext context = getAnalysisContext(path);
+    AnalysisContext context = contextSource.context;
     if (context == null) {
       return units;
     }
     // add a unit for each unit/library combination
-    Source unitSource = getSource(path);
+    Source unitSource = contextSource.source;
     List<Source> librarySources = context.getLibrariesContaining(unitSource);
     for (Source librarySource in librarySources) {
       CompilationUnit unit =
           context.resolveCompilationUnit2(unitSource, librarySource);
       if (unit != null) {
         units.add(unit);
       }
     }
     // done
     return units;
   }
 
   /**
-   * Returns the [CompilationUnit] of the Dart file with the given [path] that
-   * should be used to resend notifications for already resolved unit.
-   * Returns `null` if the file is not a part of any context, library has not
-   * been yet resolved, or any problem happened.
-   */
-  CompilationUnit getResolvedCompilationUnitToResendNotification(String path) {
-    // prepare AnalysisContext
-    AnalysisContext context = getAnalysisContext(path);
-    if (context == null) {
-      return null;
-    }
-    // prepare sources
-    Source unitSource = getSource(path);
-    List<Source> librarySources = context.getLibrariesContaining(unitSource);
-    if (librarySources.isEmpty) {
-      return null;
-    }
-    // if library has not been resolved yet, the unit will be resolved later
-    Source librarySource = librarySources[0];
-    if (context.getLibraryElement(librarySource) == null) {
-      return null;
-    }
-    // if library has been already resolved, resolve unit
-    return context.resolveCompilationUnit2(unitSource, librarySource);
-  }
-
-  /**
-   * Return the [Source] of the Dart file with the given [path].
-   */
-  Source getSource(String path) {
-    // try SDK
-    {
-      Uri uri = resourceProvider.pathContext.toUri(path);
-      Source sdkSource = defaultSdk.fromFileUri(uri);
-      if (sdkSource != null) {
-        return sdkSource;
-      }
-    }
-    // file-based source
-    File file = resourceProvider.getResource(path);
-    return ContextManager.createSourceInContext(getAnalysisContext(path), file);
-  }
-
-  /**
    * Handle a [request] that was read from the communication channel.
    */
   void handleRequest(Request request) {
     _performance.logRequest(request);
     runZoned(() {
       ServerPerformanceStatistics.serverRequests.makeCurrentWhile(() {
         int count = handlers.length;
         for (int i = 0; i < count; i++) {
           try {
             Response response = handlers[i].handleRequest(request);
@@ skipping 253 matching lines @@
    * Implementation for `analysis.setSubscriptions`.
    */
   void setAnalysisSubscriptions(
       Map<AnalysisService, Set<String>> subscriptions) {
     // send notifications for already analyzed sources
     subscriptions.forEach((service, Set<String> newFiles) {
       Set<String> oldFiles = analysisServices[service];
       Set<String> todoFiles =
           oldFiles != null ? newFiles.difference(oldFiles) : newFiles;
       for (String file in todoFiles) {
-        Source source = getSource(file);
+        ContextSourcePair contextSource = getContextSourcePair(file);
         // prepare context
-        AnalysisContext context = getAnalysisContext(file);
+        AnalysisContext context = contextSource.context;
         if (context == null) {
           continue;
         }
         // Dart unit notifications.
         if (AnalysisEngine.isDartFileName(file)) {
+          Source source = contextSource.source;
           CompilationUnit dartUnit =
-              getResolvedCompilationUnitToResendNotification(file);
+              _getResolvedCompilationUnitToResendNotification(context, source);
           if (dartUnit != null) {
             switch (service) {
               case AnalysisService.HIGHLIGHTS:
                 sendAnalysisNotificationHighlights(this, file, dartUnit);
                 break;
               case AnalysisService.NAVIGATION:
                 // TODO(scheglov) consider support for one unit in 2+ libraries
                 sendAnalysisNotificationNavigation(this, file, dartUnit);
                 break;
               case AnalysisService.OCCURRENCES:
                 sendAnalysisNotificationOccurrences(this, file, dartUnit);
                 break;
               case AnalysisService.OUTLINE:
+                AnalysisContext context = dartUnit.element.context;
                 LineInfo lineInfo = context.getLineInfo(source);
                 sendAnalysisNotificationOutline(this, file, lineInfo, dartUnit);
                 break;
               case AnalysisService.OVERRIDES:
                 sendAnalysisNotificationOverrides(this, file, dartUnit);
                 break;
             }
           }
         }
       }
     });
     // remember new subscriptions
     this.analysisServices = subscriptions;
   }
 
   /**
    * Set the priority files to the given [files].
    */
   void setPriorityFiles(String requestId, List<String> files) {
     // Note: when a file is a priority file, that information needs to be
     // propagated to all contexts that analyze the file, so that all contexts
     // will be able to do incremental resolution of the file.  See
     // dartbug.com/22209.
     Map<AnalysisContext, List<Source>> sourceMap =
         new HashMap<AnalysisContext, List<Source>>();
     List<String> unanalyzed = new List<String>();
+    Source firstSource = null;
     files.forEach((file) {
-      AnalysisContext preferredContext = getAnalysisContext(file);
-      Source source = getSource(file);
+      ContextSourcePair contextSource = getContextSourcePair(file);
+      AnalysisContext preferredContext = contextSource.context;
+      Source source = contextSource.source;
       bool contextFound = false;
       for (AnalysisContext context in folderMap.values) {
         if (context == preferredContext ||
             context.getKindOf(source) != SourceKind.UNKNOWN) {
           sourceMap.putIfAbsent(context, () => <Source>[]).add(source);
           contextFound = true;
         }
       }
+      if (firstSource == null) {
+        firstSource = source;
+      }
       if (!contextFound) {
         unanalyzed.add(file);
       }
     });
     if (unanalyzed.isNotEmpty) {
       StringBuffer buffer = new StringBuffer();
       buffer.writeAll(unanalyzed, ', ');
       throw new RequestFailure(
           new Response.unanalyzedPriorityFiles(requestId, buffer.toString()));
     }
     folderMap.forEach((Folder folder, AnalysisContext context) {
       List<Source> sourceList = sourceMap[context];
       if (sourceList == null) {
         sourceList = Source.EMPTY_ARRAY;
       }
       context.analysisPriorityOrder = sourceList;
       // Schedule the context for analysis so that it has the opportunity to
       // cache the AST's for the priority sources as soon as possible.
       schedulePerformAnalysisOperation(context);
     });
     operationQueue.reschedule();
-    Source firstSource = files.length > 0 ? getSource(files[0]) : null;
     _onPriorityChangeController.add(new PriorityChangeEvent(firstSource));
   }
 
   /**
    * Returns `true` if errors should be reported for [file] with the given
    * absolute path.
    */
   bool shouldSendErrorsNotificationFor(String file) {
     return !_noErrorNotification &&
         contextDirectoryManager.isInAnalysisRoot(file);
   }
 
   void shutdown() {
     running = false;
     if (index != null) {
       index.clear();
       index.stop();
     }
     // Defer closing the channel and shutting down the instrumentation server so
     // that the shutdown response can be sent and logged.
     new Future(() {
       instrumentationService.shutdown();
       channel.close();
     });
   }
 
   void test_flushResolvedUnit(String file) {
     if (AnalysisEngine.isDartFileName(file)) {
-      AnalysisContextImpl context = getAnalysisContext(file);
-      Source source = getSource(file);
+      ContextSourcePair contextSource = getContextSourcePair(file);
+      AnalysisContextImpl context = contextSource.context;
+      Source source = contextSource.source;
       DartEntry dartEntry = context.getReadableSourceEntryOrNull(source);
       dartEntry.flushAstStructures();
     }
   }
 
   /**
    * Performs all scheduled analysis operations.
    */
   void test_performAllAnalysisOperations() {
     while (true) {
       ServerOperation operation = operationQueue.takeIf((operation) {
         return operation is PerformAnalysisOperation;
       });
       if (operation == null) {
         break;
       }
       operation.perform(this);
     }
   }
 
   /**
    * Implementation for `analysis.updateContent`.
    */
   void updateContent(String id, Map<String, dynamic> changes) {
     changes.forEach((file, change) {
-      Source source = getSource(file);
+      ContextSourcePair contextSource = getContextSourcePair(file);
+      Source source = contextSource.source;
       operationQueue.sourceAboutToChange(source);
       // Prepare the new contents.
       String oldContents = overlayState.getContents(source);
       String newContents;
       if (change is AddContentOverlay) {
         newContents = change.content;
       } else if (change is ChangeContentOverlay) {
         if (oldContents == null) {
           // The client may only send a ChangeContentOverlay if there is
           // already an existing overlay for the source.
@@ skipping 63 matching lines @@
     //
     // Update the defaults used to create new contexts.
     //
     AnalysisOptionsImpl options = contextDirectoryManager.defaultOptions;
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
       optionUpdater(options);
     });
   }
 
   /**
-   * Return the [Source] of the Dart file with the given [path], assuming that
-   * we do not know the context in which the path should be interpreted.
+   * Returns the [CompilationUnit] of the Dart file with the given [source] that
+   * should be used to resend notifications for already resolved unit.
+   * Returns `null` if the file is not a part of any context, library has not
+   * been yet resolved, or any problem happened.
    */
-  Source _getSourceWithoutContext(String path) {
-    // try SDK
-    {
-      Uri uri = resourceProvider.pathContext.toUri(path);
-      Source sdkSource = defaultSdk.fromFileUri(uri);
-      if (sdkSource != null) {
-        return sdkSource;
-      }
+  CompilationUnit _getResolvedCompilationUnitToResendNotification(
+      AnalysisContext context, Source source) {
+    List<Source> librarySources = context.getLibrariesContaining(source);
+    if (librarySources.isEmpty) {
+      return null;
     }
-    // file-based source
-    File file = resourceProvider.getResource(path);
-    return file.createSource();
+    // if library has not been resolved yet, the unit will be resolved later
+    Source librarySource = librarySources[0];
+    if (context.getLibraryElement(librarySource) == null) {
+      return null;
+    }
+    // if library has been already resolved, resolve unit
+    return context.resolveCompilationUnit2(source, librarySource);
   }
 
   /**
    * Schedules [performOperation] exection.
    */
   void _schedulePerformOperation() {
     if (performOperationPending) {
       return;
     }
     /*
@@ skipping 47 matching lines @@
   /**
    * The contexts that were removed from the server.
    */
   final List<AnalysisContext> removed;
 
   ContextsChangedEvent({this.added: AnalysisContext.EMPTY_LIST,
       this.changed: AnalysisContext.EMPTY_LIST,
       this.removed: AnalysisContext.EMPTY_LIST});
 }
 
+class ContextSourcePair {

[Brian Wilkerson, 2015/03/06 15:04:27]

Comments?

[scheglov, 2015/03/06 21:47:03]

Done.

+  final AnalysisContext context;
+  final Source source;
+  ContextSourcePair(this.context, this.source);
+}
+
 /**
  * A [PriorityChangeEvent] indicates the set the priority files has changed.
  */
 class PriorityChangeEvent {
   final Source firstSource;
 
   PriorityChangeEvent(this.firstSource);
 }
 
 class ServerContextManager extends ContextManager {
@@ skipping 196 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = new PerformanceTag('serverRequests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }