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

pkg/analyzer/test/src/task/dart_test.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.task.dart_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 134 matching lines @@
 isInstanceOf isVerifyUnitTask = new isInstanceOf<VerifyUnitTask>();
 
 final LintCode _testLintCode = new LintCode('test lint', 'test lint code');
 
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   Source source;
   LibrarySpecificUnit target;
 
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT1);
     expect(outputs[RESOLVED_UNIT1], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT1], isTrue);
   }
 
   test_perform_find_constants() {
@@ skipping 187 matching lines @@
       expect(combinator.hiddenNames, ['C', 'D']);
     }
   }
 
   test_perform_configurations_export() {
     context.declaredVariables.define('dart.library.io', 'true');
     context.declaredVariables.define('dart.library.html', 'true');
     newSource('/foo.dart', '');
     var foo_io = newSource('/foo_io.dart', '');
     newSource('/foo_html.dart', '');
-    var testSource = newSource(
-        '/test.dart',
-        r'''
+    var testSource = newSource('/test.dart', r'''
 export 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
     // Perform the task.
     computeResult(testSource, LIBRARY_ELEMENT2,
         matcher: isBuildDirectiveElementsTask);
     LibraryElement testLibrary = outputs[LIBRARY_ELEMENT2];
     // Validate the export element.
     ExportElement export = testLibrary.exports[0];
     expect(export.exportedLibrary.source, foo_io);
     expect(export.uri, 'foo_io.dart');
   }
 
   test_perform_configurations_import() {
     context.declaredVariables.define('dart.library.io', 'true');
     context.declaredVariables.define('dart.library.html', 'true');
     newSource('/foo.dart', '');
     var foo_io = newSource('/foo_io.dart', '');
     newSource('/foo_html.dart', '');
-    var testSource = newSource(
-        '/test.dart',
-        r'''
+    var testSource = newSource('/test.dart', r'''
 import 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
     // Perform the task.
     computeResult(testSource, LIBRARY_ELEMENT2,
         matcher: isBuildDirectiveElementsTask);
     LibraryElement testLibrary = outputs[LIBRARY_ELEMENT2];
     // Validate the import element.
     ImportElement import = testLibrary.imports[0];
@@ skipping 197 matching lines @@
 
   _getImportLibraryInput(Source source) {
     var key = BuildDirectiveElementsTask.IMPORTS_LIBRARY_ELEMENT_INPUT_NAME;
     return task.inputs[key][source];
   }
 }
 
 @reflectiveTest
 class BuildEnumMemberElementsTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT3);
     expect(outputs[RESOLVED_UNIT3], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT3], isTrue);
   }
 
   test_perform() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 enum MyEnum {
   A, B
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT3,
         matcher: isBuildEnumMemberElementsTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT3];
     // validate Element
     ClassElement enumElement =
         resolutionMap.elementDeclaredByCompilationUnit(unit).getEnum('MyEnum');
