Remove uses of configuration data

pkg/analyzer/lib/src/generated/engine.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 analyzer.src.generated.engine;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
+import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/context/builder.dart' show EmbedderYamlLocator;
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/plugin/command_line_plugin.dart';
 import 'package:analyzer/src/plugin/engine_plugin.dart';
 import 'package:analyzer/src/plugin/options_plugin.dart';
+import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:front_end/src/base/timestamped_data.dart';
 import 'package:html/dom.dart' show Document;
 import 'package:path/path.dart' as pathos;
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 
 export 'package:analyzer/error/listener.dart' show RecordingErrorListener;
@@ skipping 311 matching lines @@
    */
   CompilationUnitElement getCompilationUnitElement(
       Source unitSource, Source librarySource);
 
   /**
    * Return configuration data associated with the given key or the [key]'s
    * default value if no state has been associated.
    *
    * See [setConfigurationData].
    */
+  @deprecated
   Object/*=V*/ getConfigurationData/*<V>*/(ResultDescriptor/*<V>*/ key);
 
   /**
    * Return the contents and timestamp of the given [source].
    *
    * This method should be used rather than the method [Source.getContents]
    * because contexts can have local overrides of the content of a source that
    * the source is not aware of.
    */
   TimestampedData<String> getContents(Source source);
@@ skipping 247 matching lines @@
    * is used by the context to determine what reanalysis is necessary.
    */
   void setChangedContents(
       Source source, String contents, int offset, int oldLength, int newLength);
 
   /**
    * Associate this configuration [data] object with the given descriptor [key].
    *
    * See [getConfigurationData].
    */
+  @deprecated
   void setConfigurationData(ResultDescriptor key, Object data);
 
   /**
    * Set the contents of the given [source] to the given [contents] and mark the
    * source as having changed. This has the effect of overriding the default
    * contents of the source. If the contents are `null` the override is removed
    * so that the default contents will be returned.
    */
   void setContents(Source source, String contents);
 }
@@ skipping 507 matching lines @@
    * Object, and are allowed to reference `super`.
    */
   bool get enableSuperMixins;
 
   /**
    * Return `true` if timing data should be gathered during execution.
    */
   bool get enableTiming;
 
   /**
+   * Return a list of error processors that are to be used when reporting
+   * errors in some analysis context.
+   */
+  List<ErrorProcessor> get errorProcessors;
+
+  /**
+   * Return a list of exclude patterns used to exclude some sources from
+   * analysis.
+   */
+  List<String> get excludePatterns;
+
+  /**
    * A flag indicating whether finer grained dependencies should be used
    * instead of just source level dependencies.
    *
    * This option is experimental and subject to change.
    */
   bool get finerGrainedInvalidation;
 
   /**
    * Return `true` if errors, warnings and hints should be generated for sources
    * that are implicitly being analyzed. The default value is `true`.
@@ skipping 28 matching lines @@
    * analysis.
    */
   bool get incrementalValidation;
 
   /**
    * Return `true` if analysis is to generate lint warnings.
    */
   bool get lint;
 
   /**
+   * Return a list of the lint rules that are to be run in an analysis context
+   * if [lint] returns `true`.
+   */
+  List<Linter> get lintRules;
+
+  /**
    * Return the "platform" bit mask which should be used to apply patch files,
    * or `0` if no patch files should be applied.
    */
   int get patchPlatform;
 
   /**
    * Return `true` if analysis is to parse comments.
    */
   bool get preserveComments;
 
@@ skipping 98 matching lines @@
 
   @override
   bool enableStrictCallChecks = false;
 
   @override
   bool enableSuperMixins = false;
 
   @override
   bool enableTiming = false;
 
+  /**
+   * A list of error processors that are to be used when reporting errors in
+   * some analysis context.
+   */
+  List<ErrorProcessor> _errorProcessors;
+
+  /**
+   * A list of exclude patterns used to exclude some sources from analysis.
+   */
+  List<String> _excludePatterns;
+
   @override
   bool generateImplicitErrors = true;
 
   @override
   bool generateSdkErrors = false;
 
   @override
   bool hint = true;
 
   @override
   bool incremental = false;
 
   @override
   bool incrementalApi = false;
 
   @override
   bool incrementalValidation = false;
 
   @override
   bool lint = false;
 
