Fixes for SingleContextManager after experiments with two big codebases.

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:async';
 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/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;
 import 'package:watcher/watcher.dart';
 
 /**
- * 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 context used to work with file system paths.
    */
   path.Context pathContext;
 
   /**
    * 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:` URIs.
    */
-  final PackageResolverProvider packageResolverProvider;
+  final ResolverProvider packageResolverProvider;
 
   /**
    * A list of the globs used to determine which files should be analyzed.
    */
   final List<Glob> analyzedFilesGlobs;
 
   /**
+   * The default options used to create new analysis contexts.
+   */
+  final AnalysisOptionsImpl defaultContextOptions;
+
+  /**
    * The list of included paths (folders and files) most recently passed to
    * [setRoots].
    */
   List<String> includedPaths = <String>[];
 
   /**
    * The list of excluded paths (folders and files) most recently passed to
    * [setRoots].
    */
   List<String> excludedPaths = <String>[];
@@ skipping 24 matching lines @@
 
   /**
    * The current watch subscriptions.
    */
   Map<String, StreamSubscription<WatchEvent>> watchSubscriptions =
       new Map<String, StreamSubscription<WatchEvent>>();
 
   /**
    * The [packageResolverProvider] must not be `null`.
    */
-  SingleContextManager(this.resourceProvider, this.sdkManager,
-      this.packageResolverProvider, this.analyzedFilesGlobs) {
+  SingleContextManager(
+      this.resourceProvider,
+      this.sdkManager,
+      this.packageResolverProvider,
+      this.analyzedFilesGlobs,
+      this.defaultContextOptions) {
     pathContext = resourceProvider.pathContext;
   }
 
   @override
   Iterable<AnalysisContext> get analysisContexts =>
       context == null ? <AnalysisContext>[] : <AnalysisContext>[context];
 
   @override
   Map<Folder, AnalysisContext> get folderMap => {contextFolder: context};
 
@@ skipping 71 matching lines @@
           }
           // Remember the subscription.
           newSubscriptions[includedPath] = subscription;
         }
         _cancelCurrentWatchSubscriptions();
         this.watchSubscriptions = newSubscriptions;
       }
     }
     // Create or update the analysis context.
     if (context == null) {
-      UriResolver packageResolver = packageResolverProvider();
-      context = callbacks.addContext(contextFolder, new AnalysisOptionsImpl(),
+      UriResolver packageResolver = packageResolverProvider(contextFolder);
+      context = callbacks.addContext(contextFolder, defaultContextOptions,
           new CustomPackageResolverDisposition(packageResolver));
       ChangeSet changeSet =
           _buildChangeSet(added: _includedFiles(includedPaths, excludedPaths));
       callbacks.applyChangesToContext(contextFolder, changeSet);
     } else {
       // TODO(brianwilkerson) Optimize this.
       List<File> oldFiles =
           _includedFiles(this.includedPaths, this.excludedPaths);
       List<File> newFiles = _includedFiles(includedPaths, excludedPaths);
       ChangeSet changeSet = _buildChangeSet(
@@ skipping 284 matching lines @@
   static List<Resource> _getChildrenSafe(Folder folder) {
     try {
       return folder.getChildren();
     } on FileSystemException {
       // The folder either doesn't exist or cannot be read.
       // Either way, there are no children.
       return const <Resource>[];
     }
   }
 }