@@ skipping 42 matching lines @@
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     expect(getter.variable, same(field));
     expect(getter.type, isNotNull);
   }
 }
 
 @reflectiveTest
 class BuildExportNamespaceTaskTest extends _AbstractDartTaskTest {
   test_perform_entryPoint() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
+    Source sourceA = newSource('/a.dart', '''
 library lib_a;
 export 'b.dart';
 ''');
-    Source sourceB = newSource(
-        '/b.dart',
-        '''
+    Source sourceB = newSource('/b.dart', '''
 library lib_b;
 main() {}
 ''');
     computeResult(sourceA, LIBRARY_ELEMENT4,
         matcher: isBuildExportNamespaceTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT4];
     FunctionElement entryPoint = library.entryPoint;
     expect(entryPoint, isNotNull);
     expect(entryPoint.source, sourceB);
   }
 
   test_perform_hideCombinator() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
+    Source sourceA = newSource('/a.dart', '''
 library lib_a;
 export 'b.dart' hide B1;
 class A1 {}
 class A2 {}
 class _A3 {}
 ''');
-    newSource(
-        '/b.dart',
-        '''
+    newSource('/b.dart', '''
 library lib_b;
 class B1 {}
 class B2 {}
 class B3 {}
 class _B4 {}
 ''');
-    newSource(
-        '/c.dart',
-        '''
+    newSource('/c.dart', '''
 library lib_c;
 class C1 {}
 class C2 {}
 class C3 {}
 ''');
     computeResult(sourceA, LIBRARY_ELEMENT4,
         matcher: isBuildExportNamespaceTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT4];
     Namespace namespace = library.exportNamespace;
     Iterable<String> definedKeys = namespace.definedNames.keys;
     expect(definedKeys, unorderedEquals(['A1', 'A2', 'B2', 'B3']));
   }
 
   test_perform_showCombinator() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
+    Source sourceA = newSource('/a.dart', '''
 library lib_a;
 export 'b.dart' show B1;
 class A1 {}
 class A2 {}
 class _A3 {}
 ''');
-    newSource(
-        '/b.dart',
-        '''
+    newSource('/b.dart', '''
 library lib_b;
 class B1 {}
 class B2 {}
 class _B3 {}
 ''');
     computeResult(sourceA, LIBRARY_ELEMENT4,
         matcher: isBuildExportNamespaceTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT4];
     Namespace namespace = library.exportNamespace;
     Iterable<String> definedKeys = namespace.definedNames.keys;
     expect(definedKeys, unorderedEquals(['A1', 'A2', 'B1']));
   }
 
   test_perform_showCombinator_setter() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
+    Source sourceA = newSource('/a.dart', '''
 library lib_a;
 export 'b.dart' show topLevelB;
 class A {}
 ''');
-    newSource(
-        '/b.dart',
-        '''
+    newSource('/b.dart', '''
 library lib_b;
 int topLevelB;
 ''');
     computeResult(sourceA, LIBRARY_ELEMENT4,
         matcher: isBuildExportNamespaceTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT4];
     Namespace namespace = library.exportNamespace;
     Iterable<String> definedKeys = namespace.definedNames.keys;
     expect(definedKeys, unorderedEquals(['A', 'topLevelB', 'topLevelB=']));
@@ skipping 288 matching lines @@
   }
 }
 
 @reflectiveTest
 class BuildSourceExportClosureTaskTest extends _AbstractDartTaskTest {
   List<Source> getExportSourceClosure(Map<ResultDescriptor, dynamic> outputs) {
     return outputs[EXPORT_SOURCE_CLOSURE] as List<Source>;
   }
 
   test_perform_exportClosure() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
+    Source sourceA = newSource('/a.dart', '''
 library lib_a;
 export 'b.dart';
 ''');
-    Source sourceB = newSource(
-        '/b.dart',
-        '''
+    Source sourceB = newSource('/b.dart', '''
 library lib_b;
 export 'c.dart';
 ''');
-    Source sourceC = newSource(
-        '/c.dart',
-        '''
+    Source sourceC = newSource('/c.dart', '''
 library lib_c;
 export 'a.dart';
 ''');
-    Source sourceD = newSource(
-        '/d.dart',
-        '''
+    Source sourceD = newSource('/d.dart', '''
 library lib_d;
 ''');
     // a.dart
     {
       computeResult(sourceA, EXPORT_SOURCE_CLOSURE,
           matcher: isBuildSourceExportClosureTask);
       List<Source> closure = getExportSourceClosure(outputs);
       expect(closure, unorderedEquals([sourceA, sourceB, sourceC]));
     }
     // c.dart
@@ skipping 34 matching lines @@
       if (member is ClassDeclaration && member.name.name == className) {
         expect(member.metadata, hasLength(1));
         return member.metadata[0];
       }
     }
     fail('Annotation not found');
     return null;
   }
 
   test_annotation_with_args() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const x = 1;
 @D(x) class C {}
 class D { const D(value); }
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the elements for x and D's constructor, and the annotation on C.
@@ skipping 12 matching lines @@
     // the set [x, constructorForD].
     // TODO(paulberry): test librarySource != source
     computeResult(resolutionMap.elementAnnotationForAnnotation(annotation),
         CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(
         outputs[CONSTANT_DEPENDENCIES].toSet(), [x, constructorForD].toSet());
   }
 
   test_annotation_with_nonConstArg() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class A {
   const A(x);
 }
 class C {
   @A(const [(_) => null])
   String s;
 }
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the annotation on the field.
     ClassDeclaration classC = unit.declarations[1];
     Annotation annotation = classC.members[0].metadata[0];
     // Now compute the dependencies for the annotation, and check that it is
     // the right size.
     computeResult(resolutionMap.elementAnnotationForAnnotation(annotation),
         CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(outputs[CONSTANT_DEPENDENCIES], hasLength(1));
   }
 
   test_annotation_without_args() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const x = 1;
 @x class C {}
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the element for x and the annotation on C.
     List<PropertyAccessorElement> accessors =
         resolutionMap.elementDeclaredByCompilationUnit(unit).accessors;
     Element x = accessors
         .firstWhere((PropertyAccessorElement accessor) =>
             accessor.isGetter && accessor.name == 'x')
         .variable;
     Annotation annotation = findClassAnnotation(unit, 'C');
     // Now compute the dependencies for the annotation, and check that it is
     // the list [x].
     computeResult(resolutionMap.elementAnnotationForAnnotation(annotation),
         CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(outputs[CONSTANT_DEPENDENCIES], [x]);
   }
 
   test_enumConstant() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 enum E {A, B, C}
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT3);
     CompilationUnit unit = outputs[RESOLVED_UNIT3];
     // Find the element for 'A'
     EnumDeclaration enumDeclaration = unit.declarations[0];
     EnumConstantDeclaration constantDeclaration = enumDeclaration.constants[0];
     FieldElement constantElement = constantDeclaration.element;
     // Now compute the dependencies for the constant and check that there are
     // none.
     computeResult(constantElement, CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(outputs[CONSTANT_DEPENDENCIES], isEmpty);
   }
 
   test_perform() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const x = y;
 const y = 1;
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the elements for the constants x and y.
     List<PropertyAccessorElement> accessors =
@@ skipping 31 matching lines @@
         return evaluationResult;
       }
     }
     fail('Annotation not found');
     return null;
   }
 
   test_annotation_non_const_constructor() {
     // Calling a non-const constructor from an annotation that is illegal, but
     // shouldn't crash analysis.
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class A {
   final int i;
   A(this.i);
 }
 
 @A(5)
 class C {}
 ''');
     // First compute the resolved unit for the source.
     CompilationUnit unit = _resolveSource(source);
     // Compute the constant value of the annotation on C.
     EvaluationResultImpl evaluationResult =
         computeClassAnnotation(source, unit, 'C');
     // And check that it has no value stored in it.
     expect(evaluationResult, isNotNull);
     expect(evaluationResult.value, isNull);
   }
 
   test_annotation_with_args() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const x = 1;
 @D(x) class C {}
 class D {
   const D(this.value);
   final value;
 }
 ''');
     // First compute the resolved unit for the source.
     CompilationUnit unit = _resolveSource(source);
     // Compute the constant value of the annotation on C.
     EvaluationResultImpl evaluationResult =
         computeClassAnnotation(source, unit, 'C');
     // And check that it has the expected value.
     expect(evaluationResult, isNotNull);
     expect(evaluationResult.value, isNotNull);
     expect(evaluationResult.value.type, isNotNull);
     expect(evaluationResult.value.type.name, 'D');
     expect(evaluationResult.value.fields, contains('value'));
     expect(evaluationResult.value.fields['value'].toIntValue(), 1);
   }
 
   test_annotation_without_args() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const x = 1;
 @x class C {}
 ''');
     // First compute the resolved unit for the source.
     CompilationUnit unit = _resolveSource(source);
     // Compute the constant value of the annotation on C.
     EvaluationResultImpl evaluationResult =
         computeClassAnnotation(source, unit, 'C');
     // And check that it has the expected value.
     expect(evaluationResult, isNotNull);
     expect(evaluationResult.value, isNotNull);
     expect(evaluationResult.value.toIntValue(), 1);
   }
 
   test_circular_reference() {
-    _checkCircularities(
-        'x',
-        ['y'],
-        '''
+    _checkCircularities('x', ['y'], '''
 const x = y + 1;
 const y = x + 1;
 ''');
   }
 
   test_circular_reference_one_element() {
     // See dartbug.com/23490.
     _checkCircularities('x', [], 'const x = x;');
   }
 
   test_circular_reference_strongly_connected_component() {
     // When there is a circularity, all elements in the strongly connected
     // component should be marked as having an error.
-    _checkCircularities(
-        'a',
-        ['b', 'c', 'd'],
-        '''
+    _checkCircularities('a', ['b', 'c', 'd'], '''
 const a = b;
 const b = c + d;
 const c = a;
 const d = a;
 ''');
   }
 
   test_const_constructor_calls_implicit_super_constructor_implicitly() {
     // Note: the situation below is a compile-time error (since the synthetic
     // constructor for Base is non-const), but we need to handle it without
     // throwing an exception.
-    EvaluationResultImpl evaluationResult = _computeTopLevelVariableConstValue(
-        'x',
-        '''
+    EvaluationResultImpl evaluationResult =
+        _computeTopLevelVariableConstValue('x', '''
 class Base {}
 class Derived extends Base {
   const Derived();
 }
 const x = const Derived();
 ''');
     expect(evaluationResult, isNotNull);
   }
 
   test_dependency() {
-    EvaluationResultImpl evaluationResult = _computeTopLevelVariableConstValue(
-        'x',
-        '''
+    EvaluationResultImpl evaluationResult =
+        _computeTopLevelVariableConstValue('x', '''
 const x = y + 1;
 const y = 1;
 ''');
     expect(evaluationResult, isNotNull);
     expect(evaluationResult.value, isNotNull);
     expect(evaluationResult.value.toIntValue(), 2);
   }
 
   test_external_const_factory() {
-    EvaluationResultImpl evaluationResult = _computeTopLevelVariableConstValue(
-        'x',
-        '''
+    EvaluationResultImpl evaluationResult =
+        _computeTopLevelVariableConstValue('x', '''
 const x = const C.foo();
 
 class C extends B {
   external const factory C.foo();
 }
 
 class B {}
 ''');
     expect(evaluationResult, isNotNull);
   }
 
   test_simple_constant() {
-    EvaluationResultImpl evaluationResult = _computeTopLevelVariableConstValue(
-        'x',
-        '''
+    EvaluationResultImpl evaluationResult =
+        _computeTopLevelVariableConstValue('x', '''
 const x = 1;
 ''');
     expect(evaluationResult, isNotNull);
     expect(evaluationResult.value, isNotNull);
     expect(evaluationResult.value.toIntValue(), 1);
   }
 
   void _checkCircularities(
       String variableName, List<String> otherVariables, String content) {
     // Evaluating the first constant should produce an error.
@@ skipping 53 matching lines @@
 class ComputeInferableStaticVariableDependenciesTaskTest
     extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     // Variable dependencies are only available in strong mode.
     enableStrongMode();
   }
 
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT7);
     expect(outputs[RESOLVED_UNIT7], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT7], isTrue);
   }
 
   test_perform() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 const a = b;
 const b = 0;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     TopLevelVariableElement elementA = resolutionMap
         .elementDeclaredByCompilationUnit(unit)
         .topLevelVariables[0];
     TopLevelVariableElement elementB = resolutionMap
@@ skipping 27 matching lines @@
   }
 
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   void test_library_cycle_incremental() {
     enableStrongMode();
-    Source a = newSource(
-        '/a.dart',
-        '''
+    Source a = newSource('/a.dart', '''
 library a;
 ''');
-    Source b = newSource(
-        '/b.dart',
-        '''
+    Source b = newSource('/b.dart', '''
 library b;
 import 'a.dart';
 ''');
-    Source c = newSource(
-        '/c.dart',
-        '''
+    Source c = newSource('/c.dart', '''
 library c;
 import 'b.dart';
 ''');
 
     _assertLibraryCycle(a, [a]);
     _assertLibraryCycle(b, [b]);
     _assertLibraryCycle(c, [c]);
 
     // Create a cycle.
-    context.setContents(
-        a,
-        '''
+    context.setContents(a, '''
 library a;
 import 'c.dart';
 ''');
     _expectInvalid(a);
     _expectInvalid(b);
     _expectInvalid(c);
 
     _assertLibraryCycle(a, [a, b, c]);
     _assertLibraryCycle(b, [a, b, c]);
     _assertLibraryCycle(c, [a, b, c]);
 
     // Break the cycle again.
-    context.setContents(
-        a,
-        '''
+    context.setContents(a, '''
 library a;
 ''');
     _expectInvalid(a);
     _expectInvalid(b);
     _expectInvalid(c);
 
     _assertLibraryCycle(a, [a]);
     _assertLibraryCycle(b, [b]);
     _assertLibraryCycle(c, [c]);
   }
 
   void test_library_cycle_incremental_partial() {
     enableStrongMode();
-    Source a = newSource(
-        '/a.dart',
-        r'''
+    Source a = newSource('/a.dart', r'''
 library a;
 ''');
-    Source b = newSource(
-        '/b.dart',
-        r'''
+    Source b = newSource('/b.dart', r'''
 library b;
 import 'a.dart';
 ''');
-    Source c = newSource(
-        '/c.dart',
-        r'''
+    Source c = newSource('/c.dart', r'''
 library c;
 import 'b.dart';
 ''');
 
     _assertLibraryCycle(a, [a]);
     _assertLibraryCycle(b, [b]);
     // 'c' is not reachable, so we have not yet computed its library cycles.
 
     // Complete the cycle, via 'c'.
-    context.setContents(
-        a,
-        r'''
+    context.setContents(a, r'''
 library a;
 import 'c.dart';
 ''');
     _expectInvalid(a);
     _expectInvalid(b);
     _expectInvalid(c);
 
     // Ensure that everything reachable through 'c' was invalidated,
     // and recomputed to include all three sources.
     _assertLibraryCycle(a, [a, b, c]);
     _assertLibraryCycle(b, [a, b, c]);
     _assertLibraryCycle(c, [a, b, c]);
   }
 
   void test_library_cycle_incremental_partial2() {
     enableStrongMode();
-    Source a = newSource(
-        '/a.dart',
-        r'''
+    Source a = newSource('/a.dart', r'''
 library a;
 import 'b.dart';
 ''');
-    Source b = newSource(
-        '/b.dart',
-        r'''
+    Source b = newSource('/b.dart', r'''
 library b;
 import 'a.dart';
 ''');
-    Source c = newSource(
-        '/c.dart',
-        r'''
+    Source c = newSource('/c.dart', r'''
 library c;
 import 'b.dart';
 ''');
 
     _assertLibraryCycle(a, [a, b]);
     _assertLibraryCycle(b, [a, b]);
     _assertLibraryCycle(c, [c]);
 
     // Include 'c' into the cycle.
-    context.setContents(
-        a,
-        r'''
+    context.setContents(a, r'''
 library a;
 import 'b.dart';
 import 'c.dart';
 ''');
     _expectInvalid(a);
     _expectInvalid(b);
     _expectInvalid(c);
 
     // Start processing with 'b', so that when we resolve 'b' directives,
     // and invalidate library cycles, the 'a' directives are not resolved yet,
@@ skipping 61 matching lines @@
     List<LibrarySpecificUnit> dep0 = getLibraryCycleDependencies(results[0]);
     List<LibrarySpecificUnit> dep1 = getLibraryCycleDependencies(results[1]);
     List<LibrarySpecificUnit> dep2 = getLibraryCycleDependencies(results[2]);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(1)); // dart:core
     expect(dep2, hasLength(1)); // dart:core
   }
 
   void test_library_cycle_override_inference_incremental() {
     enableStrongMode();
-    Source lib1Source = newSource(
-        '/my_lib1.dart',
-        '''
+    Source lib1Source = newSource('/my_lib1.dart', '''
 library my_lib1;
 import 'my_lib3.dart';
 ''');
-    Source lib2Source = newSource(
-        '/my_lib2.dart',
-        '''
+    Source lib2Source = newSource('/my_lib2.dart', '''
 library my_lib2;
 import 'my_lib1.dart';
 ''');
-    Source lib3Source = newSource(
-        '/my_lib3.dart',
-        '''
+    Source lib3Source = newSource('/my_lib3.dart', '''
 library my_lib3;
 import 'my_lib2.dart';
 
 class A {
   int foo(int x) => null;
 }
 class B extends A {
   foo(x) => null;
 }
 ''');
     AnalysisTarget lib1Target = new LibrarySpecificUnit(lib1Source, lib1Source);
     AnalysisTarget lib2Target = new LibrarySpecificUnit(lib2Source, lib2Source);
     AnalysisTarget lib3Target = new LibrarySpecificUnit(lib3Source, lib3Source);
 
     computeResult(lib1Target, RESOLVED_UNIT);
     computeResult(lib2Target, RESOLVED_UNIT);
     computeResult(lib3Target, RESOLVED_UNIT);
     CompilationUnit unit = outputs[RESOLVED_UNIT];
     ClassElement b = unit.declarations[1].element;
     expect(b.getMethod('foo').returnType.toString(), 'int');
 
     // add a dummy edit.
-    context.setContents(
-        lib1Source,
-        '''
+    context.setContents(lib1Source, '''
 library my_lib1;
 import 'my_lib3.dart';
 var foo = 123;
 ''');
     _expectInvalid(lib1Source);
     _expectInvalid(lib2Source);
     _expectInvalid(lib3Source);
 
     computeResult(lib1Target, RESOLVED_UNIT);
     computeResult(lib2Target, RESOLVED_UNIT);
@@ skipping 16 matching lines @@
     expect(component0, hasLength(1));
 
     List<LibrarySpecificUnit> units0 = getLibraryCycleUnits(results[0]);
     expect(units0, hasLength(1));
 
     List<LibrarySpecificUnit> dep0 = getLibraryCycleDependencies(results[0]);
     expect(dep0, hasLength(1)); // dart:core
   }
 
   void test_library_cycle_singleton() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 import 'dart:core';
 ''');
     computeResult(source, LIBRARY_CYCLE);
     List<LibraryElement> component = getLibraryCycle(outputs);
     List<LibrarySpecificUnit> units = getLibraryCycleUnits(outputs);
     List<LibrarySpecificUnit> deps = getLibraryCycleDependencies(outputs);
     expect(component, hasLength(1));
     expect(units, hasLength(1));
     expect(deps, hasLength(1));
   }
@@ skipping 238 matching lines @@
     List<AnalysisError> errors = getDartErrors(outputs);
     // This should contain only the errors in the part file, not the ones in the
     // library.
     expect(errors, hasLength(1));
   }
 }
 
 @reflectiveTest
 class EvaluateUnitConstantsTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT12);
     expect(outputs[RESOLVED_UNIT12], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT12], isTrue);
   }
 
   test_perform() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class C {
   const C();
 }
 
 @x
 f() {}
 
 const x = const C();
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
@@ skipping 15 matching lines @@
         isNotNull);
   }
 }
 
 @reflectiveTest
 class GatherUsedImportedElementsTaskTest extends _AbstractDartTaskTest {
   UsedImportedElements usedElements;
   Set<String> usedElementNames;
 
   test_perform_inBody() {
-    newSource(
-        '/a.dart',
-        r'''
+    newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
-    newSource(
-        '/b.dart',
-        r'''
+    newSource('/b.dart', r'''
 library lib_b;
 class B {}
 ''');
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'a.dart';
 import 'b.dart';
 main() {
   new A();
 }''');
     _computeUsedElements(source);
     // validate
     expect(usedElementNames, unorderedEquals(['A']));
   }
 
   test_perform_inComment_exportDirective() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'dart:async';
 /// Use [Future].
 export 'dart:math';
 ''');
     _computeUsedElements(source);
     expect(usedElementNames, unorderedEquals(['Future']));
   }
 
   test_perform_inComment_importDirective() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'dart:async';
 /// Use [Future].
 import 'dart:math';
 ''');
     _computeUsedElements(source);
     expect(usedElementNames, unorderedEquals(['Future']));
   }
 
   test_perform_inComment_libraryDirective() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 /// Use [Future].
 library test;
 import 'dart:async';
 ''');
     _computeUsedElements(source);
     expect(usedElementNames, unorderedEquals(['Future']));
   }
 
   test_perform_inComment_topLevelFunction() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'dart:async';
 /// Use [Future].
 main() {}
 ''');
     _computeUsedElements(source);
     expect(usedElementNames, unorderedEquals(['Future']));
   }
 
   void _computeUsedElements(Source source) {
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, USED_IMPORTED_ELEMENTS,
         matcher: isGatherUsedImportedElementsTask);
     usedElements = outputs[USED_IMPORTED_ELEMENTS];
     usedElementNames = usedElements.elements.map((e) => e.name).toSet();
   }
 }
 
 @reflectiveTest
 class GatherUsedLocalElementsTaskTest extends _AbstractDartTaskTest {
   UsedLocalElements usedElements;
   Set<String> usedElementNames;
 
   test_perform_forPart_afterLibraryUpdate() {
-    Source libSource = newSource(
-        '/my_lib.dart',
-        '''
+    Source libSource = newSource('/my_lib.dart', '''
 library my_lib;
 part 'my_part.dart';
 foo() => null;
 class _LocalClass {}
 ''');
-    Source partSource = newSource(
-        '/my_part.dart',
-        '''
+    Source partSource = newSource('/my_part.dart', '''
 part of my_lib;
 bar() {
   print(_LocalClass);
 }
 ''');
     AnalysisTarget libTarget = new LibrarySpecificUnit(libSource, libSource);
     AnalysisTarget partTarget = new LibrarySpecificUnit(libSource, partSource);
     computeResult(libTarget, USED_LOCAL_ELEMENTS);
     computeResult(partTarget, USED_LOCAL_ELEMENTS);
     // _LocalClass is used in my_part.dart
     {
       UsedLocalElements usedElements =
           analysisCache.getValue(partTarget, USED_LOCAL_ELEMENTS);
       expect(usedElements.elements, contains(predicate((Element e) {
         return e.displayName == '_LocalClass';
       })));
     }
     // change my_lib.dart and recompute
-    context.setContents(
-        libSource,
-        '''
+    context.setContents(libSource, '''
 library my_lib;
 part 'my_part.dart';
 String foo() => null;
 class _LocalClass {}
 ''');
     computeResult(libTarget, USED_LOCAL_ELEMENTS);
     computeResult(partTarget, USED_LOCAL_ELEMENTS);
     // _LocalClass should still be used in my_part.dart
     {
       UsedLocalElements usedElements =
           analysisCache.getValue(partTarget, USED_LOCAL_ELEMENTS);
       expect(usedElements.elements, contains(predicate((Element e) {
         return e.displayName == '_LocalClass';
       })));
     }
   }
 
   test_perform_localVariable() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 main() {
   var v1 = 1;
   var v2 = 2;
   print(v2);
 }''');
     _computeUsedElements(source);
     // validate
     expect(usedElementNames, unorderedEquals(['v2']));
   }
 
   test_perform_method() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 class A {
   _m1() {}
   _m2() {}
 }
 
 main(A a, p) {
   a._m2();
   p._m3();
 }
 ''');
     _computeUsedElements(source);
     // validate
     expect(usedElementNames, unorderedEquals(['A', 'a', 'p', '_m2']));
     expect(usedElements.members, unorderedEquals(['_m2', '_m3']));
   }
 
   void _computeUsedElements(Source source) {
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, USED_LOCAL_ELEMENTS,
         matcher: isGatherUsedLocalElementsTask);
     usedElements = outputs[USED_LOCAL_ELEMENTS];
     usedElementNames = usedElements.elements.map((e) => e.name).toSet();
   }
 }
 
 @reflectiveTest
 class GenerateHintsTaskTest extends _AbstractDartTaskTest {
   test_perform_bestPractices_missingReturn() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 int main() {
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.MISSING_RETURN]);
   }
 
   test_perform_dart2js() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.dart2jsHint = true;
     prepareAnalysisContext(options);
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main(p) {
   if (p is double) {
     print('double');
   }
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.IS_DOUBLE]);
   }
 
   test_perform_deadCode() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main() {
   if (false) {
     print('how?');
   }
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.DEAD_CODE]);
   }
 
   test_perform_disabled() {
     context.analysisOptions =
         new AnalysisOptionsImpl.from(context.analysisOptions)..hint = false;
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 int main() {
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertNoErrors();
   }
 
   test_perform_imports_duplicateImport() {
-    newSource(
-        '/a.dart',
-        r'''
+    newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'a.dart';
 import 'a.dart';
 main() {
   new A();
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.DUPLICATE_IMPORT]);
   }
 
   test_perform_imports_unusedImport_one() {
-    newSource(
-        '/a.dart',
-        r'''
+    newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
-    newSource(
-        '/b.dart',
-        r'''
+    newSource('/b.dart', r'''
 library lib_b;
 class B {}
 ''');
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'a.dart';
 import 'b.dart';
 main() {
   new A();
 }''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.UNUSED_IMPORT]);
   }
 
   test_perform_imports_unusedImport_zero() {
-    newSource(
-        '/a.dart',
-        r'''
+    newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 import 'a.dart';
 main() {
   new A();
 }''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertNoErrors();
   }
 
   test_perform_overrideVerifier() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class A {}
 class B {
   @override
   m() {}
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD]);
   }
 
   test_perform_todo() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main() {
   // TODO(developer) foo bar
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[TodoCode.TODO]);
   }
 
   test_perform_unusedLocalElements_class() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class _A {}
 class _B {}
 main() {
   new _A();
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.UNUSED_ELEMENT]);
   }
 
   test_perform_unusedLocalElements_localVariable() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main() {
   var v = 42;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[HintCode.UNUSED_LOCAL_VARIABLE]);
   }
 
   test_perform_unusedLocalElements_method() {
-    Source source = newSource(
-        '/my_lib.dart',
-        '''
+    Source source = newSource('/my_lib.dart', '''
 library my_lib;
 part 'my_part.dart';
 class A {
   _ma() {}
   _mb() {}
   _mc() {}
 }
 ''');
-    newSource(
-        '/my_part.dart',
-        '''
+    newSource('/my_part.dart', '''
 part of my_lib;
 
 f(A a) {
   a._mb();
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
@@ skipping 17 matching lines @@
     setLints(context, [new GenerateLintsTaskTest_TestLinter()]);
   }
 
   @override
   void tearDown() {
     setLints(context, []);
     super.tearDown();
   }
 
   test_camel_case_types() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class a { }
 ''');
 
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, LINTS, matcher: isGenerateLintsTask);
     // validate
     _fillErrorListener(LINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[_testLintCode]);
   }
 }
@@ skipping 15 matching lines @@
   @override
   String get name => 'GenerateLintsTaskTest_TestLinter';
 
   @override
   AstVisitor getVisitor() => new GenerateLintsTaskTest_AstVisitor(this);
 }
 
 @reflectiveTest
 class InferInstanceMembersInUnitTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT10);
     expect(outputs[RESOLVED_UNIT10], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT10], isTrue);
   }
 
   void test_perform() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 class A {
   X f;
   Y m(Z x) {}
 }
 class B extends A {
   var f;
   m(x) {}
 }
 class X {}
 class Y {}
@@ skipping 21 matching lines @@
     expect(
         resolutionMap
             .elementDeclaredByMethodDeclaration(method)
             .parameters[0]
             .type,
         typeZ);
   }
 
   void test_perform_cross_library_const() {
     enableStrongMode();
-    AnalysisTarget firstSource = newSource(
-        '/first.dart',
-        '''
+    AnalysisTarget firstSource = newSource('/first.dart', '''
 library first;
 
 const a = 'hello';
 ''');
-    AnalysisTarget secondSource = newSource(
-        '/second.dart',
-        '''
+    AnalysisTarget secondSource = newSource('/second.dart', '''
 import 'first.dart';
 
 const b = a;
 class M {
    String c = a;
 }
 ''');
     computeResult(
         new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT10,
         matcher: isInferInstanceMembersInUnitTask);
@@ skipping 15 matching lines @@
     expect(resolutionMap.elementDeclaredByVariableDeclaration(variableB).type,
         stringType);
     expect(variableB.initializer.staticType, stringType);
     expect(resolutionMap.elementDeclaredByVariableDeclaration(variableC).type,
         stringType);
     expect(variableC.initializer.staticType, stringType);
   }
 
   void test_perform_reresolution() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 const topLevel = '';
 class C {
   String field = topLevel;
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
     CompilationUnit unit = outputs[RESOLVED_UNIT10];
     VariableDeclaration topLevelDecl =
         AstFinder.getTopLevelVariable(unit, 'topLevel');
     VariableDeclaration fieldDecl =
@@ skipping 10 matching lines @@
 
 @reflectiveTest
 class InferStaticVariableTypesInUnitTaskTest extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT8);
     expect(outputs[RESOLVED_UNIT8], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT8], isTrue);
   }
 
   void test_perform_const_field() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 class M {
   static const X = "";
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8,
         matcher: isInferStaticVariableTypesInUnitTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT8];
     VariableDeclaration declaration = AstFinder.getFieldInClass(unit, 'M', 'X');
     InterfaceType stringType = context.typeProvider.stringType;
     expect(resolutionMap.elementDeclaredByVariableDeclaration(declaration).type,
         stringType);
   }
 
   test_perform_hasParseError() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 @(i $=
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT8);
     expect(outputs[RESOLVED_UNIT8], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT8], isTrue);
   }
 
   void test_perform_nestedDeclarations() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var f = (int x) {
   int squared(int value) => value * value;
   var xSquared = squared(x);
   return xSquared;
 };
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8,
         matcher: isInferStaticVariableTypesInUnitTask);
   }
 
   void test_perform_recursive() {
     enableStrongMode();
-    AnalysisTarget firstSource = newSource(
-        '/first.dart',
-        '''
+    AnalysisTarget firstSource = newSource('/first.dart', '''
 import 'second.dart';
 
 var a = new M();
 var c = b;
 ''');
-    AnalysisTarget secondSource = newSource(
-        '/second.dart',
-        '''
+    AnalysisTarget secondSource = newSource('/second.dart', '''
 import 'first.dart';
 
 var b = a;
 class M {}
 ''');
     computeResult(
         new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT8,
         matcher: isInferStaticVariableTypesInUnitTask);
     CompilationUnit firstUnit = outputs[RESOLVED_UNIT8];
     computeResult(
@@ skipping 15 matching lines @@
     expect(resolutionMap.elementDeclaredByVariableDeclaration(variableB).type,
         typeM);
     expect(variableB.initializer.staticType, typeM);
     expect(resolutionMap.elementDeclaredByVariableDeclaration(variableC).type,
         typeM);
     expect(variableC.initializer.staticType, typeM);
   }
 
   void test_perform_simple() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var X = 1;
 var Y = () => 1 + X;
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8,
         matcher: isInferStaticVariableTypesInUnitTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT8];
     TopLevelVariableDeclaration declaration = unit.declarations[1];
     FunctionExpression function =
         declaration.variables.variables[0].initializer;
     ExpressionFunctionBody body = function.body;
     Expression expression = body.expression;
     InterfaceType intType = context.typeProvider.intType;
     expect(expression.staticType, intType);
   }
 
   test_staticModeHints_forStaticVariableInference() {
     context.analysisOptions =
         new AnalysisOptionsImpl.from(context.analysisOptions)
           ..strongModeHints = true;
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 var V = [42];
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT8);
     expect(outputs[RESOLVED_UNIT8], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT8], isTrue);
     // An INFERRED_TYPE_LITERAL error should be generated.
     List<AnalysisError> errors =
         outputs[STATIC_VARIABLE_RESOLUTION_ERRORS_IN_UNIT]
             as List<AnalysisError>;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, StrongModeCode.INFERRED_TYPE_LITERAL);
   }
 }
 
 @reflectiveTest
 class InferStaticVariableTypeTaskTest extends _AbstractDartTaskTest {
   void test_getDeclaration_staticField() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 class C {
   var field = '';
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableDeclaration declaration =
         AstFinder.getFieldInClass(unit, 'C', 'field');
     VariableElement variable = declaration.name.staticElement;
     InferStaticVariableTypeTask inferTask =
         new InferStaticVariableTypeTask(task.context, variable);
     expect(inferTask.getDeclaration(unit), declaration);
   }
 
   void test_getDeclaration_topLevel() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var topLevel = '';
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableDeclaration declaration =
         AstFinder.getTopLevelVariable(unit, 'topLevel');
     VariableElement variable = declaration.name.staticElement;
     InferStaticVariableTypeTask inferTask =
         new InferStaticVariableTypeTask(task.context, variable);
     expect(inferTask.getDeclaration(unit), declaration);
   }
 
   void test_perform() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test3.dart',
-        '''
+    AnalysisTarget source = newSource('/test3.dart', '''
 var topLevel3 = '';
 class C {
   var field3 = topLevel3;
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableDeclaration topLevelDecl =
         AstFinder.getTopLevelVariable(unit, 'topLevel3');
     VariableDeclaration fieldDecl =
         AstFinder.getFieldInClass(unit, 'C', 'field3');
     VariableElement topLevel = topLevelDecl.name.staticElement;
     VariableElement field = fieldDecl.name.staticElement;
 
     computeResult(field, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     InterfaceType stringType = context.typeProvider.stringType;
     expect(topLevel.type, stringType);
     expect(field.type, stringType);
     expect(fieldDecl.initializer.staticType, stringType);
   }
 
   void test_perform_const() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 const topLevel = "hello";
 class C {
   var field = topLevel;
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableElement topLevel =
         AstFinder.getTopLevelVariable(unit, 'topLevel').name.staticElement;
     VariableElement field =
         AstFinder.getFieldInClass(unit, 'C', 'field').name.staticElement;
 
     computeResult(field, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     InterfaceType stringType = context.typeProvider.stringType;
     expect(topLevel.type, stringType);
     expect(field.type, stringType);
   }
 
   void test_perform_cycle() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var piFirst = true;
 var pi = piFirst ? 3.14 : tau / 2;
 var tau = piFirst ? pi * 2 : 6.28;
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableElement piFirst =
         AstFinder.getTopLevelVariable(unit, 'piFirst').name.staticElement;
     VariableElement pi =
         AstFinder.getTopLevelVariable(unit, 'pi').name.staticElement;
     VariableElement tau =
         AstFinder.getTopLevelVariable(unit, 'tau').name.staticElement;
 
     computeResult(piFirst, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     expect(piFirst.type, context.typeProvider.boolType);
     expect(pi.type.isDynamic, isTrue);
     expect(tau.type.isDynamic, isTrue);
   }
 
   void test_perform_error() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var a = '' / null;
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableElement a =
         AstFinder.getTopLevelVariable(unit, 'a').name.staticElement;
 
     computeResult(a, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     expect(a.type.isDynamic, isTrue);
   }
 
   void test_perform_null() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var a = null;
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableElement a =
         AstFinder.getTopLevelVariable(unit, 'a').name.staticElement;
 
     computeResult(a, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     expect(a.type.isDynamic, isTrue);
   }
 }
 
 @reflectiveTest
 class LibraryErrorsReadyTaskTest extends _AbstractDartTaskTest {
   test_perform() {
-    Source library = newSource(
-        '/lib.dart',
-        r'''
+    Source library = newSource('/lib.dart', r'''
 library lib;
 part 'part1.dart';
 part 'part2.dart';
 X v1;
 ''');
-    Source part1 = newSource(
-        '/part1.dart',
-        r'''
+    Source part1 = newSource('/part1.dart', r'''
 part of lib;
 X v2;
 ''');
-    Source part2 = newSource(
-        '/part2.dart',
-        r'''
+    Source part2 = newSource('/part2.dart', r'''
 part of lib;
 X v3;
 ''');
     computeResult(library, LIBRARY_ERRORS_READY,
         matcher: isLibraryErrorsReadyTask);
     expect(outputs, hasLength(1));
     bool ready = outputs[LIBRARY_ERRORS_READY];
     expect(ready, isTrue);
     expect(context.getErrors(library).errors, hasLength(1));
     expect(context.getErrors(part1).errors, hasLength(1));
@@ skipping 47 matching lines @@
     expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
     expect(outputs[PARSE_ERRORS], hasLength(0));
     expect(outputs[PARSED_UNIT], isNotNull);
     expect(outputs[REFERENCED_SOURCES], hasLength(2));
     expect(outputs[SOURCE_KIND], SourceKind.PART);
     expect(outputs[UNITS], hasLength(1));
   }
 
   test_perform_computeSourceKind_noDirectives_hasContainingLibrary() {
     // Parse "lib.dart" to let the context know that "test.dart" is included.
-    computeResult(
-        newSource(
-            '/lib.dart',
-            r'''
+    computeResult(newSource('/lib.dart', r'''
 library lib;
 part 'test.dart';
-'''),
-        PARSED_UNIT);
+'''), PARSED_UNIT);
     // If there are no the "part of" directive, then it is not a part.
     _performParseTask('');
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
   }
 
   test_perform_computeSourceKind_noDirectives_noContainingLibrary() {
     _performParseTask('');
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
   }
 
@@ skipping 232 matching lines @@
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
     })));
   }
 }
 
 @reflectiveTest
 class PartiallyResolveUnitReferencesTaskTest extends _AbstractDartTaskTest {
   test_perform_strong_importExport() {
-    newSource(
-        '/a.dart',
-        '''
+    newSource('/a.dart', '''
 library a;
 class A<T> {
   T m() {}
 }
 ''');
-    newSource(
-        '/b.dart',
-        '''
+    newSource('/b.dart', '''
 library b;
 export 'a.dart';
 ''');
-    Source sourceC = newSource(
-        '/c.dart',
-        '''
+    Source sourceC = newSource('/c.dart', '''
 library c;
 import 'b.dart';
 main() {
   new A<int>().m();
 }
 ''');
     computeResult(new LibrarySpecificUnit(sourceC, sourceC), RESOLVED_UNIT7,
         matcher: isPartiallyResolveUnitReferencesTask);
     // validate
     expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(0));
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     expect(unit, isNotNull);
 
     FunctionDeclaration mainFunction = unit.declarations[0];
     expect(mainFunction.element, isNotNull);
     BlockFunctionBody body = mainFunction.functionExpression.body;
     List<Statement> statements = body.block.statements;
     ExpressionStatement statement = statements[0];
     MethodInvocation invocation = statement.expression;
     MethodElement methodElement = invocation.methodName.staticElement;
     expect(methodElement, isNull);
   }
 
   test_perform_strong_inferable() {
     enableStrongMode();
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 int a = b;
 int b = c;
 var d = 0;
 class A {}
 class C {
   static final f = '';
   var g = 0;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
@@ skipping 10 matching lines @@
     }
     // Test the state of the AST
     TopLevelVariableDeclaration a = unit.declarations[0];
     VariableDeclaration variableA = a.variables.variables[0];
     SimpleIdentifier initializer = variableA.initializer;
     expect(initializer.staticElement, isNotNull);
   }
 
   test_perform_strong_notResolved() {
     enableStrongMode();
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 int A;
 f1() {
   A;
 }
 var f2 = () {
   A;
   void f3() {
     A;
   }
 }
@@ skipping 102 matching lines @@
 
 @reflectiveTest
 class ResolveInstanceFieldsInUnitTaskTest extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT9);
     expect(outputs[RESOLVED_UNIT9], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT9], isTrue);
   }
 
   /**
@@ skipping 216 matching lines @@
 
     // B.b2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         AstFinder.getFieldInClass(unit0, "B", "b2"), intType, intType);
   }
 }
 
 @reflectiveTest
 class ResolveLibraryTaskTest extends _AbstractDartTaskTest {
   test_perform() {
-    Source sourceLib = newSource(
-        '/my_lib.dart',
-        '''
+    Source sourceLib = newSource('/my_lib.dart', '''
 library my_lib;
 const a = new A();
 class A {
   const A();
 }
 @a
 class C {}
 ''');
     computeResult(sourceLib, LIBRARY_ELEMENT, matcher: isResolveLibraryTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT];
     ClassElement classC = library.getType('C');
     List<ElementAnnotation> metadata = classC.metadata;
     expect(metadata, hasLength(1));
     ElementAnnotation annotation = metadata[0];
     expect(annotation, isNotNull);
     expect((annotation as ElementAnnotationImpl).evaluationResult, isNotNull);
   }
 }
 
 @reflectiveTest
 class ResolveLibraryTypeNamesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
-    Source sourceLib = newSource(
-        '/my_lib.dart',
-        '''
+    Source sourceLib = newSource('/my_lib.dart', '''
 library my_lib;
 part 'my_part.dart';
 class A {}
 class B extends A {}
 ''');
-    newSource(
-        '/my_part.dart',
-        '''
+    newSource('/my_part.dart', '''
 part of my_lib;
 class C extends A {}
 ''');
     computeResult(sourceLib, LIBRARY_ELEMENT6,
         matcher: isResolveLibraryTypeNamesTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT6];
     {
       ClassElement classB = library.getType('B');
       expect(classB.supertype.displayName, 'A');
     }
     {
       ClassElement classC = library.getType('C');
       expect(classC.supertype.displayName, 'A');
     }
     expect(library.loadLibraryFunction, isNotNull);
   }
 
   test_perform_external() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
+    Source sourceA = newSource('/a.dart', '''
 library a;
 import 'b.dart';
 class A extends B {}
 ''');
-    newSource(
-        '/b.dart',
-        '''
+    newSource('/b.dart', '''
 library b;
 class B {}
 ''');
     // The reference A to B should be resolved, but there's no requirement that
     // the full class hierarchy be resolved.
     computeResult(sourceA, LIBRARY_ELEMENT6,
         matcher: isResolveLibraryTypeNamesTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT6];
     {
       ClassElement clazz = library.getType('A');
       expect(clazz.displayName, 'A');
       clazz = clazz.supertype.element;
       expect(clazz.displayName, 'B');
     }
   }
 }
 
 @reflectiveTest
 class ResolveTopLevelUnitTypeBoundsTaskTest extends _AbstractDartTaskTest {
   test_perform_boundIsGenericType() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class C<T extends Map<String, List<int>>> {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT4,
         matcher: isResolveTopLevelUnitTypeBoundsTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT4];
     ClassDeclaration nodeC = unit.declarations[0];
     _assertTypeParameterBound(nodeC.typeParameters.typeParameters[0],
         'Map<String, List<int>>', 'Map');
   }
 
   test_perform_errors() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class C<T extends NoSuchClass> {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVE_TYPE_BOUNDS_ERRORS,
         matcher: isResolveTopLevelUnitTypeBoundsTask);
     // validate
     _fillErrorListener(RESOLVE_TYPE_BOUNDS_ERRORS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
   }
 
   test_perform_ignoreBoundsOfBounds() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class A<T1 extends num> {}
 class B<T2 extends A> {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT4,
         matcher: isResolveTopLevelUnitTypeBoundsTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT4];
     ClassDeclaration nodeB = unit.declarations[1];
     _assertTypeParameterBound(
         nodeB.typeParameters.typeParameters[0], 'A<dynamic>', 'A');
   }
 
   test_perform_outputs() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 class C<T extends int> {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT4);
     expect(outputs[RESOLVED_UNIT4], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT4], isTrue);
     expect(outputs[RESOLVE_TYPE_BOUNDS_ERRORS], isNotNull);
   }
 
   test_perform_unitMember_ClassDeclaration() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class C<T extends int> extends Object {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT4,
         matcher: isResolveTopLevelUnitTypeBoundsTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT4];
     ClassDeclaration nodeC = unit.declarations[0];
     // 'extends Object' is not resolved
     expect(nodeC.extendsClause.superclass.name.staticElement, isNull);
     // but 'T extends int' is resolved
     _assertTypeParameterBound(
         nodeC.typeParameters.typeParameters[0], 'int', 'int');
   }
 
   test_perform_unitMember_ClassTypeAlias() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class C<T extends double> = Object;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT4,
         matcher: isResolveTopLevelUnitTypeBoundsTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT4];
     ClassTypeAlias nodeC = unit.declarations[0];
     // '= Object' is not resolved
     expect(nodeC.superclass.name.staticElement, isNull);
     // but 'T extends int' is resolved
     _assertTypeParameterBound(
         nodeC.typeParameters.typeParameters[0], 'double', 'double');
   }
 
   test_perform_unitMember_FunctionTypeAlias() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 typedef F<T extends String>();
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT4,
         matcher: isResolveTopLevelUnitTypeBoundsTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT4];
     FunctionTypeAlias nodeF = unit.declarations[0];
     // but 'T extends String' is resolved
     _assertTypeParameterBound(
@@ skipping 10 matching lines @@
     expect(boundNode.type.toString(), expectedBoundTypeString);
     expect(boundName.staticType.toString(), expectedBoundTypeString);
     expect(resolutionMap.staticElementForIdentifier(boundName).displayName,
         expectedBoundElementName);
   }
 }
 
 @reflectiveTest
 class ResolveUnitTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT11);
     expect(outputs[RESOLVED_UNIT11], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT11], isTrue);
   }
 
   void test_perform() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 void f() {
   var c = new C();
   c.m();
 }
 class C {
   void m() {
     f();
   }
 }
 ''');
@@ skipping 13 matching lines @@
   void _assertResolved(FunctionBody body) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     body.accept(verifier);
     verifier.assertResolved();
   }
 }
 
 @reflectiveTest
 class ResolveUnitTypeNamesTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5);
     expect(outputs[RESOLVED_UNIT5], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT5], isTrue);
   }
 
   test_perform() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class A {}
 class B extends A {}
 int f(String p) => p.length;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5, matcher: isResolveUnitTypeNamesTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     {
       ClassDeclaration nodeA = unit.declarations[0];
@@ skipping 11 matching lines @@
       expect(
           resolutionMap
               .elementDeclaredByFormalParameter(parameters[0])
               .type
               .displayName,
           'String');
     }
   }
 
   test_perform_errors() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 NoSuchClass f() => null;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVE_TYPE_NAMES_ERRORS,
         matcher: isResolveUnitTypeNamesTask);
     // validate
     _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
   }
 
   test_perform_typedef() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 typedef int F(G g);
 typedef String G(int p);
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5, matcher: isResolveUnitTypeNamesTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     FunctionTypeAlias nodeF = unit.declarations[0];
     FunctionTypeAlias nodeG = unit.declarations[1];
     {
@@ skipping 10 matching lines @@
       DartType parameterType =
           resolutionMap.elementDeclaredByFormalParameter(parameter).type;
       expect(
           resolutionMap.typeForTypeName(nodeG.returnType).element.displayName,
           'String');
       expect(parameterType.element.displayName, 'int');
     }
   }
 
   test_perform_typedef_errors() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 typedef int F(NoSuchType p);
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVE_TYPE_NAMES_ERRORS,
         matcher: isResolveUnitTypeNamesTask);
     // validate
     _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
   }
 }
 
 @reflectiveTest
 class ResolveVariableReferencesTaskTest extends _AbstractDartTaskTest {
   /**
    * Verify that the mutated states of the given [variable] correspond to the
    * [mutatedInClosure] and [mutatedInScope] matchers.
    */
   void expectMutated(FunctionBody body, VariableElement variable,
       bool mutatedInClosure, bool mutatedInScope) {
     expect(body.isPotentiallyMutatedInClosure(variable), mutatedInClosure);
     expect(body.isPotentiallyMutatedInScope(variable), mutatedInScope);
   }
 
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT6);
     expect(outputs[RESOLVED_UNIT6], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT6], isTrue);
   }
 
   test_perform_buildClosureLibraryElements() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main() {
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT6,
         matcher: isResolveVariableReferencesTask);
   }
 
   test_perform_local() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main() {
   var v1 = 1;
   var v2 = 1;
   var v3 = 1;
   var v4 = 1;
   v2 = 2;
   v4 = 2;
   localFunction() {
     v3 = 3;
     v4 = 3;
@@ skipping 11 matching lines @@
     LocalVariableElement v2 = findLocalVariable(unit, 'v2');
     LocalVariableElement v3 = findLocalVariable(unit, 'v3');
     LocalVariableElement v4 = findLocalVariable(unit, 'v4');
     expectMutated(body, v1, false, false);
     expectMutated(body, v2, false, true);
     expectMutated(body, v3, true, true);
     expectMutated(body, v4, true, true);
   }
 
   test_perform_parameter() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main(p1, p2, p3, p4) {
   p2 = 2;
   p4 = 2;
   localFunction() {
     p3 = 3;
     p4 = 3;
   }
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
@@ skipping 112 matching lines @@
 class StrongModeInferenceTest extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   // Check that even within a static variable cycle, inferred
   // types get propagated to the members of the cycle.
   void test_perform_cycle() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 var piFirst = true;
 var pi = piFirst ? 3.14 : tau / 2;
 var tau = piFirst ? pi * 2 : 6.28;
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT11);
     CompilationUnit unit = outputs[RESOLVED_UNIT11];
     VariableElement piFirst =
         AstFinder.getTopLevelVariable(unit, 'piFirst').name.staticElement;
     VariableElement pi =
         AstFinder.getTopLevelVariable(unit, 'pi').name.staticElement;
     VariableElement tau =
         AstFinder.getTopLevelVariable(unit, 'tau').name.staticElement;
     Expression piFirstUse = (AstFinder
             .getTopLevelVariable(unit, 'tau')
             .initializer as ConditionalExpression)
         .condition;
 
     expect(piFirstUse.staticType, context.typeProvider.boolType);
     expect(piFirst.type, context.typeProvider.boolType);
     expect(pi.type.isDynamic, isTrue);
     expect(tau.type.isDynamic, isTrue);
   }
 
   void test_perform_inference_cross_unit_cyclic() {
-    AnalysisTarget firstSource = newSource(
-        '/a.dart',
-        '''
+    AnalysisTarget firstSource = newSource('/a.dart', '''
           import 'test.dart';
           var x = 2;
           class A { static var x = 2; }
 ''');
-    AnalysisTarget secondSource = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget secondSource = newSource('/test.dart', '''
           import 'a.dart';
           var y = x;
           class B { static var y = A.x; }
 
           test1() {
             int t = 3;
             t = x;
             t = y;
             t = A.x;
             t = B.y;
@@ skipping 112 matching lines @@
         intType);
     assertVariableDeclarationStatementTypes(
         AstFinder.getStatementsInTopLevelFunction(unit2, "foo")[0],
         stringType,
         intType);
   }
 
   // Test inference interactions between local variables and top level
   // variables
   void test_perform_inference_cross_unit_non_cyclic() {
-    AnalysisTarget firstSource = newSource(
-        '/a.dart',
-        '''
+    AnalysisTarget firstSource = newSource('/a.dart', '''
           var x = 2;
           class A { static var x = 2; }
 ''');
-    AnalysisTarget secondSource = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget secondSource = newSource('/test.dart', '''
           import 'a.dart';
           var y = x;
           class B { static var y = A.x; }
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = /*severe:StaticTypeError*/"hi";
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = /*severe:StaticTypeError*/"hi";
           }
@@ skipping 73 matching lines @@
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit2, "test1");
 
     assertAssignmentStatementTypes(statements[1], intType, intType);
     assertAssignmentStatementTypes(statements[2], intType, dynamicType);
   }
 
   // Test inference across units (non-cyclic)
   void test_perform_inference_local_variables() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
       test() {
         int x = 3;
         x = "hi";
         var y = 3;
         y = "hi";
       }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT11);
     CompilationUnit unit = outputs[RESOLVED_UNIT11];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "test");
 
     assertVariableDeclarationStatementTypes(statements[0], intType, intType);
     assertAssignmentStatementTypes(statements[1], intType, stringType);
     assertVariableDeclarationStatementTypes(statements[2], intType, intType);
     assertAssignmentStatementTypes(statements[3], intType, stringType);
   }
 
   // Test inference across units (cyclic)
   void test_perform_inference_local_variables_fields() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
       class A {
         int x = 0;
 
         test1() {
           var a = x;
           a = "hi";
           a = 3;
           var b = y;
           b = "hi";
           b = 4;
@@ skipping 28 matching lines @@
     assertAssignmentStatementTypes(statements[8], intType, intType);
 
     assertVariableDeclarationTypes(
         AstFinder.getFieldInClass(unit, "A", "x"), intType, intType);
     assertVariableDeclarationTypes(
         AstFinder.getFieldInClass(unit, "A", "z"), intType, intType);
   }
 
   // Test inference of instance fields across units
   void test_perform_inference_local_variables_topLevel() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
       int x = 0;
 
       test1() {
         var a = x;
         a = /*severe:StaticTypeError*/"hi";
         a = 3;
         var b = y;
         b = /*severe:StaticTypeError*/"hi";
         b = 4;
         var c = z;
@@ skipping 28 matching lines @@
     assertVariableDeclarationTypes(
         AstFinder.getTopLevelVariable(unit, "x"), intType, intType);
     assertVariableDeclarationTypes(
         AstFinder.getTopLevelVariable(unit, "y"), intType, intType);
     assertVariableDeclarationTypes(
         AstFinder.getTopLevelVariable(unit, "z"), intType, intType);
   }
 
   // Test inference between static and instance fields
   void test_perform_inference_null() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
       var x = null;
       var y = 3;
       class A {
         static var x = null;
         static var y = 3;
 
         var x2 = null;
         var y2 = 3;
       }
 
@@ skipping 33 matching lines @@
     assertAssignmentStatementTypes(statements[0], dynamicType, stringType);
     assertAssignmentStatementTypes(statements[1], intType, stringType);
     assertAssignmentStatementTypes(statements[2], dynamicType, stringType);
     assertAssignmentStatementTypes(statements[3], intType, stringType);
     assertAssignmentStatementTypes(statements[4], dynamicType, stringType);
     assertAssignmentStatementTypes(statements[5], intType, stringType);
   }
 
   // Test inference between fields and method bodies
   void test_perform_local_explicit_disabled() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
       test() {
         int x = 3;
         x = "hi";
       }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT11);
     CompilationUnit unit = outputs[RESOLVED_UNIT11];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
