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

pkg/analyzer/test/src/dart/analysis/driver_test.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 345 matching lines @@
     driver.removeFile(a);
     expect(driver.addedFiles, isNot(contains(a)));
     expect(driver.addedFiles, isNot(contains(b)));
   }
 
   test_addFile_shouldRefresh() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
 
     provider.newFile(a, 'class A {}');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
 
     void assertNumberOfErrorsInB(int n) {
       var bResult = allResults.singleWhere((r) => r.path == b);
       expect(bResult.errors, hasLength(n));
       allResults.clear();
     }
 
     // Initial analysis, 'b' does not use 'a', so there is a hint.
     await scheduler.waitForIdle();
     assertNumberOfErrorsInB(1);
 
     // Update 'b' to use 'a', no more hints.
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 main() {
   print(A);
 }
 ''');
     driver.changeFile(b);
     await scheduler.waitForIdle();
     assertNumberOfErrorsInB(0);
 
     // Change 'b' content so that it has a hint.
     // Remove 'b' and add it again.
     // The file 'b' must be refreshed, and the hint must be reported.
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 ''');
     driver.removeFile(b);
     driver.addFile(b);
     await scheduler.waitForIdle();
     assertNumberOfErrorsInB(1);
   }
 
   test_addFile_thenRemove() async {
     var a = _p('/test/lib/a.dart');
@@ skipping 10 matching lines @@
 
     // Only 'b' has been analyzed, because 'a' was removed before we started.
     expect(allResults, hasLength(1));
     expect(allResults[0].path, b);
   }
 
   test_analyze_resolveDirectives() async {
     var lib = _p('/test/lib.dart');
     var part1 = _p('/test/part1.dart');
     var part2 = _p('/test/part2.dart');
-    provider.newFile(
-        lib,
-        '''
+    provider.newFile(lib, '''
 library lib;
 part 'part1.dart';
 part 'part2.dart';
 ''');
-    provider.newFile(
-        part1,
-        '''
+    provider.newFile(part1, '''
 part of lib;
 ''');
-    provider.newFile(
-        part2,
-        '''
+    provider.newFile(part2, '''
 part of 'lib.dart';
 ''');
 
     AnalysisResult libResult = await driver.getResult(lib);
     AnalysisResult partResult1 = await driver.getResult(part1);
     AnalysisResult partResult2 = await driver.getResult(part2);
 
     CompilationUnit libUnit = libResult.unit;
     CompilationUnit partUnit1 = partResult1.unit;
     CompilationUnit partUnit2 = partResult2.unit;
@@ skipping 21 matching lines @@
 
     {
       var partOf = partUnit2.directives.single as PartOfDirective;
       expect(partOf.element, libraryElement);
     }
   }
 
   test_analyze_resolveDirectives_error_missingLibraryDirective() async {
     var lib = _p('/test/lib.dart');
     var part = _p('/test/part.dart');
-    provider.newFile(
-        lib,
-        '''
+    provider.newFile(lib, '''
 part 'part.dart';
 ''');
-    provider.newFile(
-        part,
-        '''
+    provider.newFile(part, '''
 part of lib;
 ''');
 
     driver.addFile(lib);
 
     AnalysisResult libResult = await driver.getResult(lib);
     List<AnalysisError> errors = libResult.errors;
     if (libResult.unit.element.context.analysisOptions.enableUriInPartOf) {
       expect(errors, hasLength(1));
       expect(errors[0].errorCode, ResolverErrorCode.PART_OF_UNNAMED_LIBRARY);
     } else {
       expect(errors, hasLength(1));
       expect(errors[0].errorCode,
           ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART);
     }
   }
 
   test_analyze_resolveDirectives_error_partOfDifferentLibrary_byName() async {
     var lib = _p('/test/lib.dart');
     var part = _p('/test/part.dart');
-    provider.newFile(
-        lib,
-        '''
+    provider.newFile(lib, '''
 library lib;
 part 'part.dart';
 ''');
-    provider.newFile(
-        part,
-        '''
+    provider.newFile(part, '''
 part of someOtherLib;
 ''');
 
     driver.addFile(lib);
 
     AnalysisResult libResult = await driver.getResult(lib);
     List<AnalysisError> errors = libResult.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY);
   }
 
   test_analyze_resolveDirectives_error_partOfDifferentLibrary_byUri() async {
     var lib = _p('/test/lib.dart');
     var part = _p('/test/part.dart');
-    provider.newFile(
-        lib,
-        '''
+    provider.newFile(lib, '''
 library lib;
 part 'part.dart';
 ''');
-    provider.newFile(
-        part,
-        '''
+    provider.newFile(part, '''
 part of 'other_lib.dart';
 ''');
 
     driver.addFile(lib);
 
     AnalysisResult libResult = await driver.getResult(lib);
     List<AnalysisError> errors = libResult.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY);
   }
 
   test_analyze_resolveDirectives_error_partOfNonPart() async {
     var lib = _p('/test/lib.dart');
     var part = _p('/test/part.dart');
-    provider.newFile(
-        lib,
-        '''
+    provider.newFile(lib, '''
 library lib;
 part 'part.dart';
 ''');
-    provider.newFile(
-        part,
-        '''
+    provider.newFile(part, '''
 // no part of directive
 ''');
 
     driver.addFile(lib);
 
     AnalysisResult libResult = await driver.getResult(lib);
     List<AnalysisError> errors = libResult.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, CompileTimeErrorCode.PART_OF_NON_PART);
   }
@@ skipping 81 matching lines @@
     expect(driver.test.priorityResults, isEmpty);
 
     // The file is not priority, so its result is not cached.
     AnalysisResult result2 = await driver.getResult(a);
     expect(result2, isNot(same(result1)));
   }
 
   test_changeFile_implicitlyAnalyzed() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'b.dart';
 var A = B;
 ''');
     provider.newFile(b, 'var B = 1;');
 
     driver.priorityFiles = [a];
     driver.addFile(a);
 
     // We have a result only for "a".
     await scheduler.waitForIdle();
@@ skipping 39 matching lines @@
     await scheduler.waitForIdle();
     expect(allResults, isEmpty);
 
     // This should not add "b" to the file state.
     expect(driver.fsState.knownFilePaths, isNot(contains(b)));
   }
 
   test_changeFile_selfConsistent() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'b.dart';
 var A1 = 1;
 var A2 = B1;
 ''');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 var B1 = A1;
 ''');
 
     driver.priorityFiles = [a, b];
     driver.addFile(a);
     driver.addFile(b);
     await scheduler.waitForIdle();
 
     // We have results for both "a" and "b".
     expect(allResults, hasLength(2));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A1'), 'int');
       expect(_getTopLevelVarType(ar.unit, 'A2'), 'int');
     }
     {
       AnalysisResult br = allResults.firstWhere((r) => r.path == b);
       expect(_getTopLevelVarType(br.unit, 'B1'), 'int');
     }
 
     // Clear the results and update "a".
     allResults.clear();
-    provider.updateFile(
-        a,
-        r'''
+    provider.updateFile(a, r'''
 import 'b.dart';
 var A1 = 1.2;
 var A2 = B1;
 ''');
     driver.changeFile(a);
 
     // We again get results for both "a" and "b".
     // The results are consistent.
     await scheduler.waitForIdle();
     expect(allResults, hasLength(2));
@@ skipping 169 matching lines @@
 import 'foo.dart';
 ''');
 
     AnalysisResult result = await driver.getResult(testFile);
     List<AnalysisError> errors = result.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, CompileTimeErrorCode.URI_DOES_NOT_EXIST);
   }
 
   test_errors_uriDoesNotExist_import_deferred() async {
-    addTestFile(
-        r'''
+    addTestFile(r'''
 import 'foo.dart' deferred as foo;
 main() {
   foo.loadLibrary();
 }
-''',
-        priority: true);
+''', priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     List<AnalysisError> errors = result.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, CompileTimeErrorCode.URI_DOES_NOT_EXIST);
   }
 
   test_errors_uriDoesNotExist_part() async {
     addTestFile(r'''
 library lib;
 part 'foo.dart';
 ''');
 
     AnalysisResult result = await driver.getResult(testFile);
     List<AnalysisError> errors = result.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, CompileTimeErrorCode.URI_DOES_NOT_EXIST);
   }
 
   test_externalSummaries() async {
     var a = _p('/a.dart');
     var b = _p('/b.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 class A {}
 ''');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 var a = new A();
 ''');
 
     // Prepare the store with a.dart and everything it needs.
     SummaryDataStore summaryStore =
         createAnalysisDriver().test.getSummaryStore(a);
 
     // There are at least a.dart and dart:core libraries.
     String aUri = provider.pathContext.toUri(a).toString();
@@ skipping 11 matching lines @@
         createAnalysisDriver(externalSummaries: summaryStore);
     AnalysisResult result = await driver.getResult(b);
     expect(result.errors, isEmpty);
   }
 
   test_generatedFile() async {
     Uri uri = Uri.parse('package:aaa/foo.dart');
     String templatePath = _p('/aaa/lib/foo.dart');
     String generatedPath = _p('/generated/aaa/lib/foo.dart');
 
-    provider.newFile(
-        templatePath,
-        r'''
+    provider.newFile(templatePath, r'''
 a() {}
 b() {}
 ''');
 
-    provider.newFile(
-        generatedPath,
-        r'''
+    provider.newFile(generatedPath, r'''
 aaa() {}
 bbb() {}
 ''');
 
     Source generatedSource = new _SourceMock();
     when(generatedSource.uri).thenReturn(uri);
     when(generatedSource.fullName).thenReturn(generatedPath);
 
     when(generatedUriResolver.resolveAbsolute(uri, uri))
         .thenReturn(generatedSource);
@@ skipping 122 matching lines @@
 
     AnalysisDriverUnitIndex index = await driver.getIndex(testFile);
 
     int unitId = index.strings.indexOf('package:test/test.dart');
     int fooId = index.strings.indexOf('foo');
     expect(unitId, isNonNegative);
     expect(fooId, isNonNegative);
   }
 
   test_getLibraryByUri_external_resynthesize() async {
-    provider.newFile(
-        testFile,
-        r'''
+    provider.newFile(testFile, r'''
 class Test {}
 ''');
 
     // Prepare the store with package:test/test.dart URI.
     SummaryDataStore summaryStore =
         createAnalysisDriver().test.getSummaryStore(testFile);
 
     // package:test/test.dart is in the store.
     String uri = 'package:test/test.dart';
     expect(summaryStore.unlinkedMap.keys, contains(uri));
@@ skipping 58 matching lines @@
 
     // The same result is also received through the stream.
     await scheduler.waitForIdle();
     expect(allResults, [result]);
   }
 
   test_getResult_constants_defaultParameterValue_localFunction() async {
     var a = _p('/test/bin/a.dart');
     var b = _p('/test/bin/b.dart');
     provider.newFile(a, 'const C = 42;');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 main() {
   foo({int p: C}) {}
   foo();
 }
 ''');
     driver.addFile(a);
     driver.addFile(b);
     await scheduler.waitForIdle();
 
@@ skipping 68 matching lines @@
     addTestFile(content, priority: true);
 
     var result = await driver.getResult(testFile);
     expect(result.errors, isEmpty);
   }
 
   test_getResult_importLibrary_thenRemoveIt() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     provider.newFile(a, 'class A {}');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 class B extends A {}
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     await scheduler.waitForIdle();
 
     // No errors in b.dart
     {
@@ skipping 19 matching lines @@
     driver.addFile(a);
 
     // No errors in b.dart again.
     {
       AnalysisResult result = await driver.getResult(b);
       expect(result.errors, isEmpty);
     }
   }
 
   test_getResult_inferTypes_finalField() async {
-    addTestFile(
-        r'''
+    addTestFile(r'''
 class C {
   final f = 42;
 }
-''',
-        priority: true);
+''', priority: true);
     await scheduler.waitForIdle();
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(_getClassFieldType(result.unit, 'C', 'f'), 'int');
   }
 
   test_getResult_inferTypes_instanceMethod() async {
-    addTestFile(
-        r'''
+    addTestFile(r'''
 class A {
   int m(double p) => 1;
 }
 class B extends A {
   m(double p) => 2;
 }
-''',
-        priority: true);
+''', priority: true);
     await scheduler.waitForIdle();
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(_getClassMethodReturnType(result.unit, 'A', 'm'), 'int');
     expect(_getClassMethodReturnType(result.unit, 'B', 'm'), 'int');
   }
 
   test_getResult_invalid_annotation_functionAsConstructor() async {
-    addTestFile(
-        r'''
+    addTestFile(r'''
 fff() {}
 
 @fff()
 class C {}
-''',
-        priority: true);
+''', priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     ClassDeclaration c = result.unit.declarations[1] as ClassDeclaration;
     Annotation a = c.metadata[0];
     expect(a.name.name, 'fff');
     expect(a.name.staticElement, new isInstanceOf<FunctionElement>());
   }
 
   test_getResult_invalidUri() async {
     String content = r'''
@@ skipping 72 matching lines @@
 ''';
     addTestFile(content);
     await driver.getResult(testFile);
   }
 
   test_getResult_mix_fileAndPackageUris() async {
     var a = _p('/test/bin/a.dart');
     var b = _p('/test/bin/b.dart');
     var c = _p('/test/lib/c.dart');
     var d = _p('/test/test/d.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'package:test/c.dart';
 int x = y;
 ''');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import '../lib/c.dart';
 int x = y;
 ''');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 import '../test/d.dart';
 var y = z;
 ''');
-    provider.newFile(
-        d,
-        r'''
+    provider.newFile(d, r'''
 String z = "string";
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
     driver.addFile(d);
 
     // Analysis of my_pkg/bin/a.dart produces no error because
     // file:///my_pkg/bin/a.dart imports package:my_pkg/c.dart, and
@@ skipping 58 matching lines @@
     addTestFile(content);
     // Should not throw exceptions.
     await driver.getResult(testFile);
   }
 
   test_getResult_sameFile_twoUris() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/test/c.dart');
     provider.newFile(a, 'class A<T> {}');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 var VB = new A<int>();
 ''');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 import '../lib/a.dart';
 var VC = new A<double>();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     await scheduler.waitForIdle();
 
     {
       AnalysisResult result = await driver.getResult(b);
       expect(_getImportSource(result.unit, 0).uri.toString(),
           'package:test/a.dart');
       expect(_getTopLevelVarType(result.unit, 'VB'), 'A<int>');
     }
 
     {
       AnalysisResult result = await driver.getResult(c);
       expect(_getImportSource(result.unit, 0).uri,
           provider.pathContext.toUri(_p('/test/lib/a.dart')));
       expect(_getTopLevelVarType(result.unit, 'VC'), 'A<double>');
     }
   }
 
   test_getResult_selfConsistent() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'b.dart';
 var A1 = 1;
 var A2 = B1;
 ''');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 import 'a.dart';
 var B1 = A1;
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     await scheduler.waitForIdle();
 
     {
       AnalysisResult result = await driver.getResult(a);
       expect(_getTopLevelVarType(result.unit, 'A1'), 'int');
       expect(_getTopLevelVarType(result.unit, 'A2'), 'int');
     }
 
     // Update "a" so that "A1" is now "double".
     // Get result for "a".
     //
     // We get "double" for "A2", even though "A2" has the type from "b".
     // That's because we check for "a" API signature consistency, and because
     // it has changed, we invalidated the dependency cache, relinked libraries
     // and recomputed types.
-    provider.updateFile(
-        a,
-        r'''
+    provider.updateFile(a, r'''
 import 'b.dart';
 var A1 = 1.2;
 var A2 = B1;
 ''');
     driver.changeFile(a);
 
     {
       AnalysisResult result = await driver.getResult(a);
       expect(_getTopLevelVarType(result.unit, 'A1'), 'double');
       expect(_getTopLevelVarType(result.unit, 'A2'), 'double');
@@ skipping 75 matching lines @@
 
     _assertTopLevelDeclarations(
         await driver.getTopLevelNameDeclarations('X'), [], []);
   }
 
   test_getTopLevelNameDeclarations_parts() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
 
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library lib;
 part 'b.dart';
 part 'c.dart';
 class A {}
 ''');
     provider.newFile(b, 'part of lib; class B {}');
     provider.newFile(c, 'part of lib; class C {}');
 
     driver.addFile(a);
     driver.addFile(b);
@@ skipping 85 matching lines @@
 
     // Request of referenced names is not analysis of a file.
     driver.getFilesReferencingName('X');
     expect(driver.hasFilesToAnalyze, isFalse);
   }
 
   test_hermetic_modifyLibraryFile_resolvePart() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
 
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 part 'b.dart';
 class C {
   int foo;
 }
 ''');
-    provider.newFile(
-        b,
-        r'''
+    provider.newFile(b, r'''
 part of a;
 var c = new C();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
 
     await driver.getResult(b);
 
     // Modify the library, but don't notify the driver.
     // The driver should use the previous library content and elements.
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 part 'b.dart';
 class C {
   int bar;
 }
 ''');
 
     var result = await driver.getResult(b);
     var c = _getTopLevelVar(result.unit, 'c');
     var typeC = c.element.type as InterfaceType;
@@ skipping 19 matching lines @@
     AnalysisResult result = await driver.getResult(a);
     expect(result.errors, isEmpty);
     expect(_getTopLevelVarType(result.unit, 'b'), 'B');
   }
 
   test_knownFiles() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
 
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'b.dart';
 ''');
     provider.newFile(b, '');
     provider.newFile(c, '');
 
     driver.addFile(a);
     driver.addFile(c);
     await scheduler.waitForIdle();
 
     expect(driver.knownFiles, contains(a));
@@ skipping 51 matching lines @@
 
     ParseResult parseResult = await driver.parseFile(p);
     var clazz = parseResult.unit.declarations[0] as ClassDeclaration;
     expect(clazz.name.name, 'A2');
   }
 
   test_part_getErrors_afterLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
 
     // Process a.dart so that we know that it's a library for c.dart later.
     {
       ErrorsResult result = await driver.getErrors(a);
       expect(result.errors, isEmpty);
     }
 
     // c.dart does not have errors in the context of a.dart
     {
       ErrorsResult result = await driver.getErrors(c);
       expect(result.errors, isEmpty);
     }
   }
 
   test_part_getErrors_beforeLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
 
     // c.dart is resolve in the context of a.dart, so have no errors
     {
       ErrorsResult result = await driver.getErrors(c);
       expect(result.errors, isEmpty);
     }
   }
 
   test_part_getResult_afterLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
 
