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

pkg/analyzer/test/generated/all_the_rest_test.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.test.generated.all_the_rest_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 348 matching lines @@
   }
 
   @override
   void reset() {
     AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
     analysisOptions.hint = false;
     resetWith(options: analysisOptions);
   }
 
   test_locate_AssignmentExpression() async {
-    AstNode id = await _findNodeIn(
-        "+=",
-        r'''
+    AstNode id = await _findNodeIn("+=", r'''
 int x = 0;
 void main() {
   x += 1;
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement, MethodElement, element);
   }
 
   test_locate_BinaryExpression() async {
@@ skipping 11 matching lines @@
   }
 
   test_locate_CompilationUnit() async {
     CompilationUnit cu = await _resolveContents("// only comment");
     expect(cu.element, isNotNull);
     Element element = ElementLocator.locate(cu);
     expect(element, same(cu.element));
   }
 
   test_locate_ConstructorDeclaration() async {
-    AstNode id = await _findNodeIndexedIn(
-        "bar",
-        0,
-        r'''
+    AstNode id = await _findNodeIndexedIn("bar", 0, r'''
 class A {
   A.bar() {}
 }''');
     ConstructorDeclaration declaration =
         id.getAncestor((node) => node is ConstructorDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   test_locate_ExportDirective() async {
     AstNode id = await _findNodeIn("export", "export 'dart:core';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ExportElement, ExportElement, element);
   }
 
   test_locate_FunctionDeclaration() async {
     AstNode id = await _findNodeIn("f", "int f() => 3;");
     FunctionDeclaration declaration =
         id.getAncestor((node) => node is FunctionDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement, FunctionElement, element);
   }
 
   test_locate_Identifier_annotationClass_namedConstructor_forSimpleFormalParameter() async {
-    AstNode id = await _findNodeIndexedIn(
-        "Class",
-        2,
-        r'''
+    AstNode id = await _findNodeIndexedIn("Class", 2, r'''
 class Class {
   const Class.name();
 }
 void main(@Class.name() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement, ClassElement, element);
   }
 
   test_locate_Identifier_annotationClass_unnamedConstructor_forSimpleFormalParameter() async {
-    AstNode id = await _findNodeIndexedIn(
-        "Class",
-        2,
-        r'''
+    AstNode id = await _findNodeIndexedIn("Class", 2, r'''
 class Class {
   const Class();
 }
 void main(@Class() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   test_locate_Identifier_className() async {
     AstNode id = await _findNodeIn("A", "class A { }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement, ClassElement, element);
   }
 
   test_locate_Identifier_constructor_named() async {
-    AstNode id = await _findNodeIndexedIn(
-        "bar",
-        0,
-        r'''
+    AstNode id = await _findNodeIndexedIn("bar", 0, r'''
 class A {
   A.bar() {}
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   test_locate_Identifier_constructor_unnamed() async {
-    AstNode id = await _findNodeIndexedIn(
-        "A",
-        1,
-        r'''
+    AstNode id = await _findNodeIndexedIn("A", 1, r'''
 class A {
   A() {}
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   test_locate_Identifier_fieldName() async {
     AstNode id = await _findNodeIn("x", "class A { var x; }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldElement, FieldElement, element);
   }
 
   test_locate_Identifier_libraryDirective() async {
     AstNode id = await _findNodeIn("foo", "library foo.bar;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement, LibraryElement, element);
   }
 
   test_locate_Identifier_propertyAccess() async {
-    AstNode id = await _findNodeIn(
-        "length",
-        r'''
+    AstNode id = await _findNodeIn("length", r'''
 void main() {
  int x = 'foo'.length;
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement,
         PropertyAccessorElement, element);
   }
 
   test_locate_ImportDirective() async {
     AstNode id = await _findNodeIn("import", "import 'dart:core';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ImportElement, ImportElement, element);
   }
 
   test_locate_IndexExpression() async {
-    AstNode id = await _findNodeIndexedIn(
-        "\\[",
-        1,
-        r'''
+    AstNode id = await _findNodeIndexedIn("\\[", 1, r'''
 void main() {
   List x = [1, 2];
   var y = x[0];
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement, MethodElement, element);
   }
 
   test_locate_InstanceCreationExpression() async {
-    AstNode node = await _findNodeIndexedIn(
-        "A(",
-        0,
-        r'''
+    AstNode node = await _findNodeIndexedIn("A(", 0, r'''
 class A {}
 void main() {
  new A();
 }''');
     Element element = ElementLocator.locate(node);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   test_locate_InstanceCreationExpression_type_prefixedIdentifier() async {
@@ skipping 35 matching lines @@
   }
 
   test_locate_LibraryDirective() async {
     AstNode id = await _findNodeIn("library", "library foo;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement, LibraryElement, element);
   }
 
   test_locate_MethodDeclaration() async {
-    AstNode id = await _findNodeIn(
-        "m",
-        r'''
+    AstNode id = await _findNodeIn("m", r'''
 class A {
   void m() {}
 }''');
     MethodDeclaration declaration =
         id.getAncestor((node) => node is MethodDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement, MethodElement, element);
   }
 
   test_locate_MethodInvocation_method() async {
-    AstNode id = await _findNodeIndexedIn(
-        "bar",
-        1,
-        r'''
+    AstNode id = await _findNodeIndexedIn("bar", 1, r'''
 class A {
   int bar() => 42;
 }
 void main() {
  var f = new A().bar();
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement, MethodElement, element);
   }
 
   test_locate_MethodInvocation_topLevel() async {
     String code = r'''
 foo(x) {}
 void main() {
  foo(0);
 }''';
     CompilationUnit cu = await _resolveContents(code);
     int offset = code.indexOf('foo(0)');
     AstNode node = new NodeLocator(offset).searchWithin(cu);
     MethodInvocation invocation =
         node.getAncestor((n) => n is MethodInvocation);
     Element element = ElementLocator.locate(invocation);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement, FunctionElement, element);
   }
 
   test_locate_PartOfDirective() async {
-    Source librarySource = addNamedSource(
-        '/lib.dart',
-        '''
+    Source librarySource = addNamedSource('/lib.dart', '''
 library my.lib;
 part 'part.dart';
 ''');
-    Source unitSource = addNamedSource(
-        '/part.dart',
-        '''
+    Source unitSource = addNamedSource('/part.dart', '''
 part of my.lib;
 ''');
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit2(unitSource, librarySource);
     PartOfDirective partOf = unit.directives.first;
     Element element = ElementLocator.locate(partOf);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement, LibraryElement, element);
   }
 
   test_locate_PostfixExpression() async {
     AstNode id = await _findNodeIn("++", "int addOne(int x) => x++;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement, MethodElement, element);
   }
 
   test_locate_PrefixedIdentifier() async {
-    AstNode id = await _findNodeIn(
-        "int",
-        r'''
+    AstNode id = await _findNodeIn("int", r'''
 import 'dart:core' as core;
 core.int value;''');
     PrefixedIdentifier identifier =
         id.getAncestor((node) => node is PrefixedIdentifier);
     Element element = ElementLocator.locate(identifier);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement, ClassElement, element);
   }
 
   test_locate_PrefixExpression() async {
@@ skipping 1493 matching lines @@
     Uri result = resolveRelativeUri(base, contained);
     expect(result, isNotNull);
     expect(result.toString(), expectedStr);
   }
 }
 
 @deprecated
 @reflectiveTest
 class SDKLibrariesReaderTest extends EngineTestCase {
   test_readFrom_dart2js() async {
-    LibraryMap libraryMap = new SdkLibrariesReader(true).readFromFile(
-        FileUtilities2.createFile("/libs.dart"),
-        r'''
+    LibraryMap libraryMap = new SdkLibrariesReader(true)
+        .readFromFile(FileUtilities2.createFile("/libs.dart"), r'''
 final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
   'first' : const LibraryInfo(
     'first/first.dart',
     categories: 'Client',
     documented: true,
     platforms: VM_PLATFORM,
     dart2jsPath: 'first/first_dart2js.dart'),
 };''');
     expect(libraryMap, isNotNull);
     expect(libraryMap.size(), 1);
     SdkLibrary first = libraryMap.getLibrary("dart:first");
     expect(first, isNotNull);
     expect(first.category, "Client");
     expect(first.path, "first/first_dart2js.dart");
     expect(first.shortName, "dart:first");
     expect(first.isDart2JsLibrary, false);
     expect(first.isDocumented, true);
     expect(first.isImplementation, false);
     expect(first.isVmLibrary, true);
   }
 
   test_readFrom_empty() async {
     LibraryMap libraryMap = new SdkLibrariesReader(false)
         .readFromFile(FileUtilities2.createFile("/libs.dart"), "");
     expect(libraryMap, isNotNull);
     expect(libraryMap.size(), 0);
   }
 
   test_readFrom_normal() async {
-    LibraryMap libraryMap = new SdkLibrariesReader(false).readFromFile(
-        FileUtilities2.createFile("/libs.dart"),
-        r'''
+    LibraryMap libraryMap = new SdkLibrariesReader(false)
+        .readFromFile(FileUtilities2.createFile("/libs.dart"), r'''
 final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
   'first' : const LibraryInfo(
     'first/first.dart',
     categories: 'Client',
     documented: true,
     platforms: VM_PLATFORM),
 
   'second' : const LibraryInfo(
     'second/second.dart',
     categories: 'Server',
@@ skipping 51 matching lines @@
         resourceProvider.newFolder(resourceProvider.convertPath('/sdk'));
     resourceProvider.newFile(
         resourceProvider.convertPath(
             '/sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart'),
         '''
 const Map<String, LibraryInfo> libraries = const {
   "core": const LibraryInfo("core/core.dart")
 };
 ''');
     coreCorePath = resourceProvider.convertPath('/sdk/lib/core/core.dart');
-    resourceProvider.newFile(
-        coreCorePath,
-        '''
+    resourceProvider.newFile(coreCorePath, '''
 library dart.core;
 part 'int.dart';
 ''');
     coreIntPath = resourceProvider.convertPath('/sdk/lib/core/int.dart');
-    resourceProvider.newFile(
-        coreIntPath,
-        '''
+    resourceProvider.newFile(coreIntPath, '''
 part of dart.core;
 ''');
     sdk = new FolderBasedDartSdk(resourceProvider, sdkFolder);
   }
 }
 
 class _SourceMock extends TypedMock implements Source {}