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

pkg/analyzer/test/generated/simple_resolver_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.generated.simple_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 546 matching lines @@
   }
 
   test_empty() async {
     Source source = addSource("");
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_entryPoint_exported() async {
-    addNamedSource(
-        "/two.dart",
-        r'''
+    addNamedSource("/two.dart", r'''
 library two;
 main() {}''');
-    Source source = addNamedSource(
-        "/one.dart",
-        r'''
+    Source source = addNamedSource("/one.dart", r'''
 library one;
 export 'two.dart';''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, isNot(same(library)));
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_entryPoint_local() async {
-    Source source = addNamedSource(
-        "/one.dart",
-        r'''
+    Source source = addNamedSource("/one.dart", r'''
 library one;
 main() {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, same(library));
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_entryPoint_none() async {
     Source source = addNamedSource("/one.dart", "library one;");
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     expect(library.entryPoint, isNull);
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_enum_externalLibrary() async {
-    addNamedSource(
-        "/my_lib.dart",
-        r'''
+    addNamedSource("/my_lib.dart", r'''
 library my_lib;
 enum EEE {A, B, C}''');
     Source source = addSource(r'''
 import 'my_lib.dart';
 main() {
   EEE e = null;
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 243 matching lines @@
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(2));
     expect(classes[0].hasReferenceToSuper, isFalse);
     expect(classes[1].hasReferenceToSuper, isTrue);
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_import_hide() async {
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 set foo(value) {}
 class A {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 set foo(value) {}''');
-    Source source = addNamedSource(
-        "/lib3.dart",
-        r'''
+    Source source = addNamedSource("/lib3.dart", r'''
 import 'lib1.dart' hide foo;
 import 'lib2.dart';
 
 main() {
   foo = 0;
 }
 A a;''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_import_prefix() async {
-    addNamedSource(
-        "/two.dart",
-        r'''
+    addNamedSource("/two.dart", r'''
 library two;
 f(int x) {
   return x * x;
 }''');
-    Source source = addNamedSource(
-        "/one.dart",
-        r'''
+    Source source = addNamedSource("/one.dart", r'''
 library one;
 import 'two.dart' as _two;
 main() {
   _two.f(0);
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_import_prefix_doesNotExist() async {
     //
     // The primary purpose of this test is to ensure that we are only getting a
     // single error generated when the only problem is that an imported file
     // does not exist.
     //
-    Source source = addNamedSource(
-        "/a.dart",
-        r'''
+    Source source = addNamedSource("/a.dart", r'''
 import 'missing.dart' as p;
 int a = p.q + p.r.s;
 String b = p.t(a) + p.u(v: 0);
 p.T c = new p.T();
 class D<E> extends p.T {
   D(int i) : super(i);
   p.U f = new p.V();
 }
 class F implements p.T {
   p.T m(p.U u) => null;
 }
 class G extends Object with p.V {}
 class H extends D<p.W> {
   H(int i) : super(i);
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
     verify([source]);
   }
 
   test_import_show_doesNotExist() async {
     //
     // The primary purpose of this test is to ensure that we are only getting a
     // single error generated when the only problem is that an imported file
     // does not exist.
     //
-    Source source = addNamedSource(
-        "/a.dart",
-        r'''
+    Source source = addNamedSource("/a.dart", r'''
 import 'missing.dart' show q, r, t, u, T, U, V, W;
 int a = q + r.s;
 String b = t(a) + u(v: 0);
 T c = new T();
 class D<E> extends T {
   D(int i) : super(i);
   U f = new V();
 }
 class F implements T {
   T m(U u) => null;
 }
 class G extends Object with V {}
 class H extends D<W> {
   H(int i) : super(i);
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
     verify([source]);
   }
 
   test_import_spaceInUri() async {
-    addNamedSource(
-        "/sub folder/lib.dart",
-        r'''
+    addNamedSource("/sub folder/lib.dart", r'''
 library lib;
 foo() {}''');
-    Source source = addNamedSource(
-        "/app.dart",
-        r'''
+    Source source = addNamedSource("/app.dart", r'''
 import 'sub folder/lib.dart';
 
 main() {
   foo();
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 862 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }