Format analyzer, analysis_server, analyzer_plugin, front_end and kernel with the latest dartfmt.

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/context/context_root.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
@@ skipping 70 matching lines @@
 
   Uri convertedDirectoryUri(String directoryPath) {
     return new Uri.directory(resourceProvider.convertPath(directoryPath),
         windows: pathContext.style == path.windows.style);
   }
 
   void createDefaultSdk(Folder sdkDir) {
     defaultSdkPath = pathContext.join(sdkDir.path, 'default', 'sdk');
     String librariesFilePath = pathContext.join(defaultSdkPath, 'lib',
         '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart');
-    resourceProvider.newFile(
-        librariesFilePath,
-        r'''
+    resourceProvider.newFile(librariesFilePath, r'''
 const Map<String, LibraryInfo> libraries = const {
   "async": const LibraryInfo("async/async.dart"),
   "core": const LibraryInfo("core/core.dart"),
 };
 ''');
     sdkManager = new DartSdkManager(defaultSdkPath, false);
     builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: builderOptions);
   }
 
@@ skipping 26 matching lines @@
     var builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: createContextBuilderOptions(argResults));
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = true;
     expected.lintRules = Registry.ruleRegistry.defaultRules;
 
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_cmdline_lint_defined() {
     _defineMockLintRules();
     ArgParser argParser = new ArgParser();
     defineAnalysisArguments(argParser);
     ArgResults argResults = argParser.parse(['--$lintsFlag']);
     var builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: createContextBuilderOptions(argResults));
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = true;
     expected.lintRules = <LintRule>[
       Registry.ruleRegistry['mock_lint_rule'],
     ];
 
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 linter:
   rules:
     - mock_lint_rule
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_cmdline_lint_off() {
     ArgParser argParser = new ArgParser();
     defineAnalysisArguments(argParser);
     ArgResults argResults = argParser.parse(['--no-$lintsFlag']);
     var builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: createContextBuilderOptions(argResults));
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = false;
     expected.lintRules = <LintRule>[
       Registry.ruleRegistry['mock_lint_rule'],
     ];
 
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 linter:
   rules:
     - mock_lint_rule
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_cmdline_lint_unspecified_1() {
     ArgParser argParser = new ArgParser();
     defineAnalysisArguments(argParser);
     ArgResults argResults = argParser.parse([]);
     var builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: createContextBuilderOptions(argResults));
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = true;
     expected.lintRules = <LintRule>[
       Registry.ruleRegistry['mock_lint_rule'],
     ];
 
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 linter:
   rules:
     - mock_lint_rule
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_cmdline_lint_unspecified_2() {
     ArgParser argParser = new ArgParser();
     defineAnalysisArguments(argParser);
     ArgResults argResults = argParser.parse([]);
     var builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: createContextBuilderOptions(argResults));
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = false;
     expected.lintRules = <LintRule>[];
 
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_cmdline_options_override_options_file() {
     ArgParser argParser = new ArgParser();
     defineAnalysisArguments(argParser);
     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);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 analyzer:
   language:
     enableSuperMixins : true
     enableStrictCallChecks : false
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
@@ skipping 86 matching lines @@
   }
 
   void test_createPackageMap_fromPackageFile_explicit() {
     // Use a package file that is outside the project directory's hierarchy.
     String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(rootPath, 'child', '.packages');
     resourceProvider.newFolder(projectPath);
     Uri fooUri = convertedDirectoryUri('/pkg/foo');
     Uri barUri = convertedDirectoryUri('/pkg/bar');
-    createFile(
-        packageFilePath,
-        '''
+    createFile(packageFilePath, '''
 foo:$fooUri
 bar:$barUri
 ''');
 
     builderOptions.defaultPackageFilePath = packageFilePath;
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
     expect(map['foo'], fooUri);
     expect(map['bar'], barUri);
   }
 
   void test_createPackageMap_fromPackageFile_inParentOfRoot() {
     // Use a package file that is inside the parent of the project directory.
     String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(rootPath, '.packages');
     resourceProvider.newFolder(projectPath);
     Uri fooUri = convertedDirectoryUri('/pkg/foo');
     Uri barUri = convertedDirectoryUri('/pkg/bar');
-    createFile(
-        packageFilePath,
-        '''
+    createFile(packageFilePath, '''
 foo:$fooUri
 bar:$barUri
 ''');
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
     expect(map['foo'], fooUri);
     expect(map['bar'], barUri);
   }
 
   void test_createPackageMap_fromPackageFile_inRoot() {
     // Use a package file that is inside the project directory.
     String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     resourceProvider.newFolder(projectPath);
     Uri fooUri = convertedDirectoryUri('/pkg/foo');
     Uri barUri = convertedDirectoryUri('/pkg/bar');
-    createFile(
-        packageFilePath,
-        '''
+    createFile(packageFilePath, '''
 foo:$fooUri
 bar:$barUri
 ''');
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
     expect(map['foo'], fooUri);
     expect(map['bar'], barUri);
@@ skipping 52 matching lines @@
   void test_createSourceFactory_noProvider_packages_embedder_extensions() {
     String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String embedderPath = pathContext.join(packageA, '_embedder.yaml');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
     String extensionPath = pathContext.join(packageB, '_sdkext');
-    createFile(
-        packageFilePath,
-        '''
+    createFile(packageFilePath, '''
 a:${pathContext.toUri(packageA)}
 b:${pathContext.toUri(packageB)}
 ''');
     String asyncPath = pathContext.join(packageA, 'sdk', 'async.dart');
     String corePath = pathContext.join(packageA, 'sdk', 'core.dart');
-    createFile(
-        embedderPath,
-        '''
+    createFile(embedderPath, '''
 embedded_libs:
   "dart:async": ${_relativeUri(asyncPath, from: packageA)}
   "dart:core": ${_relativeUri(corePath, from: packageA)}
 ''');
     String fooPath = pathContext.join(packageB, 'ext', 'foo.dart');
-    createFile(
-        extensionPath,
-        '''{
+    createFile(extensionPath, '''{
 "dart:foo": "${_relativeUri(fooPath, from: packageB)}"
 }''');
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 
     SourceFactory factory = builder.createSourceFactory(projectPath, options);
 
     Source asyncSource = factory.forUri('dart:async');
     expect(asyncSource, isNotNull);
     expect(asyncSource.fullName, asyncPath);
 
     Source fooSource = factory.forUri('dart:foo');
     expect(fooSource, isNotNull);
     expect(fooSource.fullName, fooPath);
 
     Source packageSource = factory.forUri('package:b/b.dart');
     expect(packageSource, isNotNull);
     expect(packageSource.fullName, pathContext.join(packageB, 'b.dart'));
   }
 
   void test_createSourceFactory_noProvider_packages_embedder_noExtensions() {
     String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String embedderPath = pathContext.join(packageA, '_embedder.yaml');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
-    createFile(
-        packageFilePath,
-        '''
+    createFile(packageFilePath, '''
 a:${pathContext.toUri(packageA)}
 b:${pathContext.toUri(packageB)}
 ''');
     String asyncPath = pathContext.join(packageA, 'sdk', 'async.dart');
     String corePath = pathContext.join(packageA, 'sdk', 'core.dart');
-    createFile(
-        embedderPath,
-        '''
+    createFile(embedderPath, '''
 embedded_libs:
   "dart:async": ${_relativeUri(asyncPath, from: packageA)}
   "dart:core": ${_relativeUri(corePath, from: packageA)}
 ''');
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 
     SourceFactory factory = builder.createSourceFactory(projectPath, options);
 
     Source dartSource = factory.forUri('dart:async');
     expect(dartSource, isNotNull);
@@ skipping 10 matching lines @@
   }
 
   void test_createSourceFactory_noProvider_packages_noEmbedder_noExtensions() {
     String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
-    createFile(
-        packageFilePath,
-        '''
+    createFile(packageFilePath, '''
 a:${pathContext.toUri(packageA)}
 b:${pathContext.toUri(packageB)}
 ''');
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 
     SourceFactory factory = builder.createSourceFactory(projectPath, options);
 
     Source dartSource = factory.forUri('dart:core');
     expect(dartSource, isNotNull);
     expect(dartSource.fullName,
@@ skipping 119 matching lines @@
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = true;
     expected.lintRules = <Linter>[_mockLintRule];
     String packagesFilePath =
         resourceProvider.convertPath('/some/directory/path/.packages');
     createFile(packagesFilePath, 'flutter:/pkg/flutter/lib/');
     String optionsFilePath = resourceProvider
         .convertPath('/pkg/flutter/lib/analysis_options_user.yaml');
-    createFile(
-        optionsFilePath,
-        '''
+    createFile(optionsFilePath, '''
 linter:
   rules:
     - mock_lint_rule
 ''');
     String projPath = resourceProvider.convertPath('/some/directory/path');
     AnalysisOptions options = builder.getAnalysisOptions(projPath);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_default_flutter_disabled() {
     _defineMockLintRules();
     ArgParser argParser = new ArgParser();
     defineAnalysisArguments(argParser);
     ArgResults argResults =
         argParser.parse(['--no-$packageDefaultAnalysisOptions']);
 
     builderOptions = createContextBuilderOptions(argResults);
     expect(builderOptions.packageDefaultAnalysisOptions, isFalse);
     builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
         options: builderOptions);
 
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
 
     String packagesFilePath =
         resourceProvider.convertPath('/some/directory/path/.packages');
     createFile(packagesFilePath, 'flutter:/pkg/flutter/lib/');
     String optionsFilePath = resourceProvider
         .convertPath('/pkg/flutter/lib/analysis_options_user.yaml');
-    createFile(
-        optionsFilePath,
-        '''
+    createFile(optionsFilePath, '''
 linter:
   rules:
     - mock_lint_rule
 ''');
     String projPath = resourceProvider.convertPath('/some/directory/path');
     AnalysisOptions options = builder.getAnalysisOptions(projPath);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_default_flutter_repo() {
     _defineMockLintRules();
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.lint = true;
     expected.lintRules = <Linter>[_mockLintRule, _mockPublicMemberApiDocs];
     String packagesFilePath =
         resourceProvider.convertPath('/some/directory/path/.packages');
     createFile(packagesFilePath, 'flutter:/pkg/flutter/lib/');
     String optionsFilePath = resourceProvider
         .convertPath('/pkg/flutter/lib/analysis_options_user.yaml');
-    createFile(
-        optionsFilePath,
-        '''
+    createFile(optionsFilePath, '''
 linter:
   rules:
     - mock_lint_rule
 ''');
     String projPath = resourceProvider.convertPath('/some/directory/path');
     AnalysisOptions options;
     try {
       ContextBuilderOptions.flutterRepo = true;
       options = builder.getAnalysisOptions(projPath);
     } finally {
       ContextBuilderOptions.flutterRepo = false;
     }
     _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,
-        '''
+    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,
-        '''
+    resourceProvider.newFile(filePath, '''
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_gnWorkspace() {
@@ skipping 23 matching lines @@
     builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     expected.lint = true;
     expected.lintRules = <Linter>[
       _mockLintRule,
       _mockLintRule2,
       _mockLintRule3
     ];
     resourceProvider.newFile(
-        resourceProvider.convertPath('/mypkgs/somepkg/lib/here.yaml'),
-        '''
+        resourceProvider.convertPath('/mypkgs/somepkg/lib/here.yaml'), '''
 linter:
   rules:
     - mock_lint_rule3
 ''');
     String path = resourceProvider.convertPath('/some/directory/path');
-    resourceProvider.newFile(
-        pathContext.join(path, '.packages'),
-        '''
+    resourceProvider.newFile(pathContext.join(path, '.packages'), '''
 somepkg:../../../mypkgs/somepkg/lib
 ''');
-    resourceProvider.newFile(
-        pathContext.join(path, 'bar.yaml'),
-        '''
+    resourceProvider.newFile(pathContext.join(path, 'bar.yaml'), '''
 include: package:somepkg/here.yaml
 analyzer:
   language:
     enableSuperMixins : true
 linter:
   rules:
     - mock_lint_rule2
 ''');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 include: bar.yaml
 linter:
   rules:
     - mock_lint_rule
 ''');
 
     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, ';');
 
     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,
-        '''
+    resourceProvider.newFile(filePath, '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
     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,
-        '''
+    resourceProvider.newFile(filePath, '''
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
     AnalysisOptions options = builder.getAnalysisOptions(path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_optionsPath() {
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    resourceProvider.newFile(
-        filePath,
-        '''
+    resourceProvider.newFile(filePath, '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
     ContextRoot root = new ContextRoot(path, []);
     builder.getAnalysisOptions(path, contextRoot: root);
     expect(root.optionsFilePath, equals(filePath));
   }
 
@@ skipping 125 matching lines @@
 class _MockLintRule implements LintRule {
   final String _name;
 
   _MockLintRule(this._name);
 
   @override
   String get name => _name;
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }