Avoid infinite loop if const constructor redirects don't reach a fixed point.

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 engine.compile_time_error_code_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart' as _ut;
@@ skipping 618 matching lines @@
     Source source = addSource("class as {}");
     resolve(source);
     assertErrors(
         source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
     verify([source]);
   }
 
   void test_builtInIdentifierAsTypeParameterName() {
     Source source = addSource("class A<as> {}");
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME]);
     verify([source]);
   }
 
   void test_caseExpressionTypeImplementsEquals() {
     Source source = addSource(r'''
 class IntWrapper {
   final int value;
   const IntWrapper(this.value);
   bool operator ==(IntWrapper x) {
     return value == x.value;
@@ skipping 325 matching lines @@
     ], <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
   }
 
   void test_constEval_newInstance_constConstructor() {
     Source source = addSource(r'''
 class A {
   const A();
 }
 const a = new A();''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constEval_newInstance_externalFactoryConstConstructor() {
     // We can't evaluate "const A()" because its constructor is external.  But
     // the code is correct--we shouldn't report an error.
     Source source = addSource(r'''
 class A {
   external factory const A();
 }
 const x = const A();''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_constEval_propertyExtraction_targetNotConst() {
     Source source = addSource(r'''
 class A {
   const A();
   m() {}
 }
 final a = const A();
 const C = a.m;''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constEvalThrowsException_binaryMinus_null() {
     _check_constEvalThrowsException_binary_null("null - 5", false);
     _check_constEvalThrowsException_binary_null("5 - null", true);
   }
 
   void test_constEvalThrowsException_binaryPlus_null() {
     _check_constEvalThrowsException_binary_null("null + 5", false);
@@ skipping 112 matching lines @@
     assertErrors(source, [CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValue() {
     Source source = addSource(r'''
 f(p) {
   const C = p;
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValue_missingConstInListLiteral() {
     Source source = addSource("const List L = [0];");
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValue_missingConstInMapLiteral() {
     Source source = addSource("const Map M = {'a' : 0};");
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValueFromDeferredClass() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 const V = 1;''',
       r'''
 library root;
@@ skipping 31 matching lines @@
   void test_constMapKeyTypeImplementsEquals_direct() {
     Source source = addSource(r'''
 class A {
   const A();
   operator ==(other) => false;
 }
 main() {
   const {const A() : 0};
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
     verify([source]);
   }
 
   void test_constMapKeyTypeImplementsEquals_dynamic() {
     // Note: static type of B.a is "dynamic", but actual type of the const
     // object is A.  We need to make sure we examine the actual type when
     // deciding whether there is a problem with operator==.
     Source source = addSource(r'''
 class A {
   const A();
   operator ==(other) => false;
 }
 class B {
   static const a = const A();
 }
 main() {
   const {B.a : 0};
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
     verify([source]);
   }
 
   void test_constMapKeyTypeImplementsEquals_factory() {
     Source source = addSource(r'''
 class A { const factory A() = B; }
 
 class B implements A {
   const B();
 
   operator ==(o) => true;
 }
 
 main() {
   var m = const { const A(): 42 };
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
     verify([source]);
   }
 
   void test_constMapKeyTypeImplementsEquals_super() {
     Source source = addSource(r'''
 class A {
   const A();
   operator ==(other) => false;
 }
 class B extends A {
   const B();
 }
 main() {
   const {const B() : 0};
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
     verify([source]);
   }
 
   void test_constWithInvalidTypeParameters() {
     Source source = addSource(r'''
 class A {
   const A();
 }
 f() { return const A<A>(); }''');
     resolve(source);
@@ skipping 138 matching lines @@
 
   void test_constWithUndefinedConstructorDefault() {
     Source source = addSource(r'''
 class A {
   const A.name();
 }
 f() {
   return const A();
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
 
   void test_defaultValueInFunctionTypeAlias() {
     Source source = addSource("typedef F([x = 0]);");
     resolve(source);
     assertErrors(
         source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
     verify([source]);
   }
 
   void test_defaultValueInFunctionTypedParameter_named() {
     Source source = addSource("f(g({p: null})) {}");
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
     verify([source]);
   }
 
   void test_defaultValueInFunctionTypedParameter_optional() {
     Source source = addSource("f(g([p = null])) {}");
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
     verify([source]);
   }
 
   void test_defaultValueInRedirectingFactoryConstructor() {
     Source source = addSource(r'''
 class A {
   factory A([int x = 0]) = B;
 }
 
 class B implements A {
@@ skipping 421 matching lines @@
     verify([source]);
   }
 
   void test_fieldInitializedByMultipleInitializers() {
     Source source = addSource(r'''
 class A {
   int x;
   A() : x = 0, x = 1 {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
 
   void test_fieldInitializedByMultipleInitializers_multipleInits() {
     Source source = addSource(r'''
 class A {
   int x;
   A() : x = 0, x = 1, x = 2 {}
 }''');
     resolve(source);
@@ skipping 19 matching lines @@
     verify([source]);
   }
 
   void test_fieldInitializedInParameterAndInitializer() {
     Source source = addSource(r'''
 class A {
   int x;
   A(this.x) : x = 1 {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
     verify([source]);
   }
 
   void test_fieldInitializerFactoryConstructor() {
     Source source = addSource(r'''
 class A {
   int x;
   factory A(this.x) {}
 }''');
     resolve(source);
@@ skipping 30 matching lines @@
   }
 
   void test_fieldInitializerRedirectingConstructor_afterRedirection() {
     Source source = addSource(r'''
 class A {
   int x;
   A.named() {}
   A() : this.named(), x = 42;
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_fieldInitializerRedirectingConstructor_beforeRedirection() {
     Source source = addSource(r'''
 class A {
   int x;
   A.named() {}
   A() : x = 42, this.named();
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_fieldInitializingFormalRedirectingConstructor() {
     Source source = addSource(r'''
 class A {
   int x;
   A.named() {}
   A(this.x) : this.named();
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_finalInitializedMultipleTimes_initializers() {
     Source source = addSource(r'''
 class A {
   final x;
   A() : x = 0, x = 0 {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
 
   /**
    * This test doesn't test the FINAL_INITIALIZED_MULTIPLE_TIMES code, but tests the
    * FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER code instead. It is provided here to show
    * coverage over all of the permutations of initializers in constructor declarations.
    *
    * Note: FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER covers a subset of
    * FINAL_INITIALIZED_MULTIPLE_TIMES, since it more specific, we use it instead of the broader code
    */
   void test_finalInitializedMultipleTimes_initializingFormal_initializer() {
     Source source = addSource(r'''
 class A {
   final x;
   A(this.x) : x = 0 {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
     verify([source]);
   }
 
   void test_finalInitializedMultipleTimes_initializingFormals() {
     Source source = addSource(r'''
 class A {
   final x;
   A(this.x, this.x) {}
 }''');
     resolve(source);
@@ skipping 512 matching lines @@
     assertErrors(source, [CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD]);
     verify([source]);
   }
 
   void test_initializingFormalForNonExistentField() {
     Source source = addSource(r'''
 class A {
   A(this.x) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
     verify([source]);
   }
 
   void test_initializingFormalForNonExistentField_notInEnclosingClass() {
     Source source = addSource(r'''
 class A {
 int x;
 }
 class B extends A {
   B(this.x) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
     verify([source]);
   }
 
   void test_initializingFormalForNonExistentField_optional() {
     Source source = addSource(r'''
 class A {
   A([this.x]) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
     verify([source]);
   }
 
   void test_initializingFormalForNonExistentField_synthetic() {
     Source source = addSource(r'''
 class A {
   int get x => 1;
   A(this.x) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
     verify([source]);
   }
 
   void test_initializingFormalForStaticField() {
     Source source = addSource(r'''
 class A {
   static int x;
   A([this.x]) {}
 }''');
     resolve(source);
@@ skipping 1007 matching lines @@
   }
 
   void test_multipleRedirectingConstructorInvocations() {
     Source source = addSource(r'''
 class A {
   A() : this.a(), this.b();
   A.a() {}
   A.b() {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS]);
     verify([source]);
   }
 
   void test_multipleSuperInitializers() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   B() : super(), super() {}
 }''');
     resolve(source);
@@ skipping 70 matching lines @@
 class B {
   B({x});
   B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
 }
 class Mixed = B with M;
 class C extends Mixed {
   C(x) : super();
 }
 ''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_mixinAppWithNamedParam() {
     Source source = addSource(r'''
 class M {}
 class B {
   B({x});
   B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
 }
 class Mixed = B with M;
 class C extends Mixed {
   C();
 }
 ''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_MixinAppWithNamedSuperCall() {
     Source source = addSource(r'''
 class M {}
 class B {
   B.named({x});
   B.named2(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
 }
@@ skipping 14 matching lines @@
 class B {
   B([x]);
   B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
 }
 class Mixed = B with M;
 class C extends Mixed {
   C();
 }
 ''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_MixinWithDirectSuperCall() {
     Source source = addSource(r'''
 class M {}
 class B {
   B({x});
   B.other();
 }
 class C extends B with M {
   C(x) : super();
 }
 ''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_mixinWithNamedParam() {
     Source source = addSource(r'''
 class M {}
 class B {
   B({x});
   B.named();
 }
@@ skipping 851 matching lines @@
   void test_recursiveFactoryRedirect_directSelfReference() {
     Source source = addSource(r'''
 class A {
   factory A() = A;
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT]);
     verify([source]);
   }
 
+  void test_recursiveFactoryRedirect_diverging() {
+    // Analysis should terminate even though the redirections don't reach a
+    // fixed point.  (C<int> redirects to C<C<int>>, then to C<C<C<int>>>, and
+    // so on).
+    Source source = addSource('''
+class C<T> {
+  const factory C() = C<C<T>>;
+}
+main() {
+  const C<int>();
+}
+''');
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT]);
+    verify([source]);
+  }
+
   void test_recursiveFactoryRedirect_generic() {
     Source source = addSource(r'''
 class A<T> implements B<T> {
   factory A() = C;
 }
 class B<T> implements C<T> {
   factory B() = A;
 }
 class C<T> implements A<T> {
   factory C() = B;
@@ skipping 171 matching lines @@
     resolve(source);
     assertErrors(source, [
       CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
     ]);
     verify([source]);
   }
 
   void test_recursiveInterfaceInheritanceBaseCaseWith() {
     Source source = addSource("class M = Object with M;");
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH]);
     verify([source]);
   }
 
   void test_redirectGenerativeToMissingConstructor() {
     Source source = addSource(r'''
 class A {
   A() : this.noSuchConstructor();
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
   }
 
   void test_redirectGenerativeToNonGenerativeConstructor() {
     Source source = addSource(r'''
 class A {
   A() : this.x();
   factory A.x() => null;
 }''');
     resolve(source);
     assertErrors(source, [
@@ skipping 465 matching lines @@
 
   void test_undefinedConstructorInInitializer_explicit_unnamed() {
     Source source = addSource(r'''
 class A {
   A.named() {}
 }
 class B extends A {
   B() : super();
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_undefinedConstructorInInitializer_implicit() {
     Source source = addSource(r'''
 class A {
   A.named() {}
 }
 class B extends A {
   B();
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_undefinedNamedParameter() {
     Source source = addSource(r'''
 class A {
   const A();
 }
 main() {
   const A(p: 0);
@@ skipping 58 matching lines @@
     _check_wrongNumberOfParametersForOperator1(">>");
     _check_wrongNumberOfParametersForOperator1("[]");
   }
 
   void test_wrongNumberOfParametersForOperator_minus() {
     Source source = addSource(r'''
 class A {
   operator -(a, b) {}
 }''');
     resolve(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS]);
     verify([source]);
     reset();
   }
 
   void test_wrongNumberOfParametersForOperator_tilde() {
     _check_wrongNumberOfParametersForOperator("~", "a");
     _check_wrongNumberOfParametersForOperator("~", "a, b");
   }
 
   void test_wrongNumberOfParametersForSetter_function_named() {
@@ skipping 174 matching lines @@
         source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }