Restore partial analysis of analysis options files

pkg/analyzer/lib/src/task/options.dart

 // Copyright (c) 2015, 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 analyzer.src.task.options;
 
 import 'dart:collection';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/plugin/options.dart';
@@ skipping 215 matching lines @@
   }
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   Source get source => target.source;
 
   @override
   void internalPerform() {
     String content = getRequiredInput(CONTENT_INPUT_NAME);
+    //
+    // Record outputs.
+    //
+    outputs[ANALYSIS_OPTIONS_ERRORS] =
+        analyzeAnalysisOptions(source, content, context?.sourceFactory);
+    outputs[LINE_INFO] = computeLineInfo(content);
+  }
 
+  static List<AnalysisError> analyzeAnalysisOptions(
+      Source source, String content, SourceFactory sourceFactory) {
     List<AnalysisError> errors = <AnalysisError>[];
     Source initialSource = source;
     SourceSpan initialIncludeSpan;
+    AnalysisOptionsProvider optionsProvider =
+        new AnalysisOptionsProvider(sourceFactory);
 
     // Validate the specified options and any included option files
     void validate(Source source, Map<String, YamlNode> options) {
       List<AnalysisError> validationErrors =
           new OptionsFileValidator(source).validate(options);
       if (initialIncludeSpan != null && validationErrors.isNotEmpty) {
         for (AnalysisError error in validationErrors) {
           var args = [
             source.fullName,
             error.offset.toString(),
@@ skipping 11 matching lines @@
         errors.addAll(validationErrors);
       }
 
       YamlNode node = options[AnalyzerOptions.include];
       if (node == null) {
         return;
       }
       SourceSpan span = node.span;
       initialIncludeSpan ??= span;
       String includeUri = span.text;
-      Source includedSource =
-          context.sourceFactory.resolveUri(source, includeUri);
+      Source includedSource = sourceFactory.resolveUri(source, includeUri);
       if (!includedSource.exists()) {
         errors.add(new AnalysisError(
             initialSource,
             initialIncludeSpan.start.column + 1,
             initialIncludeSpan.length,
             AnalysisOptionsWarningCode.INCLUDE_FILE_NOT_FOUND,
             [includeUri, source.fullName]));
         return;
       }
       try {
@@ skipping 20 matching lines @@
 
     try {
       Map<String, YamlNode> options =
           optionsProvider.getOptionsFromString(content);
       validate(source, options);
     } on OptionsFormatException catch (e) {
       SourceSpan span = e.span;
       errors.add(new AnalysisError(source, span.start.column + 1, span.length,
           AnalysisOptionsErrorCode.PARSE_ERROR, [e.message]));
     }
-
-    //
-    // Record outputs.
-    //
-    outputs[ANALYSIS_OPTIONS_ERRORS] = errors;
-    outputs[LINE_INFO] = computeLineInfo(content);
+    return errors;
   }
 
   /// Return a map from the names of the inputs of this kind of task to the
   /// task input descriptors describing those inputs for a task with the
   /// given [target].
   static Map<String, TaskInput> buildInputs(AnalysisTarget source) =>
       <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
 
   /// Compute [LineInfo] for the given [content].
   static LineInfo computeLineInfo(String content) {
@@ skipping 257 matching lines @@
         }
       });
     } else if (config is Map) {
       options.strongMode = true;
       config.forEach((k, v) => _applyStrongModeOption(options, k, v));
     } else {
       options.strongMode = config is bool ? config : false;
     }
   }
 }