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

pkg/analyzer/test/src/summary/summary_common.dart

 // Copyright (c) 2015, 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.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 994 matching lines @@
     EntityRef xInitializerReturnType =
         getTypeRefForSlot(findVariable('x').initializer.inferredReturnTypeSlot);
     EntityRef yInitializerReturnType =
         getTypeRefForSlot(findVariable('y').initializer.inferredReturnTypeSlot);
     expect(xInitializerReturnType.reference, yInitializerReturnType.reference);
   }
 
   test_cascaded_export_hide_hide() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" hide C hide B, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib1.dart';
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_export_hide_show() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" hide C show A, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib1.dart';
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_export_show_hide() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" show A, B hide B, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib1.dart';
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_export_show_show() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" show A, B show A, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib1.dart';
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_hide_hide() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib.dart' hide C hide B, C;
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_hide_show() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib.dart' hide C show A, C;
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_show_hide() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib.dart' show A, B hide B, C;
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_show_show() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'lib.dart' show A, B show A, C;
 A a;
 B b;
 C c;
-    ''',
-        allowErrors: true);
+    ''', allowErrors: true);
     checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_class_abstract() {
     UnlinkedClass cls = serializeClassText('abstract class C {}');
     expect(cls.isAbstract, true);
   }
 