+  /**
+   * The lint rules that are to be run in an analysis context if [lint] returns
+   * `true`.
+   */
+  List<Linter> _lintRules;
+
   @override
   int patchPlatform = 0;
 
   @override
   bool preserveComments = true;
 
   @override
   bool strongMode = false;
 
   /**
@@ skipping 52 matching lines @@
   AnalysisOptionsImpl.from(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     dart2jsHint = options.dart2jsHint;
     enableAssertInitializer = options.enableAssertInitializer;
     enableAssertMessage = options.enableAssertMessage;
     enableStrictCallChecks = options.enableStrictCallChecks;
     enableInitializingFormalAccess = options.enableInitializingFormalAccess;
     enableLazyAssignmentOperators = options.enableLazyAssignmentOperators;
     enableSuperMixins = options.enableSuperMixins;
     enableTiming = options.enableTiming;
+    errorProcessors = options.errorProcessors;
+    excludePatterns = options.excludePatterns;
     generateImplicitErrors = options.generateImplicitErrors;
     generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
+    lintRules = options.lintRules;
     preserveComments = options.preserveComments;
     strongMode = options.strongMode;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
       implicitCasts = options.implicitCasts;
       nonnullableTypes = options.nonnullableTypes;
       implicitDynamic = options.implicitDynamic;
     }
     trackCacheDependencies = options.trackCacheDependencies;
     disableCacheFlushing = options.disableCacheFlushing;
@@ skipping 47 matching lines @@
   void set enableConditionalDirectives(_) {}
 
   @override
   @deprecated
   bool get enableGenericMethods => true;
 
   @deprecated
   void set enableGenericMethods(bool enable) {}
 
   @override
+  List<ErrorProcessor> get errorProcessors =>
+      _errorProcessors ??= const <ErrorProcessor>[];
+
+  /**
+   * Set the list of error [processors] that are to be used when reporting
+   * errors in some analysis context.
+   */
+  void set errorProcessors(List<ErrorProcessor> processors) {
+    _errorProcessors = processors;
+  }
+
+  @override
+  List<String> get excludePatterns => _excludePatterns ??= const <String>[];
+
+  /**
+   * Set the exclude patterns used to exclude some sources from analysis to
+   * those in the given list of [patterns].
+   */
+  void set excludePatterns(List<String> patterns) {
+    _excludePatterns = patterns;
+  }
+
+  @override
+  List<Linter> get lintRules => _lintRules ??= const <Linter>[];
+
+  /**
+   * Set the lint rules that are to be run in an analysis context if [lint]
+   * returns `true`.
+   */
+  void set lintRules(List<Linter> rules) {
+    _lintRules = rules;
+  }
+
+  @override
   List<int> encodeCrossContextOptions() {
     int flags = (enableAssertMessage ? ENABLE_ASSERT_FLAG : 0) |
         (enableLazyAssignmentOperators ? ENABLE_LAZY_ASSIGNMENT_OPERATORS : 0) |
         (enableStrictCallChecks ? ENABLE_STRICT_CALL_CHECKS_FLAG : 0) |
         (enableSuperMixins ? ENABLE_SUPER_MIXINS_FLAG : 0) |
         (strongMode ? ENABLE_STRONG_MODE_FLAG : 0) |
         (strongModeHints ? ENABLE_STRONG_MODE_HINTS_FLAG : 0);
     return <int>[flags, patchPlatform];
   }
 
@@ skipping 1217 matching lines @@
    */
   bool get wereSourcesAdded => _changeSet.addedSources.length > 0;
 
   /**
    * Return `true` if any sources were removed or deleted.
    */
   bool get wereSourcesRemoved =>
       _changeSet.removedSources.length > 0 ||
       _changeSet.removedContainers.length > 0;
 }