@@ skipping 10 matching lines @@
       expect(result.errors, isEmpty);
       expect(_getTopLevelVarType(result.unit, 'a'), 'A');
       expect(_getTopLevelVarType(result.unit, 'b'), 'B');
     }
   }
 
   test_part_getResult_beforeLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
 
     // b.dart will be analyzed after a.dart is analyzed.
     // So, A and B references are resolved.
     AnalysisResult result = await driver.getResult(c);
     expect(result.errors, isEmpty);
     expect(_getTopLevelVarType(result.unit, 'a'), 'A');
     expect(_getTopLevelVarType(result.unit, 'b'), 'B');
   }
 
   test_part_getResult_noLibrary() async {
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(c);
 
     // There is no library which c.dart is a part of, so it has unresolved
     // A and B references.
     AnalysisResult result = await driver.getResult(c);
     expect(result.errors, isNotEmpty);
     expect(result.unit, isNotNull);
   }
 
   test_part_results_afterLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     // The order is important for creating the test case.
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
@@ skipping 19 matching lines @@
       AnalysisResult result = allResults.lastWhere((r) => r.path == c);
       expect(result.errors, isNotEmpty);
       expect(result.unit, isNull);
     }
   }
 
   test_part_results_beforeLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     // The order is important for creating the test case.
     driver.addFile(c);
     driver.addFile(a);
     driver.addFile(b);
 
     await scheduler.waitForIdle();
 
     // c.dart was added before a.dart, so we attempt to analyze it before
     // a.dart, but we cannot find the library for it, so we delay analysis
     // until all other files are analyzed, including a.dart, after which we
     // analyze the delayed parts.
     AnalysisResult result = allResults.lastWhere((r) => r.path == c);
     expect(result.errors, isEmpty);
     expect(result.unit, isNull);
   }
 
   test_part_results_noLibrary() async {
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(c);
 
     await scheduler.waitForIdle();
 
     // There is no library which c.dart is a part of, so it has unresolved
     // A and B references.
     AnalysisResult result = allResults.lastWhere((r) => r.path == c);
     expect(result.errors, isNotEmpty);
     expect(result.unit, isNull);
   }
 
   test_part_results_priority_beforeLibrary() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 library a;
 import 'b.dart';
 part 'c.dart';
 class A {}
 var c = new C();
 ''');
     provider.newFile(b, 'class B {}');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     // The order is important for creating the test case.
     driver.priorityFiles = [c];
     driver.addFile(c);
     driver.addFile(a);
     driver.addFile(b);
 
     await scheduler.waitForIdle();
 
     // c.dart was added before a.dart, so we attempt to analyze it before
     // a.dart, but we cannot find the library for it, so we delay analysis
     // until all other files are analyzed, including a.dart, after which we
     // analyze the delayed parts.
     AnalysisResult result = allResults.lastWhere((r) => r.path == c);
     expect(result.errors, isEmpty);
     expect(result.unit, isNotNull);
   }
 
   test_removeFile_changeFile_implicitlyAnalyzed() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'b.dart';
 var A = B;
 ''');
     provider.newFile(b, 'var B = 1;');
 
     driver.priorityFiles = [a, b];
     driver.addFile(a);
     driver.addFile(b);
 
     // We have results for both "a" and "b".