@@ skipping 884 matching lines @@
                   numTypeParameters: 2)
             ],
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   absoluteUri: absUri('/a.dart'), numTypeParameters: 2)
             ],
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
@@ skipping 34 matching lines @@
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, absUri('/a.dart'), 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
@@ skipping 30 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
@@ skipping 46 matching lines @@
       'e',
       'g',
       'f'
     ], referenceValidators: [
       (EntityRef r) =>
           checkTypeRef(r, null, 'C', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'C',
               expectedKind: ReferenceKind.classOrEnum,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named() {
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = const C.foo();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named2() {
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 const v = const C.foo();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named_prefixed() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
 }
 ''');
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.foo();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named_prefixed2() {
     addNamedSource('/a.dart', '');
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.foo();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'C'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_unnamed() {
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 const v = const Foo();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) =>
           checkTypeRef(r, null, 'Foo', expectedKind: ReferenceKind.unresolved)
     ]);
   }
@@ skipping 30 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_length_classConstField_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static const int length = 0;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.C.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
@@ skipping 40 matching lines @@
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.propertyAccessor, 'F'),
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C'),
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 const String a = 'aaa';
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const int v = a.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a',
                     absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 const String a = 'aaa';
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.a.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'length',
@@ skipping 335 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'V1',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValue_viaImport() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 enum C {V1, V2, V3}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.V1;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'V1',
@@ skipping 15 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'values',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValues_viaImport() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 enum C {V1, V2, V3}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.values;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'values',
@@ skipping 17 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.F;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.F;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
@@ skipping 38 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static int get x => null;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static int get x => null;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
@@ skipping 20 matching lines @@
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.m;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.m;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
@@ skipping 33 matching lines @@
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'f',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 f() {}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = f;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'f',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 f() {}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.f;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'f',
@@ skipping 101 matching lines @@
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) {
         return checkParamTypeRef(r, 1);
       }
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix0() {
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 const v = foo;
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) =>
           checkTypeRef(r, null, 'foo', expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix1() {
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = C.foo;
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix2() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {}
 ''');
-    UnlinkedVariable variable = serializeVariableText(
-        '''
+    UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.foo;
-''',
-        allowErrors: true);
+''', allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p'),
               ])
@@ skipping 660 matching lines @@
         prefixExpectations: [
           new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
               numTypeParameters: 2)
         ],
         numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_named_imported() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D extends C {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C {
   factory C() = D.named;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
           new _PrefixExpectation(
             ReferenceKind.classOrEnum,
             'D',
             absoluteUri: absUri('/foo.dart'),
           )
         ]);
   }
 
   test_constructor_redirected_factory_named_imported_generic() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C<T, U> {
   factory C() = D<U, T>.named;
   C._();
@@ skipping 13 matching lines @@
             numTypeParameters: 2,
             absoluteUri: absUri('/foo.dart'),
           )
         ],
         numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_named_prefixed() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D extends C {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C {
   factory C() = foo.D.named;
   C._();
@@ skipping 10 matching lines @@
           new _PrefixExpectation(
             ReferenceKind.classOrEnum,
             'D',
             absoluteUri: absUri('/foo.dart'),
           ),
           new _PrefixExpectation(ReferenceKind.prefix, 'foo')
         ]);
   }
 
   test_constructor_redirected_factory_named_prefixed_generic() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C<T, U> {
   factory C() = foo.D<U, T>.named;
   C._();
@@ skipping 53 matching lines @@
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, null, 'D',
         numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed_imported() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D extends C {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C {
   factory C() = D;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D');
   }
 
   test_constructor_redirected_factory_unnamed_imported_generic() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C<T, U> {
   factory C() = D<U, T>;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D',
         numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed_prefixed() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D extends C {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C {
   factory C() = foo.D;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D',
         expectedPrefix: 'foo');
   }
 
   test_constructor_redirected_factory_unnamed_prefixed_generic() {
-    addNamedSource(
-        '/foo.dart',
-        '''
+    addNamedSource('/foo.dart', '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C<T, U> {
   factory C() = foo.D<U, T>;
   C._();
@@ skipping 81 matching lines @@
 class D {
   final x;
   D() : x = new C();
 }
 ''');
     expect(findClass('C').executables[0].constCycleSlot, 0);
     expect(findClass('D').executables[0].constCycleSlot, 0);
   }
 
   test_constructorCycle_redirectToImplicitConstructor() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   const factory C() = D;
 }
 class D extends C {}
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_redirectToNonConstConstructor() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   const factory C() = D;
 }
 class D extends C {
   D();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_redirectToSymbolConstructor() {
     // The symbol constructor has some special case behaviors in analyzer.
     // Make sure those special case behaviors don't cause problems.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   const factory C(String name) = Symbol;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToClass() {
     serializeLibraryText('''
 class C {
   final x;
   const C() : x = C;
 }
 ''');
@@ skipping 29 matching lines @@
   final x;
   const C() : x = E.values;
 }
 ''');
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToGenericParameter() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C<T> {
   final x;
   const C() : x = T;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToGenericParameter_asSupertype() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C<T> extends T {
   const C();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToStaticMethod_inOtherClass() {
     serializeLibraryText('''
 class C {
   final x;
   const C() : x = D.f;
 }
 class D {
@@ skipping 32 matching lines @@
   final x;
   const C() : x = F;
 }
 ''');
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToUndefinedName() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   const C() : x = foo;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToUndefinedName_viaPrefix() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
     addNamedSource('/a.dart', '');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'a.dart' as a;
 class C {
   final x;
   const C() : x = a.foo;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_referenceToUndefinedName_viaPrefix_nonExistentFile() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
     allowMissingFiles = true;
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'a.dart' as a;
 class C {
   final x;
   const C() : x = a.foo;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_trivial() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   const C() : this();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaFactoryRedirect() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   const C();
   const factory C.named() = D;
 }
 class D extends C {
   final x;
   const D() : x = y;
 }
 const y = const C.named();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
     checkConstCycle('C', name: 'named');
     checkConstCycle('D');
   }
 
   test_constructorCycle_viaFinalField() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x = const C();
   const C();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaLength() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   const C() : x = y.length;
 }
 const y = const C();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaNamedConstructor() {
     serializeLibraryText('''
 class C {
   final x;
   const C() : x = const D.named();
 }
 class D {
@@ skipping 31 matching lines @@
   const C.named() : super.named();
 }
 ''');
     checkConstCycle('B', hasCycle: false);
     checkConstCycle('B', name: 'named', hasCycle: false);
     checkConstCycle('C', hasCycle: false);
     checkConstCycle('C', name: 'named', hasCycle: false);
   }
 
   test_constructorCycle_viaRedirectArgument() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   const C() : this.named(y);
   const C.named(this.x);
 }
 const y = const C();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
     checkConstCycle('C', name: 'named', hasCycle: false);
   }
 
   test_constructorCycle_viaStaticField_inOtherClass() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   const C() : x = D.y;
 }
 class D {
   static const y = const C();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaStaticField_inSameClass() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   static const y = const C();
   const C() : x = y;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaSuperArgument() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class B {
   final x;
   const B(this.x);
 }
 class C extends B {
   const C() : super(y);
 }
 const y = const C();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('B', hasCycle: false);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaSupertype() {
     serializeLibraryText('''
 class C {
   final x;
   const C() : x = const D();
 }
 class D extends C {
   const D();
 }
 ''');
     checkConstCycle('C');
     checkConstCycle('D');
   }
 
   test_constructorCycle_viaSupertype_Enum() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 enum E { v }
 class C extends E {
   const C();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
   }
 
   test_constructorCycle_viaSupertype_explicit() {
     serializeLibraryText('''
 class C {
   final x;
   const C() : x = const D();
   const C.named() : x = const D.named();
 }
 class D extends C {
   const D() : super();
   const D.named() : super.named();
 }
 ''');
     checkConstCycle('C');
     checkConstCycle('C', name: 'named');
     checkConstCycle('D');
     checkConstCycle('D', name: 'named');
   }
 
   test_constructorCycle_viaSupertype_explicit_undefined() {
     // It's not valid Dart but we need to make sure it doesn't crash
     // summary generation.
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   const C() : x = const D();
 }
 class D extends C {
   const D() : super.named();
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C', hasCycle: false);
     checkConstCycle('D', hasCycle: false);
   }
 
   test_constructorCycle_viaSupertype_withDefaultTypeArgument() {
     serializeLibraryText('''
 class C<T> {
   final x;
   const C() : x = const D();
 }
@@ skipping 13 matching lines @@
 }
 class D extends C<int> {
   const D();
 }
 ''');
     checkConstCycle('C');
     checkConstCycle('D');
   }
 
   test_constructorCycle_viaTopLevelVariable() {
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 class C {
   final x;
   const C() : x = y;
 }
 const y = const C();
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaTopLevelVariable_imported() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 import 'test.dart';
 const y = const C();
     ''');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'a.dart';
 class C {
   final x;
   const C() : x = y;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_constructorCycle_viaTopLevelVariable_importedViaPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 import 'test.dart';
 const y = const C();
     ''');
-    serializeLibraryText(
-        '''
+    serializeLibraryText('''
 import 'a.dart' as a;
 class C {
   final x;
   const C() : x = a.y;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     checkConstCycle('C');
   }
 
   test_dependencies_export_to_export_unused() {
     addNamedSource('/a.dart', 'export "b.dart";');
     addNamedSource('/b.dart', '');
     serializeLibraryText('export "a.dart";');
     // The main test library depends on b.dart, even though it doesn't
     // re-export any names defined in b.dart, because a change to b.dart might
     // cause it to start exporting a name that the main test library *does*
@@ skipping 120 matching lines @@
         'library d; part "e/f.dart"; part "g/h.dart"; class D {}');
     addNamedSource('/a/c/e/f.dart', 'part of d;');
     addNamedSource('/a/c/g/h.dart', 'part of d;');
     serializeLibraryText('import "a/b.dart"; D d;');
     int dep = checkHasDependency(absUri('/a/c/d.dart'));
     checkDependencyParts(linked.dependencies[dep],
         [absUri('/a/c/e/f.dart'), absUri('/a/c/g/h.dart')]);
   }
 
   test_elements_in_part() {
-    addNamedSource(
-        '/part1.dart',
-        '''
+    addNamedSource('/part1.dart', '''
 part of my.lib;
 
 class C {}
 enum E { v }
 var v;
 f() {}
 typedef F();
 ''');
     serializeLibraryText('library my.lib; part "part1.dart";');
     UnlinkedUnit unit = unlinkedUnits[1];
@@ skipping 1432 matching lines @@
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_assignToRef_topLevelVariable_imported() {
     if (skipNonConstInitializers) {
       return;
     }
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 int a = 0;
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 final v = (a = 1);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_assignToRef_topLevelVariable_imported_withPrefix() {
     if (skipNonConstInitializers) {
       return;
     }
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 int a = 0;
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = (p.a = 1);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushInt,
@@ skipping 585 matching lines @@
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'a')
                   ])
         ]);
   }
 
   test_expr_invokeMethodRef_static_importedWithPrefix() {
     if (skipNonConstInitializers) {
       return;
     }
-    addNamedSource(
-        '/a.dart',
-        '''
+    addNamedSource('/a.dart', '''
 class C {
   static int m() => 42;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = p.C.m();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
@@ skipping 1158 matching lines @@
   }
 
   test_initializer_executable_with_return_type_from_closure_field() {
     if (skipFullyLinkedData) {
       return;
     }
     // The synthetic executable for `v` has type `() => () => int`, where the
     // `() => int` part refers to the closure declared inside the initializer
     // for v.  Note: `v` is mis-typed as `int` to prevent type propagation,
     // which would complicate the test.
-    UnlinkedClass cls = serializeClassText(
-        '''
+    UnlinkedClass cls = serializeClassText('''
 class C {
   int v = () => 0;
 }
-''',
-        allowErrors: true);
+''', allowErrors: true);
     UnlinkedVariable variable = cls.fields[0];
     EntityRef closureType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
     checkLinkedTypeRef(closureType, null, '',
         expectedKind: ReferenceKind.function);
     int initializerIndex =
         definingUnit.references[closureType.reference].containingReference;
     checkReferenceIndex(initializerIndex, null, '',
         expectedKind: ReferenceKind.function);
     int variableIndex =
@@ skipping 1884 matching lines @@
  */
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.numTypeParameters: 0});
 }