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

pkg/analyzer/test/generated/non_error_resolver_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.non_error_resolver_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 126 matching lines @@
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_ambiguousExport() async {
     Source source = addSource(r'''
 library L;
 export 'lib1.dart';
 export 'lib2.dart';''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class M {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_ambiguousExport_combinators_hide() async {
     Source source = addSource(r'''
 library L;
 export 'lib1.dart';
 export 'lib2.dart' hide B;''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library L1;
 class A {}
 class B {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library L2;
 class B {}
 class C {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_ambiguousExport_combinators_show() async {
     Source source = addSource(r'''
 library L;
 export 'lib1.dart';
 export 'lib2.dart' show C;''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library L1;
 class A {}
 class B {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library L2;
 class B {}
 class C {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_ambiguousExport_sameDeclaration() async {
     Source source = addSource(r'''
 library L;
 export 'lib.dart';
 export 'lib.dart';''');
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class N {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_ambiguousImport_hideCombinator() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 import 'lib3.dart' hide N;
 main() {
   new N1();
   new N2();
   new N3();
 }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}
 class N1 {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}
 class N2 {}''');
-    addNamedSource(
-        "/lib3.dart",
-        r'''
+    addNamedSource("/lib3.dart", r'''
 library lib3;
 class N {}
 class N3 {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
   }
 
   test_ambiguousImport_showCombinator() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart' show N, N2;
 main() {
   new N1();
   new N2();
 }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}
 class N1 {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}
 class N2 {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [HintCode.UNUSED_SHOWN_NAME]);
   }
 
   test_annotated_partOfDeclaration() async {
     Source source = addSource('library L; part "part.dart";');
     addNamedSource('/part.dart', '@deprecated part of L;');
@@ skipping 241 matching lines @@
     verify([source]);
   }
 
   test_assignmentToFinals_importWithPrefix() async {
     Source source = addSource(r'''
 library lib;
 import 'lib1.dart' as foo;
 main() {
   foo.x = true;
 }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 bool x = false;''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_async_dynamic_with_return() async {
     Source source = addSource('''
 dynamic f() async {
@@ skipping 762 matching lines @@
     Source source = addSource('''
 const Type d = dynamic;
 ''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_const_imported_defaultParameterValue_withImportPrefix() async {
     resetWith(options: new AnalysisOptionsImpl()..strongMode = true);
-    Source source = addNamedSource(
-        "/a.dart",
-        r'''
+    Source source = addNamedSource("/a.dart", r'''
 import 'b.dart';
 const b = const B();
 ''');
-    addNamedSource(
-        "/b.dart",
-        r'''
+    addNamedSource("/b.dart", r'''
 import 'c.dart' as ccc;
 class B {
   const B([p = ccc.value]);
 }
 ''');
-    addNamedSource(
-        "/c.dart",
-        r'''
+    addNamedSource("/c.dart", r'''
 const int value = 12345;
 ''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_constConstructorWithNonConstSuper_explicit() async {
     Source source = addSource(r'''
 class A {
@@ skipping 103 matching lines @@
   test_constEval_functionTypeLiteral() async {
     Source source = addSource(r'''
 typedef F();
 const C = F;''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_constEval_propertyExtraction_fieldStatic_targetType() async {
-    addNamedSource(
-        "/math.dart",
-        r'''
+    addNamedSource("/math.dart", r'''
 library math;
 const PI = 3.14;''');
     Source source = addSource(r'''
 import 'math.dart' as math;
 const C = math.PI;''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_constEval_propertyExtraction_methodStatic_targetType() async {
     Source source = addSource(r'''
 class A {
   const A();
   static m() {}
 }
 const C = A.m;''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_constEval_symbol() async {
-    addNamedSource(
-        "/math.dart",
-        r'''
+    addNamedSource("/math.dart", r'''
 library math;
 const PI = 3.14;''');
     Source source = addSource(r'''
 const C = #foo;
 foo() {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 219 matching lines @@
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_deprecatedMemberUse_hide() async {
     Source source = addSource(r'''
 library lib;
 import 'lib1.dart' hide B;
 A a = new A();''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}
 @deprecated
 class B {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_duplicateDefinition_emptyName() async {
@@ skipping 782 matching lines @@
       HintCode.UNUSED_IMPORT
     ]);
     verify([source]);
   }
 
   test_importOfNonLibrary_libraryDeclared() async {
     Source source = addSource(r'''
 library lib;
 import 'part.dart';
 A a;''');
-    addNamedSource(
-        "/part.dart",
-        r'''
+    addNamedSource("/part.dart", r'''
 library lib1;
 class A {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_importOfNonLibrary_libraryNotDeclared() async {
     Source source = addSource(r'''
 library lib;
 import 'part.dart';
 A a;''');
     addNamedSource("/part.dart", "class A {}");
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_importPrefixes_withFirstLetterDifference() async {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as math;
 import 'lib2.dart' as path;
 main() {
   math.test1();
   path.test2();
 }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 test1() {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 test2() {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_inconsistentCaseExpressionTypes() async {
     Source source = addSource(r'''
 f(var p) {
@@ skipping 221 matching lines @@
     assertNoErrors(source);
     verify([source]);
   }
 
   test_instanceMethodNameCollidesWithSuperclassStatic_field() async {
     Source source = addSource(r'''
 import 'lib.dart';
 class B extends A {
   _m() {}
 }''');
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library L;
 class A {
   static var _m;
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_instanceMethodNameCollidesWithSuperclassStatic_method() async {
     Source source = addSource(r'''
 import 'lib.dart';
 class B extends A {
   _m() {}
 }''');
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library L;
 class A {
   static _m() {}
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidAnnotation_constantVariable_field() async {
     Source source = addSource(r'''
 @A.C
 class A {
   static const C = 0;
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidAnnotation_constantVariable_field_importWithPrefix() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A {
   static const C = 0;
 }''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.A.C
 main() {
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidAnnotation_constantVariable_topLevel() async {
     Source source = addSource(r'''
 const C = 0;
 @C
 main() {
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidAnnotation_constantVariable_topLevel_importWithPrefix() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 const C = 0;''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.C
 main() {
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidAnnotation_constConstructor_importWithPrefix() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A {
   const A(int p);
 }''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.A(42)
 main() {
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidAnnotation_constConstructor_named_importWithPrefix() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A {
   const A.named(int p);
 }''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.A.named(42)
 main() {
 }''');
     await computeAnalysisResult(source);
@@ skipping 307 matching lines @@
 }
 class B extends A {
   m(a) {}
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_interface() async {
-    Source source = addNamedSource(
-        "/test.dart",
-        r'''
+    Source source = addNamedSource("/test.dart", r'''
 abstract class A {
   num m();
 }
 class B implements A {
   int m() { return 1; }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_interface2() async {
-    Source source = addNamedSource(
-        "/test.dart",
-        r'''
+    Source source = addNamedSource("/test.dart", r'''
 abstract class A {
   num m();
 }
 abstract class B implements A {
 }
 class C implements B {
   int m() { return 1; }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_mixin() async {
-    Source source = addNamedSource(
-        "/test.dart",
-        r'''
+    Source source = addNamedSource("/test.dart", r'''
 class A {
   num m() { return 0; }
 }
 class B extends Object with A {
   int m() { return 1; }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_parameterizedTypes() async {
     Source source = addSource(r'''
 abstract class A<E> {
   List<E> m();
 }
 class B extends A<dynamic> {
   List<dynamic> m() { return new List<dynamic>(); }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_sameType() async {
-    Source source = addNamedSource(
-        "/test.dart",
-        r'''
+    Source source = addNamedSource("/test.dart", r'''
 class A {
   int m() { return 0; }
 }
 class B extends A {
   int m() { return 1; }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_superclass() async {
-    Source source = addNamedSource(
-        "/test.dart",
-        r'''
+    Source source = addNamedSource("/test.dart", r'''
 class A {
   num m() { return 0; }
 }
 class B extends A {
   int m() { return 1; }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_invalidOverrideReturnType_returnType_superclass2() async {
-    Source source = addNamedSource(
-        "/test.dart",
-        r'''
+    Source source = addNamedSource("/test.dart", r'''
 class A {
   num m() { return 0; }
 }
 class B extends A {
 }
 class C extends B {
   int m() { return 1; }
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
@@ skipping 1417 matching lines @@
   h(g);
 }
 h(x) {}
 ''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_prefixCollidesWithTopLevelMembers() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A {}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 typedef P();
 p2() {}
 var p3;
 class p4 {}
 p.A a;''');
     await computeAnalysisResult(source);
@@ skipping 977 matching lines @@
 f(Type t) {}
 main() {
   f(C);
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_typeType_class_prefixed() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class C {}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 f(Type t) {}
 main() {
   f(p.C);
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_typeType_functionTypeAlias() async {
     Source source = addSource(r'''
 typedef F();
 f(Type t) {}
 main() {
   f(F);
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_typeType_functionTypeAlias_prefixed() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 typedef F();''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 f(Type t) {}
 main() {
   f(p.F);
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
@@ skipping 179 matching lines @@
   test_undefinedOperator_tilde() async {
     Source source = addSource(r'''
 const A = 3;
 const B = ~((1 << A) - 1);''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_undefinedSetter_importWithPrefix() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 set y(int value) {}''');
     Source source = addSource(r'''
 import 'lib.dart' as x;
 main() {
   x.y = 0;
 }''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 400 matching lines @@
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
     reset();
   }
 
   Future<Null> _check_wrongNumberOfParametersForOperator1(String name) async {
     await _check_wrongNumberOfParametersForOperator(name, "a");
   }
 }