implement default analysis options in bazel

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/src/command_line/arguments.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/lint/linter.dart';
+import 'package:analyzer/src/lint/registry.dart';
+import 'package:analyzer/src/services/lint.dart';
 import 'package:args/args.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/src/packages_impl.dart';
 import 'package:path/path.dart' as path;
 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';
@@ skipping 92 matching lines @@
     ArgResults argResults = argParser.parse(['--$enableStrictCallChecksFlag']);
     var builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: createContextBuilderOptions(argResults));
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     expected.enableStrictCallChecks = true;
 
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
-    pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 analyzer:
   language:
     enableSuperMixins : true
     enableStrictCallChecks : false
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
@@ skipping 375 matching lines @@
         builder.findSdk(null, new AnalysisOptionsImpl()..strongMode = true);
     expect(sdk, isNotNull);
     Source htmlSource = sdk.mapDartUri('dart:html');
     expect(
         htmlSource.fullName,
         resourceProvider
             .convertPath('/sdk/lib/html/dart2js/html_dart2js.dart'));
     expect(htmlSource.exists(), isTrue);
   }
 
+  void test_getAnalysisOptions_default_bazel() {

[Brian Wilkerson, 2017/01/30 14:56:05]

Should we have a similar test for Gn?

[danrubel, 2017/01/30 19:00:44]

Good point, but I don't know an appropriate default for Gn. I can implement and
add a test in a subsequent CL once we determine a proper course of action.

+    MockLintRule mockLintRule = new MockLintRule('mock_lint_rule');
+    Registry.ruleRegistry.register(mockLintRule);
+    MockLintRule mockLintRule2 = new MockLintRule('mock_lint_rule2');
+    Registry.ruleRegistry.register(mockLintRule2);
+    AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
+    builderOptions.defaultOptions = defaultOptions;
+    AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
+    expected.lint = true;
+    expected.lintRules = <Linter>[mockLintRule];
+    createFile(resourceProvider.convertPath('/root/WORKSPACE'), '');
+    createFile(
+        resourceProvider
+            .convertPath('/root/dart/analysis_options/lib/default.yaml'),
+        '''
+linter:
+  rules:
+    - mock_lint_rule
+''');
+    createFile(
+        resourceProvider
+            .convertPath('/root/dart/analysis_options/lib/flutter.yaml'),
+        '''
+linter:
+  rules:
+    - mock_lint_rule2
+''');
+    AnalysisOptions options = builder
+        .getAnalysisOptions(resourceProvider.convertPath('/root/some/path'));
+    _expectEqualOptions(options, expected);
+  }
+
   void test_getAnalysisOptions_default_noOverrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.enableLazyAssignmentOperators = true;
     builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableLazyAssignmentOperators = true;
     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
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_default_overrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
+    defaultOptions.enableSuperMixins = false;
     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,
@@ skipping 156 matching lines @@
     expect(actual.enableStrictCallChecks, expected.enableStrictCallChecks);
     expect(actual.enableSuperMixins, expected.enableSuperMixins);
     expect(actual.enableTiming, expected.enableTiming);
     expect(actual.generateImplicitErrors, expected.generateImplicitErrors);
     expect(actual.generateSdkErrors, expected.generateSdkErrors);
     expect(actual.hint, expected.hint);
     expect(actual.incremental, expected.incremental);
     expect(actual.incrementalApi, expected.incrementalApi);
     expect(actual.incrementalValidation, expected.incrementalValidation);
     expect(actual.lint, expected.lint);
+    expect(
+      actual.lintRules.map((l) => l.name),
+      unorderedEquals(expected.lintRules.map((l) => l.name)),
+    );
     expect(actual.preserveComments, expected.preserveComments);
     expect(actual.strongMode, expected.strongMode);
     expect(actual.strongModeHints, expected.strongModeHints);
     expect(actual.implicitCasts, expected.implicitCasts);
     expect(actual.implicitDynamic, expected.implicitDynamic);
     expect(actual.trackCacheDependencies, expected.trackCacheDependencies);
     expect(actual.disableCacheFlushing, expected.disableCacheFlushing);
     expect(actual.finerGrainedInvalidation, expected.finerGrainedInvalidation);
   }
 
@@ skipping 18 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 MockLintRule implements LintRule {
+  final String _name;
+
+  MockLintRule(this._name);
+
+  @override
+  String get name => _name;
+
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}