Remove the AnalysisOptionsProcessor

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';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
+import 'package:analyzer/src/lint/config.dart';
+import 'package:analyzer/src/lint/linter.dart';
+import 'package:analyzer/src/lint/registry.dart';
 import 'package:analyzer/src/task/general.dart';
 import 'package:analyzer/src/util/yaml.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:source_span/source_span.dart';
 import 'package:yaml/yaml.dart';
 
 /// The errors produced while parsing an analysis options file.
 ///
 /// The list will be empty if there were no errors, but will not be `null`.
 final ListResultDescriptor<AnalysisError> ANALYSIS_OPTIONS_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'ANALYSIS_OPTIONS_ERRORS', AnalysisError.NO_ERRORS);
 
 final _OptionsProcessor _processor = new _OptionsProcessor();
 
 void applyToAnalysisOptions(
     AnalysisOptionsImpl options, Map<String, Object> optionMap) {
   _processor.applyToAnalysisOptions(options, optionMap);
 }
 
-/// Configure this [context] based on configuration details specified in
-/// the given [options].  If [options] is `null`, default values are applied.
-void configureContextOptions(
-        AnalysisContext context, Map<String, Object> options) =>
-    _processor.configure(context, options);
-
 /// `analyzer` analysis options constants.
 class AnalyzerOptions {
   static const String analyzer = 'analyzer';
   static const String enableAssertInitializer = 'enableAssertInitializer';
   static const String enableAsync = 'enableAsync';
   static const String enableGenericMethods = 'enableGenericMethods';
   static const String enableInitializingFormalAccess =
       'enableInitializingFormalAccess';
   static const String enableStrictCallChecks = 'enableStrictCallChecks';
   static const String enableSuperMixins = 'enableSuperMixins';
@@ skipping 452 matching lines @@
       _applyProcessors(options, filters);
 
       // Process language options.
       var language = analyzer[AnalyzerOptions.language];
       _applyLanguageOptions(options, language);
 
       // Process excludes.
       var excludes = analyzer[AnalyzerOptions.exclude];
       _applyExcludes(options, excludes);
     }
-  }
 
-  /// Configure [context] based on the given [options] (which can be `null`
-  /// to restore [defaults]).
-  void configure(AnalysisContext context, Map<String, Object> options) {
-    if (options == null) {
-      options = defaults;
-    }
-
-    var analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer is Map) {
-      // Set strong mode (default is false).
-      var strongMode = analyzer[AnalyzerOptions.strong_mode];
-      setStrongMode(context, strongMode);
-
-      // Set filters.
-      var filters = analyzer[AnalyzerOptions.errors];
-      setProcessors(context, filters);
-
-      // Process language options.
-      var language = analyzer[AnalyzerOptions.language];
-      setLanguageOptions(context, language);
-
-      // Process excludes.
-      var excludes = analyzer[AnalyzerOptions.exclude];
-      setExcludes(context, excludes);
-    }
-  }
-
-  void setExcludes(AnalysisContext context, Object excludes) {
-    if (excludes is YamlList) {
-      List<String> excludeList = toStringList(excludes);
-      if (excludeList != null) {
-        AnalysisOptionsImpl options =
-            new AnalysisOptionsImpl.from(context.analysisOptions);
-        options.excludePatterns = excludeList;
-        context.analysisOptions = options;
+    LintConfig config = parseConfig(optionMap);
+    if (config != null) {
+      Iterable<LintRule> lintRules = Registry.ruleRegistry.enabled(config);
+      if (lintRules.isNotEmpty) {
+        options.lint = true;
+        options.lintRules = lintRules.toList();
       }
     }
   }
-
-  void setLanguageOption(
-      AnalysisContext context, Object feature, Object value) {
-    if (feature == AnalyzerOptions.enableAssertInitializer) {
-      if (isTrue(value)) {
-        AnalysisOptionsImpl options =
-            new AnalysisOptionsImpl.from(context.analysisOptions);
-        options.enableAssertInitializer = true;
-        context.analysisOptions = options;
-      }
-    }
-    if (feature == AnalyzerOptions.enableStrictCallChecks) {
-      if (isTrue(value)) {
-        AnalysisOptionsImpl options =
-            new AnalysisOptionsImpl.from(context.analysisOptions);
-        options.enableStrictCallChecks = true;
-        context.analysisOptions = options;
-      }
-    }
-    if (feature == AnalyzerOptions.enableSuperMixins) {
-      if (isTrue(value)) {
-        AnalysisOptionsImpl options =
-            new AnalysisOptionsImpl.from(context.analysisOptions);
-        options.enableSuperMixins = true;
-        context.analysisOptions = options;
-      }
-    }
-  }
-
-  void setLanguageOptions(AnalysisContext context, Object configs) {
-    if (configs is YamlMap) {
-      configs.nodes.forEach((k, v) {
-        if (k is YamlScalar && v is YamlScalar) {
-          String feature = k.value?.toString();
-          setLanguageOption(context, feature, v.value);
-        }
-      });
-    } else if (configs is Map) {
-      configs.forEach((k, v) => setLanguageOption(context, k, v));
-    }
-  }
-
-  void setProcessors(AnalysisContext context, Object codes) {
-    ErrorConfig config = new ErrorConfig(codes);
-    AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.from(context.analysisOptions);
-    options.errorProcessors = config.processors;
-    context.analysisOptions = options;
-  }
-
-  void setStrongMode(AnalysisContext context, Object strongMode) {
-    if (strongMode is Map) {
-      AnalysisOptionsImpl options =
-          new AnalysisOptionsImpl.from(context.analysisOptions);
-      _applyStrongOptions(options, strongMode);
-      context.analysisOptions = options;
-    } else {
-      strongMode = strongMode is bool ? strongMode : false;
-      if (context.analysisOptions.strongMode != strongMode) {
-        AnalysisOptionsImpl options =
-            new AnalysisOptionsImpl.from(context.analysisOptions);
-        options.strongMode = strongMode;
-        context.analysisOptions = options;
-      }
-    }
-  }
 
   void _applyExcludes(AnalysisOptionsImpl options, Object excludes) {
     if (excludes is YamlList) {
       List<String> excludeList = toStringList(excludes);
       if (excludeList != null) {
         options.excludePatterns = excludeList;
       }
     }
   }
 
   void _applyLanguageOption(
       AnalysisOptionsImpl options, Object feature, Object value) {
     bool boolValue = toBool(value);
     if (boolValue != null) {
       if (feature == AnalyzerOptions.enableAssertInitializer) {
         options.enableAssertInitializer = boolValue;
+      } else if (feature == AnalyzerOptions.enableStrictCallChecks) {
+        options.enableStrictCallChecks = true;
       } else if (feature == AnalyzerOptions.enableSuperMixins) {
         options.enableSuperMixins = boolValue;
       }
     }
   }
 
   void _applyLanguageOptions(AnalysisOptionsImpl options, Object configs) {
     if (configs is YamlMap) {
       configs.nodes.forEach((key, value) {
         if (key is YamlScalar && value is YamlScalar) {
@@ skipping 34 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;
     }
   }
 }