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

pkg/analyzer/test/generated/compile_time_error_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.compile_time_error_code_test;
 
 import 'dart:async';
 
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ skipping 185 matching lines @@
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD]);
     // Cannot verify because "_name" cannot be resolved.
   }
 
   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 N {}''');
-    addNamedSource(
-        "/lib2.dart",
-        r'''
+    addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
 
   test_annotationWithNotClass() async {
     Source source = addSource('''
 class Property {
   final int value;
   const Property(this.value);
 }
 
 const Property property = const Property(42);
 
 @property(123)
 main() {
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.ANNOTATION_WITH_NON_CLASS]);
     verify([source]);
   }
 
   test_annotationWithNotClass_prefixed() async {
-    addNamedSource(
-        "/annotations.dart",
-        r'''
+    addNamedSource("/annotations.dart", r'''
 class Property {
   final int value;
   const Property(this.value);
 }
 
 const Property property = const Property(42);
 ''');
     Source source = addSource('''
 import 'annotations.dart' as pref;
 @pref.property(123)
@@ skipping 251 matching lines @@
 f() async {
   return "$async";
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
     verify([source]);
   }
 
   test_async_used_as_identifier_in_suffix() async {
-    addNamedSource(
-        "/lib1.dart",
-        r'''
+    addNamedSource("/lib1.dart", r'''
 library lib1;
 int async;
 ''');
     Source source = addSource('''
 import 'lib1.dart' as l;
 f() async {
   return l.async;
 }
 ''');
     await computeAnalysisResult(source);
@@ skipping 1011 matching lines @@
 f() {
   return const A();
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source]);
   }
 
   test_constWithNonType_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() {
   const lib.A();
 }''');
     await computeAnalysisResult(source1);
     await computeAnalysisResult(source2);
     assertErrors(source2, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source1]);
   }
 
@@ skipping 115 matching lines @@
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [
       CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT,
       CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT
     ]);
     verify([source]);
   }
 
   test_duplicateDefinition_acrossLibraries() async {
-    Source librarySource = addNamedSource(
-        "/lib.dart",
-        r'''
+    Source librarySource = addNamedSource("/lib.dart", r'''
 library lib;
 
 part 'a.dart';
 part 'b.dart';''');
-    Source sourceA = addNamedSource(
-        "/a.dart",
-        r'''
+    Source sourceA = addNamedSource("/a.dart", r'''
 part of lib;
 
 class A {}''');
-    Source sourceB = addNamedSource(
-        "/b.dart",
-        r'''
+    Source sourceB = addNamedSource("/b.dart", r'''
 part of lib;
 
 class A {}''');
     await computeAnalysisResult(librarySource);
     await computeAnalysisResult(sourceA);
     await computeAnalysisResult(sourceB);
     assertNoErrors(librarySource);
     assertErrors(sourceB, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA, sourceB]);
   }
