Move folderMap from AnalysisContext to ContextManager

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:core' hide Resource;
 import 'dart:math' show max;
@@ skipping 138 matching lines @@
    * The object used to manage the SDK's known to this server.
    */
   DartSdkManager sdkManager;
 
   /**
    * The instrumentation service that is to be used by this analysis server.
    */
   final InstrumentationService instrumentationService;
 
   /**
-   * A table mapping [Folder]s to the [AnalysisContext]s associated with them.
-   */
-  final Map<Folder, AnalysisContext> folderMap =
-      new HashMap<Folder, AnalysisContext>();
-
-  /**
    * A queue of the operations to perform in this server.
    */
   ServerOperationQueue operationQueue;
 
   /**
    * True if there is a pending future which will execute [performOperation].
    */
   bool performOperationPending = false;
 
   /**
@@ skipping 173 matching lines @@
     });
     Notification notification =
         new ServerConnectedParams(VERSION).toNotification();
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
     handlers = serverPlugin.createDomains(this);
     sdkManager = new DartSdkManager(defaultSdkCreator);
   }
 
   /**
+   * Return the [AnalysisContext]s that are being used to analyze the analysis
+   * roots.
+   */
+  Iterable<AnalysisContext> get analysisContexts =>
+      contextManager.analysisContexts;
+
+  /**
+   * Return a table mapping [Folder]s to the [AnalysisContext]s associated with
+   * them.
+   */
+  Map<Folder, AnalysisContext> get folderMap => contextManager.folderMap;
+
+  /**
    * The [Future] that completes when analysis is complete.
    */
   Future get onAnalysisComplete {
     if (isAnalysisComplete()) {
       return new Future.value();
     }
     if (_onAnalysisCompleteCompleter == null) {
       _onAnalysisCompleteCompleter = new Completer();
     }
     return _onAnalysisCompleteCompleter.future;
@@ skipping 90 matching lines @@
    */
   AnalysisContext getAnalysisContext(String path) {
     return getContextSourcePair(path).context;
   }
 
   /**
    * 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) {
+    for (AnalysisContext context in analysisContexts) {
       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;
-  }
-
   CompilationUnitElement getCompilationUnitElement(String file) {
     ContextSourcePair pair = getContextSourcePair(file);
     if (pair == null) {
       return null;
     }
     // prepare AnalysisContext and Source
     AnalysisContext context = pair.context;
     Source unitSource = pair.source;
     if (context == null || unitSource == null) {
       return null;
@@ skipping 55 matching lines @@
     File file = resource;
     {
       AnalysisContext containingContext = getContainingContext(path);
       if (containingContext != null) {
         Source source =
             ContextManagerImpl.createSourceInContext(containingContext, file);
         return new ContextSourcePair(containingContext, source);
       }
     }
     // try to find a context that analysed the file
-    for (AnalysisContext context in folderMap.values) {
+    for (AnalysisContext context in analysisContexts) {
       Source source = ContextManagerImpl.createSourceInContext(context, file);
       SourceKind kind = context.getKindOf(source);
       if (kind != SourceKind.UNKNOWN) {
         return new ContextSourcePair(context, source);
       }
     }
     // try to find a context for which the file is a priority source
-    for (InternalAnalysisContext context in folderMap.values) {
+    for (InternalAnalysisContext context in analysisContexts) {
       List<Source> sources = context.getSourcesWithFullName(path);
       if (sources.isNotEmpty) {
         Source source = sources.first;
         return new ContextSourcePair(context, source);
       }
     }
     // file-based source
     Source fileSource = file.createSource();
     return new ContextSourcePair(null, fileSource);
   }
@@ skipping 531 matching lines @@
       // Prepare the context/source pair.
       ContextSourcePair contextSource = getContextSourcePair(file);
       AnalysisContext preferredContext = contextSource.context;
       Source source = contextSource.source;
       // Try to make the file analyzable.
       // If it is not in any context yet, add it to the first one which
       // could use it, e.g. imports its package, even if not the library.
       if (preferredContext == null) {
         Resource resource = resourceProvider.getResource(file);
         if (resource is File && resource.exists) {
-          for (AnalysisContext context in folderMap.values) {
+          for (AnalysisContext context in analysisContexts) {
             Uri uri = context.sourceFactory.restoreUri(source);
             if (uri.scheme != 'file') {
               preferredContext = context;
               source =
                   ContextManagerImpl.createSourceInContext(context, resource);
               break;
             }
           }
         }
       }
       // Fill the source map.
       bool contextFound = false;
       if (preferredContext != null) {
         sourceMap.putIfAbsent(preferredContext, () => <Source>[]).add(source);
         contextFound = true;
       }
-      for (AnalysisContext context in folderMap.values) {
+      for (AnalysisContext context in analysisContexts) {
         if (context != preferredContext &&
             context.getKindOf(source) != SourceKind.UNKNOWN) {
           sourceMap.putIfAbsent(context, () => <Source>[]).add(source);
           contextFound = true;
         }
       }
       if (firstSource == null) {
         firstSource = source;
       }
       if (!contextFound) {
@@ skipping 93 matching lines @@
       } else if (change is RemoveContentOverlay) {
         newContents = null;
       } else {
         // Protocol parsing should have ensured that we never get here.
         throw new AnalysisException('Illegal change type');
       }
       overlayState.setContents(source, newContents);
       // If the source does not exist, then it was an overlay-only one.
       // Remove it from contexts.
       if (newContents == null && !source.exists()) {
-        for (InternalAnalysisContext context in folderMap.values) {
+        for (InternalAnalysisContext context in analysisContexts) {
           List<Source> sources = context.getSourcesWithFullName(file);
           ChangeSet changeSet = new ChangeSet();
           sources.forEach(changeSet.removedSource);
           context.applyChanges(changeSet);
           schedulePerformAnalysisOperation(context);
         }
         return;
       }
       // Update all contexts.
       bool anyContextUpdated = false;
-      for (InternalAnalysisContext context in folderMap.values) {
+      for (InternalAnalysisContext context in analysisContexts) {
         List<Source> sources = context.getSourcesWithFullName(file);
         sources.forEach((Source source) {
           anyContextUpdated = true;
           if (context.handleContentsChanged(
               source, oldContents, newContents, true)) {
             schedulePerformAnalysisOperation(context);
           } else {
             // When the client sends any change for a source, we should resend
             // subscribed notifications, even if there were no changes in the
             // source contents.
@@ skipping 36 matching lines @@
   }
 
   /**
    * Use the given updaters to update the values of the options in every
    * existing analysis context.
    */
   void updateOptions(List<OptionUpdater> optionUpdaters) {
     //
     // Update existing contexts.
     //
-    folderMap.forEach((Folder folder, AnalysisContext context) {
+    for (AnalysisContext context in analysisContexts) {
       AnalysisOptionsImpl options =
           new AnalysisOptionsImpl.from(context.analysisOptions);
       optionUpdaters.forEach((OptionUpdater optionUpdater) {
         optionUpdater(options);
       });
       context.analysisOptions = options;
       // TODO(brianwilkerson) As far as I can tell, this doesn't cause analysis
       // to be scheduled for this context.
-    });
+    }
+    ;

[Paul Berry, 2016/02/29 21:46:31]

Stray `;`

[Brian Wilkerson, 2016/02/29 22:04:13]

Done

     //
     // Update the defaults used to create new contexts.
     //
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
       optionUpdater(defaultContextOptions);
     });
   }
 
   void _computingPackageMap(bool computing) {
     if (serverServices.contains(ServerService.STATUS)) {
@@ skipping 377 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');
 }