anchor.diff:      ));
     }
   
  -  /**
  -   * Send status notification to the client. The state of analysis is given by
  -   * the [status] information.
  -   */
  +  /// Send status notification to the client. The state of analysis is given by
  +  /// the [status] information.
     void sendStatusNotificationNew(nd.AnalysisStatus status) {
       if (status.isAnalyzing) {
         _onAnalysisStartedController.add(true);
  
positive.code: 
  typedef void OptionUpdater(AnalysisOptionsImpl options);
  
  /**
   * Instances of the class [AnalysisServer] implement a server that listens on a
   * [CommunicationChannel] for analysis requests and process them.
   */
  class AnalysisServer {
    /**
     * The version of the analysis server. The value should be replaced
     * automatically during the build.
     */
    static final String VERSION = '1.21.1';
  
    /**
     * The options of this server instance.
     */
    AnalysisServerOptions options;
  
    /**
     * The channel from which requests are received and to which responses should
     * be sent.
     */
    final ServerCommunicationChannel channel;
  
    /**
     * The object used to manage sending a subset of notifications to the client.
     * The subset of notifications are those to which plugins may contribute.
     * This field is `null` when the new plugin support is disabled.
     */
    final NotificationManager notificationManager;
  
    /**
     * The object used to manage the execution of plugins.
     */
    PluginManager pluginManager;
  
    /**
     * The [ResourceProvider] using which paths are converted into [Resource]s.
     */
    final ResourceProvider resourceProvider;
  
    /**
     * The [SearchEngine] for this server, may be `null` if indexing is disabled.
     */
    SearchEngine searchEngine;
  
    /**
     * A list of the globs used to determine which files should be analyzed. The
     * list is lazily created and should be accessed using [analyzedFilesGlobs].
     */
    List<Glob> _analyzedFilesGlobs = null;
  
    /**
     * The [ContextManager] that handles the mapping from analysis roots to
     * context directories.
     */
    ContextManager contextManager;
  
    /**
     * A flag indicating the value of the 'analyzing' parameter sent in the last
     * status message to the client.
     */
    bool statusAnalyzing = false;
  
    /**
     * A list of the request handlers used to handle the requests sent to this
     * server.
     */
    List<RequestHandler> handlers;
  
    /**
     * The object used to manage the SDK's known to this server.
     */
    final DartSdkManager sdkManager;
  
    /**
     * The instrumentation service that is to be used by this analysis server.
     */
    final InstrumentationService instrumentationService;
  
    /**
     * A set of the [ServerService]s to send notifications for.
     */
    Set<ServerService> serverServices = new HashSet<ServerService>();
  
    /**
     * A set of the [GeneralAnalysisService]s to send notifications for.
     */
    Set<GeneralAnalysisService> generalAnalysisServices =
        new HashSet<GeneralAnalysisService>();
  
    /**
     * A table mapping [AnalysisService]s to the file paths for which these
     * notifications should be sent.
     */
    Map<AnalysisService, Set<String>> analysisServices =
        new HashMap<AnalysisService, Set<String>>();
  
    /**
     * A table mapping [FlutterService]s to the file paths for which these
     * notifications should be sent.
     */
    Map<FlutterService, Set<String>> flutterServices = {};
  
    /**
     * Performance information before initial analysis is complete.
     */
    final ServerPerformance performanceDuringStartup = new ServerPerformance();
  
    /**
     * Performance information after initial analysis is complete
     * or `null` if the initial analysis is not yet complete
     */
    ServerPerformance performanceAfterStartup;
  
    /**
     * A [RecentBuffer] of the most recent exceptions encountered by the analysis
     * server.
     */
    final RecentBuffer<ServerException> exceptions = new RecentBuffer(10);
  
    /**
     * The class into which performance information is currently being recorded.
     * During startup, this will be the same as [performanceDuringStartup]
     * and after startup is complete, this switches to [performanceAfterStartup].
     */
    ServerPerformance _performance;
  
    /**
     * The [Completer] that completes when analysis is complete.
     */
    Completer _onAnalysisCompleteCompleter;
  
    /**
     * The controller that is notified when analysis is started.
     */
    StreamController<bool> _onAnalysisStartedController;
  
    /**
     * The content overlay for all analysis drivers.
     */
    final nd.FileContentOverlay fileContentOverlay = new nd.FileContentOverlay();
  
    /**
     * If the "analysis.analyzedFiles" notification is currently being subscribed
     * to (see [generalAnalysisServices]), and at least one such notification has
     * been sent since the subscription was enabled, the set of analyzed files
     * that was delivered in the most recently sent notification.  Otherwise
     * `null`.
     */
    Set<String> prevAnalyzedFiles;
  
    /**
     * The default options used to create new analysis contexts. This object is
     * also referenced by the ContextManager.
     */
    final AnalysisOptionsImpl defaultContextOptions = new AnalysisOptionsImpl();
  
    /**
     * The file resolver provider used to override the way file URI's are
     * resolved in some contexts.
     */
    ResolverProvider fileResolverProvider;
  
    /**
     * The package resolver provider used to override the way package URI's are
     * resolved in some contexts.
     */
    ResolverProvider packageResolverProvider;
  
    PerformanceLog _analysisPerformanceLogger;
  
negative.code:     return result?.unit;
    }
  
    /// Return the resolved unit for the file with the given [path]. The file is
    /// analyzed in one of the analysis drivers to which the file was added,
    /// otherwise in the first driver, otherwise `null` is returned.
    Future<ResolvedUnitResult> getResolvedUnit(String path,
        {bool sendCachedToStream: false}) {
      if (!AnalysisEngine.isDartFileName(path)) {
  