@@ skipping 35 matching lines @@
 class A {
   m() {}
   m() {}
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
 
   test_duplicateDefinition_inPart() async {
-    Source librarySource = addNamedSource(
-        "/lib.dart",
-        r'''
+    Source librarySource = addNamedSource("/lib.dart", r'''
 library test;
 part 'a.dart';
 class A {}''');
-    Source sourceA = addNamedSource(
-        "/a.dart",
-        r'''
+    Source sourceA = addNamedSource("/a.dart", r'''
 part of test;
 class A {}''');
     await computeAnalysisResult(librarySource);
     await computeAnalysisResult(sourceA);
     assertNoErrors(librarySource);
     assertErrors(sourceA, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA]);
   }
 
   test_duplicateDefinition_locals_inCase() async {
@@ skipping 1115 matching lines @@
     assertErrors(source,
         [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
 
   test_importOfNonLibrary() async {
     Source source = addSource(r'''
 library lib;
 import 'part.dart';
 A a;''');
-    addNamedSource(
-        "/part.dart",
-        r'''
+    addNamedSource("/part.dart", r'''
 part of lib;
 class A{}''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
 
   test_inconsistentCaseExpressionTypes() async {
     Source source = addSource(r'''
 f(var p) {
@@ skipping 253 matching lines @@
 get V => 0;
 @V
 main() {
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
   test_invalidAnnotation_importWithPrefix_getter() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 get V => 0;''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
   test_invalidAnnotation_importWithPrefix_notConstantVariable() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 final V = 0;''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
   test_invalidAnnotation_importWithPrefix_notVariableOrConstructorInvocation() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 typedef V();''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
@@ skipping 1594 matching lines @@
     await computeAnalysisResult(source);
     assertErrors(source, [
       CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER,
       CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION
     ]);
     verify([source]);
   }
 
   test_nonConstValueInInitializer_instanceCreation_inDifferentFile() async {
     resetWith(options: new AnalysisOptionsImpl()..strongMode = true);
-    Source source = addNamedSource(
-        '/a.dart',
-        r'''
+    Source source = addNamedSource('/a.dart', r'''
 import 'b.dart';
 const v = const MyClass();
 ''');
-    addNamedSource(
-        '/b.dart',
-        r'''
+    addNamedSource('/b.dart', r'''
 class MyClass {
   const MyClass([p = foo]);
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
   }
 
   test_nonConstValueInInitializer_redirecting() async {
     Source source = addSource(r'''
@@ skipping 254 matching lines @@
   p = 1;
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefix_conditionalPropertyAccess_call() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 g() {}
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   p?.g();
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefix_conditionalPropertyAccess_call_loadLibrary() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 ''');
     Source source = addSource('''
 import 'lib.dart' deferred as p;
 f() {
   p?.loadLibrary();
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefix_conditionalPropertyAccess_get() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 var x;
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   return p?.x;
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefix_conditionalPropertyAccess_get_loadLibrary() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 ''');
     Source source = addSource('''
 import 'lib.dart' deferred as p;
 f() {
   return p?.loadLibrary;
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefix_conditionalPropertyAccess_set() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 var x;
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   p?.x = null;
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefix_conditionalPropertyAccess_set_loadLibrary() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 ''');
     Source source = addSource('''
 import 'lib.dart' deferred as p;
 f() {
   p?.loadLibrary = null;
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
@@ skipping 25 matching lines @@
   p();
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefixCollidesWithTopLevelMembers_functionTypeAlias() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 typedef p();
 p.A a;''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
 
   test_prefixCollidesWithTopLevelMembers_topLevelFunction() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 p() {}
 p.A a;''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
 
   test_prefixCollidesWithTopLevelMembers_topLevelVariable() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 var p = null;
 p.A a;''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
 
   test_prefixCollidesWithTopLevelMembers_type() async {
-    addNamedSource(
-        "/lib.dart",
-        r'''
+    addNamedSource("/lib.dart", r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 class p {}
 p.A a;''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
@@ skipping 21 matching lines @@
   p += 1;
 }
 ''');
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   test_prefixNotFollowedByDot_conditionalMethodInvocation() async {
-    addNamedSource(
-        '/lib.dart',
-        '''
+    addNamedSource('/lib.dart', '''
 library lib;
 g() {}
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   p?.g();
 }
 ''');
     await computeAnalysisResult(source);
@@ skipping 1305 matching lines @@
     reset();
   }
 
   Future<Null> _check_wrongNumberOfParametersForOperator1(String name) async {
     await _check_wrongNumberOfParametersForOperator(name, "");
     await _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 
   Future<Null> _privateCollisionInMixinApplicationTest(String testCode) async {
     resetWith(options: new AnalysisOptionsImpl()..strongMode = true);
-    addNamedSource(
-        '/lib1.dart',
-        '''
+    addNamedSource('/lib1.dart', '''
 class A {
   int _x;
 }
 
 class B {
   int _x;
 }
 ''');
     Source source = addSource(testCode);
     await computeAnalysisResult(source);
     assertErrors(
         source, [CompileTimeErrorCode.PRIVATE_COLLISION_IN_MIXIN_APPLICATION]);
     verify([source]);
   }
 }