Add NOT_INITIALIZED_FIELDS property for FINAL_NOT_INITIALIZED_CONSTRUCTOR_X.

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 engine.static_warning_code_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart';
 
@@ skipping 864 matching lines @@
 
   void test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter() {
     Source source = addSource(r'''
 class A {
   static set v(x) {}
 }
 class B extends A {
   var v;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_getter() {
     Source source = addSource(r'''
 class A {
   static get v => 0;
 }
 class B extends A {
   get v => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_method() {
     Source source = addSource(r'''
 class A {
   static v() {}
 }
 class B extends A {
   get v => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_setter() {
     Source source = addSource(r'''
 class A {
   static set v(x) {}
 }
 class B extends A {
   get v => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_declGetter_indirect() {
     Source source = addSource(r'''
 class A {
   static int v;
 }
 class B extends A {}
 class C extends B {
   get v => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_declGetter_mixin() {
     Source source = addSource(r'''
 class M {
   static int v;
 }
 class B extends Object with M {
   get v => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_direct_field() {
     Source source = addSource(r'''
 class A {
   static int v;
 }
 class B extends A {
   get v => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingInstanceMethodSetter2() {
     Source source = addSource(r'''
 class A {
   foo() {}
   set foo(a) {}
 }''');
     resolve(source);
@@ skipping 44 matching lines @@
 
   void test_conflictingInstanceSetterAndSuperclassMember() {
     Source source = addSource(r'''
 class A {
   static int v;
 }
 class B extends A {
   set v(x) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingStaticGetterAndInstanceSetter_mixin() {
     Source source = addSource(r'''
 class A {
   set x(int p) {}
 }
 class B extends Object with A {
   static get x => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
     verify([source]);
   }
 
   void test_conflictingStaticGetterAndInstanceSetter_superClass() {
     Source source = addSource(r'''
 class A {
   set x(int p) {}
 }
 class B extends A {
   static get x => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
     verify([source]);
   }
 
   void test_conflictingStaticGetterAndInstanceSetter_thisClass() {
     Source source = addSource(r'''
 class A {
   static get x => 0;
   set x(int p) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
     verify([source]);
   }
 
   void test_conflictingStaticSetterAndInstanceMember_thisClass_getter() {
     Source source = addSource(r'''
 class A {
   get x => 0;
   static set x(int p) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingStaticSetterAndInstanceMember_thisClass_method() {
     Source source = addSource(r'''
 class A {
   x() {}
   static set x(int p) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
     verify([source]);
   }
 
   void test_constWithAbstractClass() {
     Source source = addSource(r'''
 abstract class A {
   const A();
 }
 void f() {
   A a = const A();
@@ skipping 79 matching lines @@
     verify([source]);
   }
 
   void test_fieldInitializedInInitializerAndDeclaration_final() {
     Source source = addSource(r'''
 class A {
   final int x = 0;
   A() : x = 1 {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     verify([source]);
   }
 
   void test_fieldInitializerNotAssignable() {
     Source source = addSource(r'''
 class A {
   int x;
   A() : x = '';
 }''');
     resolve(source);
@@ skipping 22 matching lines @@
    * FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, since it more specific, we use it instead of
    * the broader code
    */
   void test_finalInitializedInDeclarationAndConstructor_initializers() {
     Source source = addSource(r'''
 class A {
   final x = 0;
   A() : x = 0 {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     verify([source]);
   }
 
   void test_finalInitializedInDeclarationAndConstructor_initializingFormal() {
     Source source = addSource(r'''
 class A {
   final x = 0;
   A(this.x) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
     verify([source]);
   }
 
-  void test_finalNotInitialized_inConstructor() {
+  void test_finalNotInitialized_inConstructor_1() {
     Source source = addSource(r'''
 class A {
   final int x;
   A() {}
 }''');
     resolve(source);
-    assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
+    assertErrors(
+        source, [StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_1]);
     verify([source]);
   }
 
+  void test_finalNotInitialized_inConstructor_2() {
+    Source source = addSource(r'''
+class A {
+  final int a;
+  final int b;
+  A() {}
+}''');
+    resolve(source);
+    assertErrors(
+        source, [StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_2]);
+    verify([source]);
+  }
+
+  void test_finalNotInitialized_inConstructor_3() {
+    Source source = addSource(r'''
+class A {
+  final int a;
+  final int b;
+  final int c;
+  A() {}
+}''');
+    resolve(source);
+    assertErrors(
+        source, [StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_3_PLUS]);
+    verify([source]);
+  }
+
   void test_finalNotInitialized_instanceField_final() {
     Source source = addSource(r'''
 class A {
   final F;
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
     verify([source]);
   }
 
@@ skipping 103 matching lines @@
     Source source = addSource(r'''
 abstract class A {
   int x();
 }
 abstract class B {
   int get x;
 }
 class C implements A, B {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
     verify([source]);
   }
 
   void test_instanceMethodNameCollidesWithSuperclassStatic_field() {
     Source source = addSource(r'''
 class A {
   static var n;
 }
 class B extends A {
   void n() {}
@@ skipping 300 matching lines @@
 
   void test_invalidMethodOverrideOptionalParamType() {
     Source source = addSource(r'''
 class A {
   m([int a]) {}
 }
 class B implements A {
   m([String a]) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
     verify([source]);
   }
 
   void test_invalidMethodOverrideOptionalParamType_twoInterfaces() {
     Source source = addSource(r'''
 abstract class I {
   m([int n]);
 }
 abstract class J {
   m([num n]);
 }
 abstract class A implements I, J {}
 class B extends A {
   m([String n]) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
     verify([source]);
   }
 
   void test_invalidMethodOverrideReturnType_interface() {
     Source source = addSource(r'''
 class A {
   int m() { return 0; }
 }
 class B implements A {
   String m() { return 'a'; }
@@ skipping 121 matching lines @@
     // value, even if implicitly.
     Source source = addSource(r'''
 class A {
   foo({x: 1}) {}
 }
 class B extends A {
   foo({x}) {}
 }
 ''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
     verify([source]);
   }
 
   void test_invalidOverride_defaultOverridesNonDefaultNull() {
     // If the base class provided an explicit null value for a default
     // parameter, then it is ok for the derived class to let the default value
     // be implicit, because the implicit default value of null matches the
     // explicit default value of null.
     Source source = addSource(r'''
 class A {
@@ skipping 62 matching lines @@
 
   void test_invalidOverrideDifferentDefaultValues_named() {
     Source source = addSource(r'''
 class A {
   m({int p : 0}) {}
 }
 class B extends A {
   m({int p : 1}) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
     verify([source]);
   }
 
   void test_invalidOverrideDifferentDefaultValues_positional() {
     Source source = addSource(r'''
 class A {
   m([int p = 0]) {}
 }
 class B extends A {
   m([int p = 1]) {}
@@ skipping 186 matching lines @@
 
   void test_mismatchedAccessorTypes_getterAndSuperSetter() {
     Source source = addSource(r'''
 class A {
   int get g { return 0; }
 }
 class B extends A {
   set g(String v) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE]);
     verify([source]);
   }
 
   void test_mismatchedAccessorTypes_setterAndSuperGetter() {
     Source source = addSource(r'''
 class A {
   set g(int v) {}
 }
 class B extends A {
   String get g { return ''; }
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE]);
     verify([source]);
   }
 
   void test_mismatchedAccessorTypes_topLevel() {
     Source source = addSource(r'''
 int get g { return 0; }
 set g(String v) {}''');
     resolve(source);
     assertErrors(
         source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
@@ skipping 172 matching lines @@
     Source source = addSource(r'''
 abstract class A {
   m();
   n();
   o();
   p();
 }
 class C extends A {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() {
     // 15979
     Source source = addSource(r'''
 abstract class M {}
 abstract class A {}
 abstract class I {
   m();
 }
 class B = A with M implements I;''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_mixin() {
     // 15979
     Source source = addSource(r'''
 abstract class M {
   m();
 }
 abstract class A {}
 class B = A with M;''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() {
     // 15979
     Source source = addSource(r'''
 class M {}
 abstract class A {
   m();
 }
 class B = A with M;''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() {
     // 15028
     Source source = addSource(r'''
 class C {
   foo(int x) => x;
 }
 abstract class D {
   foo(x, [y]);
 }
 class E extends C implements D {}''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface() {
     Source source = addSource(r'''
 class I {
   int get g {return 1;}
 }
 class C implements I {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass() {
     Source source = addSource(r'''
 abstract class A {
   int get g;
 }
 class C extends A {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface() {
     Source source = addSource(r'''
 class I {
   m(p) {}
 }
 class C implements I {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass() {
     Source source = addSource(r'''
 abstract class A {
   m(p);
 }
 class C extends A {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() {
     // 7640
     Source source = addSource(r'''
 abstract class A {
   int x(int a);
 }
 abstract class B {
   int x(int a, [int b]);
 }
 class C implements A, B {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_getter() {
     // 15001
     Source source = addSource(r'''
 abstract class A { get g1; get g2; }
 abstract class B implements A { get g1 => 1; }
 class C extends Object with B {}''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_method() {
     // 15001
     Source source = addSource(r'''
 abstract class A { m1(); m2(); }
 abstract class B implements A { m1() => 1; }
 class C extends Object with B {}''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_setter() {
     // 15001
     Source source = addSource(r'''
 abstract class A { set s1(v); set s2(v); }
 abstract class B implements A { set s1(v) {} }
 class C extends Object with B {}''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_and_implicitSetter() {
     // test from language/override_inheritance_abstract_test_14.dart
     Source source = addSource(r'''
 abstract class A {
   set field(_);
 }
 abstract class I {
   var field;
 }
 class B extends A implements I {
   get field => 0;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface() {
     Source source = addSource(r'''
 class I {
   set s(int i) {}
 }
 class C implements I {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass() {
     Source source = addSource(r'''
 abstract class A {
   set s(int i);
 }
 class C extends A {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface() {
     // bug 11154
     Source source = addSource(r'''
 class A {
   get a => 'a';
 }
 abstract class B implements A {
   get b => 'b';
 }
 class C extends B {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingGetter() {
     // 16133
     Source source = addSource(r'''
 class I {
   var v;
 }
 class C implements I {
   set v(_) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingSetter() {
     // 16133
     Source source = addSource(r'''
 class I {
   var v;
 }
 class C implements I {
   get v => 1;
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberThree() {
     Source source = addSource(r'''
 abstract class A {
   m();
   n();
   o();
 }
 class C extends A {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberTwo() {
     Source source = addSource(r'''
 abstract class A {
   m();
   n();
 }
 class C extends A {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromInterface_missingBoth() {
     // 16133
     Source source = addSource(r'''
 class I {
   var v;
 }
 class C implements I {
 }''');
     resolve(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
-    ]);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
     verify([source]);
   }
 
   void test_nonTypeInCatchClause_noElement() {
     Source source = addSource(r'''
 f() {
   try {
   } on T catch (e) {
   }
 }''');
@@ skipping 769 matching lines @@
 
   void test_voidReturnForGetter() {
     Source source = addSource(r'''
 class S {
   void get value {}
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
   }
 }