@@ skipping 15 matching lines @@
 
 @reflectiveTest
 class StrongModeVerifyUnitTaskTest extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   test_created_resolved_unit() {
-    Source source = newSource(
-        '/test.dart',
-        r'''
+    Source source = newSource('/test.dart', r'''
 library lib;
 class A {}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT);
     expect(outputs[RESOLVED_UNIT], isNotNull);
     expect(outputs[CREATED_RESOLVED_UNIT], isTrue);
   }
 
   void test_perform_recordDynamicInvoke() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 void main() {
   dynamic a = [];
   a[0];
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), STRONG_MODE_ERRORS);
     CompilationUnit unit = outputs[RESOLVED_UNIT];
 
     // validate
     _fillErrorListener(STRONG_MODE_ERRORS);
     expect(errorListener.errors, isEmpty);
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     ExpressionStatement statement = statements[1];
     IndexExpression idx = statement.expression;
     expect(strong_ast.isDynamicInvoke(idx.target), isTrue);
   }
 
   void test_perform_verifyError() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 class A {}
 class B extends A {}
 B b = new A();
 ''');
     computeResult(new LibrarySpecificUnit(source, source), STRONG_MODE_ERRORS);
     // validate
     _fillErrorListener(STRONG_MODE_ERRORS);
 
     var errors = errorListener.errors;
     expect(errors.length, 1);
     expect(errors[0].errorCode.name, "STRONG_MODE_INVALID_CAST_NEW_EXPR");
   }
 }
 
 @reflectiveTest
 class VerifyUnitTaskTest extends _AbstractDartTaskTest {
   test_perform_constantError() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main(int p) {
   const v = p;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[
       CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
     ]);
   }
 
   test_perform_ConstantValidator_declaredIdentifier() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 void main() {
   for (const foo in []) {
     print(foo);
   }
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertNoErrors();
   }
 
   test_perform_ConstantValidator_dependencyCycle() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const int a = b;
 const int b = c;
 const int c = a;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[
       CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT,
       CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT,
       CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT
     ]);
   }
 
   test_perform_ConstantValidator_duplicateFields() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 class Test {
   final int x = 1;
   final int x = 2;
   const Test();
 }
 
 main() {
   const Test();
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
   }
 
   test_perform_ConstantValidator_noInitializer() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 const x;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
   }
 
   test_perform_ConstantValidator_unknownValue() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 import 'no-such-file.dart' as p;
 
 const int x = p.y;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[
       CompileTimeErrorCode.URI_DOES_NOT_EXIST,
       CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
     ]);
   }
 
   test_perform_directiveError_generated() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 import 'generated-file.g.dart';
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[CompileTimeErrorCode.URI_HAS_NOT_BEEN_GENERATED]);
   }
 
   test_perform_directiveError_nonGenerated() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 import 'no-such-file.dart';
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
   void test_perform_reresolution() {
     enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
+    AnalysisTarget source = newSource('/test.dart', '''
 const topLevel = 3;
 class C {
   String field = topLevel;
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), VERIFY_ERRORS);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
 
     var errors = errorListener.errors;
     expect(errors.length, 1);
     expect(errors[0].errorCode, StaticTypeWarningCode.INVALID_ASSIGNMENT);
   }
 
   test_perform_verifyError() {
-    Source source = newSource(
-        '/test.dart',
-        '''
+    Source source = newSource('/test.dart', '''
 main() {
   if (42) {
     print('Not bool!');
   }
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
@@ skipping 116 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result] as List<AnalysisError>;
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }