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

pkg/analyzer/test/generated/static_warning_code_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.static_warning_code_test;
 
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source_io.dart';
@@ skipping 54 matching lines @@
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_SETTER]);
     verify([source]);
   }
 
   test_ambiguousImport_as() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f(p) {p as N;}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_extends() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A extends N {}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       CompileTimeErrorCode.EXTENDS_NON_CLASS
     ]);
   }
 
   test_ambiguousImport_implements() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A implements N {}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       CompileTimeErrorCode.IMPLEMENTS_NON_CLASS
     ]);
   }
 
   test_ambiguousImport_inPart() async {
     Source source = addSource(r'''
 library lib;
 import 'lib1.dart';
 import 'lib2.dart';
 part 'part.dart';''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
-    Source partSource = addNamedSource(
-        "/part.dart",
-        r'''
+    Source partSource = addNamedSource("/part.dart", r'''
 part of lib;
 class A extends N {}''');
     await computeAnalysisResult(source);
     await computeAnalysisResult(partSource);
     assertNoErrors(source);
     assertErrors(partSource, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       CompileTimeErrorCode.EXTENDS_NON_CLASS
     ]);
   }
 
   test_ambiguousImport_instanceCreation() async {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib2.dart';
 f() {new N();}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_is() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f(p) {p is N;}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_qualifier() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 g() { N.FOO; }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_typeAnnotation() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 typedef N FT(N p);
 N f(N p) {
   N v;
   return null;
 }
 class A {
   N m() { return null; }
 }
 class B<T extends N> {}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT
     ]);
   }
 
   test_ambiguousImport_typeArgument_annotation() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A<T> {}
 A<N> f() { return null; }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_typeArgument_instanceCreation() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A<T> {}
 f() {new A<N>();}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 class N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_varRead() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f() { g(v); }
 g(p) {}''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 var v;''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 var v;''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_varWrite() async {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f() { v = 0; }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 var v;''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 var v;''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_ambiguousImport_withPrefix() async {
     Source source = addSource(r'''
 library test;
 import 'lib1.dart' as p;
 import 'lib2.dart' as p;
 main() {
   p.f();
 }''');
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 f() {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 f() {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   test_argumentTypeNotAssignable_ambiguousClassName() async {
     // See dartbug.com/19624
-    Source source = addNamedSource(
-        "/lib1.dart",
-        r'''
+    Source source = addNamedSource("/lib1.dart", r'''
 library lib1;
 import 'lib2.dart';
 class _A {}
 f() {
   g((_A a) {});
 }''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class _A {}
 g(h(_A a)) {}''');
     // The name _A is private to the library it's defined in, so this is a type
     // mismatch. Furthermore, the error message should mention both _A and the
     // filenames so the user can figure out what's going on.
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
     List<AnalysisError> errors = analysisResult.errors;
     expect(errors, hasLength(1));
     AnalysisError error = errors[0];
@@ skipping 625 matching lines @@
         source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
     verify([source]);
   }
 
   test_conflictingDartImport() async {
     Source source = addSource(r'''
 import 'lib.dart';
 import 'dart:async';
 Future f = null;
 Stream s;''');
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class Future {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
   test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter() async {
     Source source = addSource(r'''
 class A {
   static set v(x) {}
@@ skipping 1511 matching lines @@
 void f() {
   var a = new A();
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source]);
   }
 
   test_newWithNonType_fromLibrary() async {
     Source source1 = addNamedSource("/lib.dart", "class B {}");
-    Source source2 = addNamedSource(
-        "/lib2.dart",
-        r'''
+    Source source2 = addNamedSource("/lib2.dart", r'''
 import 'lib.dart' as lib;
 void f() {
   var a = new lib.A();
 }
 lib.B b;''');
     await computeAnalysisResult(source1);
     await computeAnalysisResult(source2);
     assertErrors(source2, [StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source1]);
   }
@@ skipping 1046 matching lines @@
   }
 
   test_undefinedClassBoolean_variableDeclaration() async {
     Source source = addSource("f() { boolean v; }");
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS_BOOLEAN]);
   }
 
   test_undefinedGetter_fromLibrary() async {
     Source source1 = addNamedSource("/lib.dart", "");
-    Source source2 = addNamedSource(
-        "/lib2.dart",
-        r'''
+    Source source2 = addNamedSource("/lib2.dart", r'''
 import 'lib.dart' as lib;
 void f() {
   var g = lib.gg;
 }''');
     await computeAnalysisResult(source1);
     await computeAnalysisResult(source2);
     assertErrors(source2, [StaticWarningCode.UNDEFINED_GETTER]);
     verify([source1]);
   }
 
@@ skipping 30 matching lines @@
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   test_undefinedIdentifier_methodInvocation() async {
     Source source = addSource("f() { C.m(); }");
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   test_undefinedIdentifier_private_getter() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A {
   var _foo;
 }''');
     Source source = addSource(r'''
 import 'lib.dart';
 class B extends A {
   test() {
     var v = _foo;
   }
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   test_undefinedIdentifier_private_setter() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A {
   var _foo;
 }''');
     Source source = addSource(r'''
 import 'lib.dart';
 class B extends A {
   test() {
     _foo = 42;
   }
@@ skipping 14 matching lines @@
 main() {
   f(c: 1);
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
     // no verify(), 'c' is not resolved
   }
 
   test_undefinedSetter() async {
     addNamedSource("/lib.dart", "");
-    Source source2 = addNamedSource(
-        "/lib2.dart",
-        r'''
+    Source source2 = addNamedSource("/lib2.dart", r'''
 import 'lib.dart' as lib;
 void f() {
   lib.gg = null;
 }''');
     await computeAnalysisResult(source2);
     assertErrors(source2, [StaticWarningCode.UNDEFINED_SETTER]);
   }
 
   test_undefinedStaticMethodOrGetter_getter() async {
     Source source = addSource(r'''
@@ skipping 56 matching lines @@
 
   test_voidReturnForGetter() async {
     Source source = addSource(r'''
 class S {
   void get value {}
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
   }
 }