@@ skipping 67 matching lines @@
     allResults.clear();
   }
 
   test_results_order() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
     var d = _p('/test/lib/d.dart');
     var e = _p('/test/lib/e.dart');
     var f = _p('/test/lib/f.dart');
-    provider.newFile(
-        a,
-        r'''
+    provider.newFile(a, r'''
 import 'd.dart';
 ''');
     provider.newFile(b, '');
-    provider.newFile(
-        c,
-        r'''
+    provider.newFile(c, r'''
 import 'd.dart';
 ''');
-    provider.newFile(
-        d,
-        r'''
+    provider.newFile(d, r'''
 import 'b.dart';
 ''');
-    provider.newFile(
-        e,
-        r'''
+    provider.newFile(e, r'''
 export 'b.dart';
 ''');
-    provider.newFile(
-        f,
-        r'''
+    provider.newFile(f, r'''
 import 'e.dart';
 class F extends X {}
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
     driver.addFile(d);
     driver.addFile(e);
     driver.addFile(f);
@@ skipping 300 matching lines @@
     expect(() {
       driver.changeFile(path);
     }, throwsStateError);
   }
 
   test_getResult_libraryUnits() async {
     var lib = _p('/lib.dart');
     var part1 = _p('/part1.dart');
     var part2 = _p('/part2.dart');
 
-    provider.newFile(
-        lib,
-        r'''
+    provider.newFile(lib, r'''
 library test;
 part 'part1.dart';
 part 'part2.dart';
 ''');
     provider.newFile(part1, 'part of test; class A {}');
     provider.newFile(part2, 'part of test; class B {}');
 
     driver.addFile(lib);
     driver.addFile(part1);
     driver.addFile(part2);
@@ skipping 48 matching lines @@
     var path = _p('/test.dart');
     expect(() {
       driver.removeFile(path);
     }, throwsStateError);
   }
 
   String _p(String path) => provider.convertPath(path);
 }
 
 class _SourceMock extends TypedMock implements Source {}