Remove the AnalysisOptionsProcessor

pkg/analyzer/test/src/context/builder_test.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 analyzer.test.src.context.context_builder_test;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
-import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/src/context/builder.dart';
 import 'package:analyzer/src/context/source.dart';
 import 'package:analyzer/src/generated/bazel.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/plugin/options_plugin.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/src/packages_impl.dart';
 import 'package:path/path.dart' as path;
-import 'package:plugin/src/plugin_impl.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../embedder_tests.dart';
 import '../../generated/test_support.dart';
 import 'mock_sdk.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ContextBuilderTest);
@@ skipping 475 matching lines @@
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
-    AnalysisOptions options = builder.getAnalysisOptions(context, path);
+    AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_default_overrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.enableLazyAssignmentOperators = true;
     builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     expected.enableLazyAssignmentOperators = true;
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
-    AnalysisEngine engine = AnalysisEngine.instance;
-    OptionsPlugin plugin = engine.optionsPlugin;
-    plugin.registerExtensionPoints((_) {});
-    try {
-      _TestOptionsProcessor processor = new _TestOptionsProcessor();
-      processor.expectedOptions = <String, Object>{
-        'analyzer': {
-          'language': {'enableSuperMixins': true}
-        }
-      };
-      (plugin.optionsProcessorExtensionPoint as ExtensionPointImpl)
-          .add(processor);
-      AnalysisContext context = engine.createAnalysisContext();
-      AnalysisOptions options = builder.getAnalysisOptions(context, path);
-      _expectEqualOptions(options, expected);
-    } finally {
-      plugin.registerExtensionPoints((_) {});
-    }
+    AnalysisOptions options = builder.getAnalysisOptions(path);
+    _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_includes() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     resourceProvider.newFile(
         resourceProvider.convertPath('/mypkgs/somepkg/lib/here.yaml'),
         '''
@@ skipping 15 matching lines @@
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 include: bar.yaml
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
-    AnalysisEngine engine = AnalysisEngine.instance;
-    OptionsPlugin plugin = engine.optionsPlugin;
-    plugin.registerExtensionPoints((_) {});
-    try {
-      _TestOptionsProcessor processor = new _TestOptionsProcessor();
-      processor.expectedOptions = <String, Object>{
-        'analyzer': {
-          'language': {'enableSuperMixins': true}
-        },
-        'foo': {'bar': 'baz'},
-        'two': {'boo': 'newt'},
-      };
-      (plugin.optionsProcessorExtensionPoint as ExtensionPointImpl)
-          .add(processor);
-      AnalysisContext context = engine.createAnalysisContext();
-      AnalysisOptions options = builder.getAnalysisOptions(context, path);
-      _expectEqualOptions(options, expected);
-    } finally {
-      plugin.registerExtensionPoints((_) {});
-    }
+    AnalysisOptions options = builder.getAnalysisOptions(path);
+    _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_invalid() {
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(filePath, ';');
 
-    AnalysisEngine engine = AnalysisEngine.instance;
-    OptionsPlugin plugin = engine.optionsPlugin;
-    plugin.registerExtensionPoints((_) {});
-    try {
-      _TestOptionsProcessor processor = new _TestOptionsProcessor();
-      (plugin.optionsProcessorExtensionPoint as ExtensionPointImpl)
-          .add(processor);
-      AnalysisContext context = engine.createAnalysisContext();
-      AnalysisOptions options = builder.getAnalysisOptions(context, path);
-      expect(options, isNotNull);
-      expect(processor.errorCount, 1);
-    } finally {
-      plugin.registerExtensionPoints((_) {});
-    }
+    AnalysisOptions options = builder.getAnalysisOptions(path);
+    expect(options, isNotNull);
   }
 
   void test_getAnalysisOptions_noDefault_noOverrides() {
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
-    AnalysisOptions options = builder.getAnalysisOptions(context, path);
+    AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, new AnalysisOptionsImpl());
   }
 
   void test_getAnalysisOptions_noDefault_overrides() {
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
-    AnalysisOptions options = builder.getAnalysisOptions(context, path);
+    AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getOptionsFile_explicit() {
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath = resourceProvider.convertPath('/options/analysis.yaml');
     resourceProvider.newFile(filePath, '');
 
     builderOptions.defaultAnalysisOptionsFilePath = filePath;
     File result = builder.getOptionsFile(path);
@@ skipping 97 matching lines @@
     expect(locator.embedderYamls, hasLength(0));
   }
 
   void test_valid() {
     EmbedderYamlLocator locator = new EmbedderYamlLocator({
       'fox': <Folder>[pathTranslator.getResource(foxLib)]
     });
     expect(locator.embedderYamls, hasLength(1));
   }
 }
-
-class _TestOptionsProcessor implements OptionsProcessor {
-  Map<String, Object> expectedOptions = null;
-
-  int errorCount = 0;
-
-  @override
-  void onError(Exception exception) {
-    errorCount++;
-  }
-
-  @override
-  void optionsProcessed(AnalysisContext context, Map<String, Object> options) {
-    if (expectedOptions == null) {
-      fail('Unexpected invocation of optionsProcessed');
-    }
-    expect(options, hasLength(expectedOptions.length));
-    for (String key in expectedOptions.keys) {
-      expect(options.containsKey(key), isTrue, reason: 'missing key $key');
-      expect(options[key], expectedOptions[key],
-          reason: 'values for key $key do not match');
-    }
-  }
-}