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

pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/provisional/completion/dart/completion_dart.dart';
 import 'package:analysis_server/src/services/completion/dart/imported_reference_contributor.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:test/test.dart';
@@ skipping 14 matching lines @@
 
   @override
   DartCompletionContributor createContributor() {
     return new ImportedReferenceContributor();
   }
 
   /// Sanity check.  Permutations tested in local_ref_contributor.
   test_ArgDefaults_function_with_required_named() async {
     addMetaPackageSource();
 
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib B;
 import 'package:meta/meta.dart';
 
 bool foo(int bar, {bool boo, @required int baz}) => false;
 ''');
 
     addTestSource('''
 import "/testB.dart";
 
 void main() {f^}''');
     await computeSuggestions();
 
     assertSuggestFunction('foo', 'bool',
         defaultArgListString: 'bar, baz: null');
   }
 
   test_ArgumentList() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import '/libA.dart';
         class B { }
         String bar() => true;
         void main() {expect(^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertSuggestFunction('hasLength', 'bool');
     assertSuggestFunction('identical', 'bool');
     assertNotSuggested('B');
     assertSuggestClass('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_imported_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         expect(arg) { }
         void baz() { }''');
     addTestSource('''
         import '/libA.dart'
         class B { }
         String bar() => true;
         void main() {expect(^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertSuggestFunction('hasLength', 'bool');
     assertSuggestFunction('identical', 'bool');
     assertNotSuggested('B');
     assertSuggestClass('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_InstanceCreationExpression_functionalArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import 'dart:async';
         import '/libA.dart';
         class B { }
         String bar() => true;
         void main() {new A(^)}''');
@@ skipping 10 matching lines @@
     assertNotSuggested('B');
     assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
     assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_InstanceCreationExpression_typedefArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         typedef Funct();
         class A { A(Funct f) { } }
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import 'dart:async';
         import '/libA.dart';
         class B { }
         String bar() => true;
@@ skipping 11 matching lines @@
     assertNotSuggested('B');
     assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
     assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_local_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import '/libA.dart'
         expect(arg) { }
         class B { }
         String bar() => true;
         void main() {expect(^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertSuggestFunction('hasLength', 'bool');
     assertSuggestFunction('identical', 'bool');
     assertNotSuggested('B');
     assertSuggestClass('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_local_method() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import '/libA.dart'
         class B {
           expect(arg) { }
           void foo() {expect(^)}}
         String bar() => true;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertSuggestFunction('hasLength', 'bool');
     assertSuggestFunction('identical', 'bool');
     assertNotSuggested('B');
     assertSuggestClass('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_MethodInvocation_functionalArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import 'dart:async';
         import '/libA.dart';
         class B { }
         String bar(f()) => true;
         void main() {bar(^);}''');
@@ skipping 10 matching lines @@
     assertNotSuggested('B');
     assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
     assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_MethodInvocation_methodArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
         void baz() { }''');
     addTestSource('''
         import 'dart:async';
         import '/libA.dart';
         class B { String bar(f()) => true; }
         void main() {new B().bar(^);}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertSuggestFunction('hasLength', 'bool',
         kind: CompletionSuggestionKind.IDENTIFIER);
     assertSuggestFunction('identical', 'bool',
         kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('B');
     assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
     assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_namedParam() async {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }''');
     addTestSource('''
         import '/libA.dart'
         String bar() => true;
         void main() {expect(foo: ^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
@@ skipping 17 matching lines @@
     expect(replacementLength, 0);
     assertNotSuggested('b');
     assertNotSuggested('_c');
     assertSuggestClass('Object');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_AsExpression_type_subtype_extends_filter() async {
     // SimpleIdentifier  TypeName  AsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
           foo() { }
           class A {} class B extends A {} class C extends B {}
           class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
           import "/testB.dart";
          main(){A a; if (a as ^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('B');
     assertSuggestClass('C');
     assertNotSuggested('A');
     assertNotSuggested('X');
     assertNotSuggested('Object');
     assertNotSuggested('a');
     assertNotSuggested('main');
   }
 
   test_AsExpression_type_subtype_implements_filter() async {
     // SimpleIdentifier  TypeName  AsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
           foo() { }
           class A {} class B implements A {} class C implements B {}
           class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
           import "/testB.dart";
           main(){A a; if (a as ^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
@@ skipping 128 matching lines @@
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('a');
     assertNotSuggested('main');
     assertNotSuggested('A');
     assertSuggestClass('Object');
   }
 
   test_AwaitExpression_function() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 Future y() async {return 0;}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   int x;
   foo() async {await ^}
 }
 ''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestFunction('y', 'dynamic');
     assertNotSuggested('A');
     assertSuggestClass('Object');
   }
 
   test_AwaitExpression_inherited() async {
     // SimpleIdentifier  AwaitExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib libB;
 class A {
   Future y() async { return 0; }
 }''');
     addTestSource('''
 import "/testB.dart";
 class B extends A {
   foo() async {await ^}
 }
 ''');
@@ skipping 30 matching lines @@
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('a');
     assertSuggestClass('Object');
     assertNotSuggested('b');
     assertNotSuggested('==');
   }
 
   test_Block() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g;
         int T5;
         var _T6;
@@ skipping 65 matching lines @@
     assertNotSuggested('blog');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
     assertSuggestClass('Uri');
     assertNotSuggested('parseIPv6Address');
     assertNotSuggested('parseHex');
   }
 
   test_Block_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g;
         int T5;
         var _T6;
@@ skipping 78 matching lines @@
 
   test_Block_final3() async {
     addTestSource('main() {final ^ v;}');
 
     await computeSuggestions();
     assertSuggestClass('String');
   }
 
   test_Block_final_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g hide G;
         int T5;
         var _T6;
@@ skipping 66 matching lines @@
     assertNotSuggested('blog');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
     assertSuggestClass('Uri');
     assertNotSuggested('parseIPv6Address');
     assertNotSuggested('parseHex');
   }
 
   test_Block_final_var() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g;
         int T5;
         var _T6;
@@ skipping 63 matching lines @@
     assertNotSuggested('clog');
     assertNotSuggested('blog');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
     assertSuggestClass('Uri');
     assertNotSuggested('parseIPv6Address');
     assertNotSuggested('parseHex');
   }
 
   test_Block_identifier_partial() async {
-    resolveSource(
-        '/testAB.dart',
-        '''
+    resolveSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class DF { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         class D3 { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g;
         int T5;
@@ skipping 43 matching lines @@
     assertNotSuggested('_T4');
     //assertNotSuggested('T5');
     //assertNotSuggested('_T6');
     assertNotSuggested('==');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
   }
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
         class E extends F { var e1; e2() { } }
         class I { int i1; i2() { } }
         class M { var m1; int m2() { } }''');
     addTestSource('''
         import "/testB.dart";
         class A extends E implements I with M {a() {^}}''');
 
     await computeSuggestions();
@@ skipping 33 matching lines @@
     assertNotSuggested('m1');
     assertNotSuggested('f3');
     assertNotSuggested('f4');
     assertNotSuggested('e2');
     assertNotSuggested('f2');
     assertNotSuggested('i2');
     assertNotSuggested('m2');
   }
 
   test_Block_local_function() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g;
         int T5;
         var _T6;
@@ skipping 17 matching lines @@
     expect(replacementLength, 1);
 
     assertNotSuggested('partT8');
     assertNotSuggested('partBoo');
     assertNotSuggested('parseIPv6Address');
     assertNotSuggested('parseHex');
   }
 
   test_Block_partial_results() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
         import "/testAB.dart";
         import "/testCD.dart" hide D;
         import "/testEEF.dart" show EE;
         import "/testG.dart" as g;
         int T5;
         var _T6;
@@ skipping 16 matching lines @@
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     // Not imported, so not suggested
     assertNotSuggested('Foo');
     assertNotSuggested('Foo2');
     assertNotSuggested('Future');
   }
 
   test_CascadeExpression_selector1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "/testB.dart";
         class A {var b; X _c;}
         class X{}
         // looks like a cascade to the parser
         // but the user is trying to get completions for a non-cascade
         main() {A a; a.^.z}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('b');
     assertNotSuggested('_c');
     assertNotSuggested('Object');
     assertNotSuggested('A');
     assertNotSuggested('B');
     assertNotSuggested('X');
     assertNotSuggested('z');
     assertNotSuggested('==');
   }
 
   test_CascadeExpression_selector2() async {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "/testB.dart";
         class A {var b; X _c;}
         class X{}
         main() {A a; a..^z}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 1);
     assertNotSuggested('b');
     assertNotSuggested('_c');
     assertNotSuggested('Object');
     assertNotSuggested('A');
     assertNotSuggested('B');
     assertNotSuggested('X');
     assertNotSuggested('z');
     assertNotSuggested('==');
   }
 
   test_CascadeExpression_selector2_withTrailingReturn() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "/testB.dart";
         class A {var b; X _c;}
         class X{}
         main() {A a; a..^ return}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
@@ skipping 74 matching lines @@
     expect(replacementLength, 0);
     assertNotSuggested('e');
     assertNotSuggested('s');
     assertNotSuggested('a');
     assertSuggestClass('Object');
     assertNotSuggested('x');
   }
 
   test_ClassDeclaration_body() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
         @deprecated class A {^}
         class _B {}
         A T;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('_B');
     CompletionSuggestion suggestionO = assertSuggestClass('Object');
     if (suggestionO != null) {
       expect(suggestionO.element.isDeprecated, isFalse);
       expect(suggestionO.element.isPrivate, isFalse);
     }
     assertNotSuggested('T');
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('x');
   }
 
   test_ClassDeclaration_body_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
         class A {final ^}
         class _B {}
         A T;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('_B');
     assertSuggestClass('Object');
     assertNotSuggested('T');
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('x');
   }
 
   test_ClassDeclaration_body_final_field() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
         class A {final ^ A(){}}
         class _B {}
         A T;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('_B');
     assertSuggestClass('String');
     assertNotSuggested('T');
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('x');
   }
 
   test_ClassDeclaration_body_final_field2() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as Soo;
         class A {final S^ A();}
         class _B {}
         A Sew;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('A');
     assertNotSuggested('_B');
     assertSuggestClass('String');
     assertNotSuggested('Sew');
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('Soo');
   }
 
   test_ClassDeclaration_body_final_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
         class A {final ^ final foo;}
         class _B {}
         A T;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('_B');
     assertSuggestClass('Object');
     assertNotSuggested('T');
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('x');
   }
 
   test_ClassDeclaration_body_final_var() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
         class A {final ^ var foo;}
         class _B {}
         A T;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('_B');
     assertSuggestClass('Object');
     assertNotSuggested('T');
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('x');
   }
 
   test_Combinator_hide() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         class C { }
         class D { }''');
     addTestSource('''
         import "/testAB.dart" hide ^;
         import "/testCD.dart";
         class X {}''');
 
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         typedef PB2 F2(int blat);
         class Clz = Object with Object;
         class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         class C { }
         class D { }''');
     addTestSource('''
         import "/testAB.dart" show ^;
         import "/testCD.dart";
         class X {}''');
 
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_ConditionalExpression_elseExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T1 : T^}}''');
 
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_elseExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T1 : ^}}''');
 
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertSuggestClass('A');
     assertSuggestFunction('F1', 'dynamic');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_partial_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T^}}''');
 
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_partial_thenExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? ^}}''');
 
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertSuggestClass('A');
     assertSuggestFunction('F1', 'dynamic');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T^ : c}}''');
 
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         var m;
         main() {new X.^}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by NamedConstructorContributor
     assertNotSuggested('c');
     assertNotSuggested('F1');
     assertNotSuggested('T1');
     assertNotSuggested('_d');
     assertNotSuggested('z');
     assertNotSuggested('m');
   }
 
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {factory X.c(); factory X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         var m;
         main() {new X.^}''');
 
     await computeSuggestions();
@@ skipping 80 matching lines @@
     expect(replacementLength, 0);
     assertNotSuggested('foo');
     assertNotSuggested('a');
     assertNotSuggested('A');
     assertSuggestClass('String');
     assertSuggestFunction('identical', 'bool');
     assertNotSuggested('bar');
   }
 
   test_doc_class() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library A;
 /// My class.
 /// Short description.
 ///
 /// Longer description.
 class A {}
 ''');
     addTestSource('import "/libA.dart"; main() {^}');
 
     await computeSuggestions();
 
     CompletionSuggestion suggestion = assertSuggestClass('A');
     expect(suggestion.docSummary, 'My class.\nShort description.');
     expect(suggestion.docComplete,
         'My class.\nShort description.\n\nLonger description.');
   }
 
   test_doc_function() async {
-    resolveSource(
-        '/libA.dart',
-        r'''
+    resolveSource('/libA.dart', r'''
 library A;
 /// My function.
 /// Short description.
 ///
 /// Longer description.
 int myFunc() {}
 ''');
     addTestSource('import "/libA.dart"; main() {^}');
 
     await computeSuggestions();
 
     CompletionSuggestion suggestion = assertSuggestFunction('myFunc', 'int');
     expect(suggestion.docSummary, 'My function.\nShort description.');
     expect(suggestion.docComplete,
         'My function.\nShort description.\n\nLonger description.');
   }
 
   test_doc_function_c_style() async {
-    resolveSource(
-        '/libA.dart',
-        r'''
+    resolveSource('/libA.dart', r'''
 library A;
 /**
  * My function.
  * Short description.
  *
  * Longer description.
  */
 int myFunc() {}
 ''');
     addTestSource('import "/libA.dart"; main() {^}');
@@ skipping 21 matching lines @@
     await computeSuggestions();
     // TODO(danrube) investigate why suggestion/element is not deprecated
     // when AST node has correct @deprecated annotation
     assertSuggestEnum('E', isDeprecated: true);
     assertNotSuggested('one');
     assertNotSuggested('two');
   }
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         _B F1() { }
         class A {int x;}
         class _B { }''');
     addTestSource('''
         import "/testA.dart";
         typedef int F2(int blat);
         class Clz = Object with Object;
         class C {foo(){^} void bar() {}}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('A');
     assertSuggestFunction('F1', '_B');
     assertNotSuggested('C');
     assertNotSuggested('foo');
     assertNotSuggested('bar');
     assertNotSuggested('F2');
     assertNotSuggested('Clz');
     assertNotSuggested('C');
     assertNotSuggested('x');
     assertNotSuggested('_B');
   }
 
   test_ExpressionStatement_name() async {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         B T1;
         class B{}''');
     addTestSource('''
         import "/testA.dart";
         class C {a() {C ^}}''');
 
     await computeSuggestions();
     assertNoSuggestions();
   }
 
@@ skipping 187 matching lines @@
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('index');
     assertNotSuggested('main');
     assertNotSuggested('bar');
   }
 
   test_function_parameters_mixed_required_and_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 int m(x, {int y}) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'int');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_function_parameters_mixed_required_and_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, [int y]) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_function_parameters_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m({x, int y}) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_function_parameters_none() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m() {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
 
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, isEmpty);
     expect(suggestion.parameterTypes, isEmpty);
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_function_parameters_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m([x, int y]) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_function_parameters_required() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, int y) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 2);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         /* */ ^ zoo(z) { } String name;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertSuggestFunctionTypeAlias('D1', 'dynamic');
     assertSuggestClass('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         /** */ ^ zoo(z) { } String name;''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertSuggestFunctionTypeAlias('D1', 'dynamic');
     assertSuggestClass('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         /// some dartdoc
@@ skipping 101 matching lines @@
     addTestSource('''
         import "dart^";
         main() {}''');
 
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_IndexExpression() async {
     // ExpressionStatement  Block
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} f[^]}}''');
 
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertSuggestClass('A');
     assertSuggestFunction('F1', 'dynamic');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_IndexExpression2() async {
     // SimpleIdentifier IndexExpression ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} f[T^]}}''');
 
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_InstanceCreationExpression() async {
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
 class A {foo(){var f; {var x;}}}
 class B {B(this.x, [String boo]) { } int x;}
 class C {C.bar({boo: 'hoo', int z: 0}) { } }''');
     addTestSource('''
 import "/testA.dart";
 import "dart:math" as math;
 main() {new ^ String x = "hello";}''');
 
     await computeSuggestions();
     CompletionSuggestion suggestion;
@@ skipping 29 matching lines @@
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, true);
 
     // Suggested by LibraryPrefixContributor
     assertNotSuggested('math');
   }
 
   test_InstanceCreationExpression_imported() async {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {A(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         import "dart:async";
         int T2;
         F2() { }
         class B {B(this.x, [String boo]) { } int x;}
         class C {foo(){var f; {var x;} new ^}}''');
@@ skipping 40 matching lines @@
     await computeSuggestions();
     assertSuggest('print');
     // Not imported, so not suggested
     assertNotSuggested('pow');
     // Do not suggest completions from internal SDK library
     assertNotSuggested('printToConsole');
   }
 
   test_InterpolationExpression() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         main() {String name; print("hello \$^");}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertSuggestTopLevelVar('T1', null);
     assertSuggestFunction('F1', null);
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_InterpolationExpression_block() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
@@ skipping 53 matching lines @@
 
     await computeSuggestions();
     assertNotSuggested('name');
     // top level results are partially filtered
     //assertSuggestClass('Object');
     assertNotSuggested('length');
   }
 
   test_IsExpression() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         class Y {Y.c(); Y._d(); z() {}}
         main() {var x; if (x is ^) { }}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
@@ skipping 49 matching lines @@
     expect(replacementOffset, completionOffset - 3);
     expect(replacementLength, 3);
     assertNotSuggested('a');
     assertNotSuggested('main');
     assertNotSuggested('A');
     assertSuggestClass('Object');
   }
 
   test_IsExpression_type_subtype_extends_filter() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         foo() { }
         class A {} class B extends A {} class C extends B {}
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         main(){A a; if (a is ^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('B');
     assertSuggestClass('C');
     assertNotSuggested('A');
     assertNotSuggested('X');
     assertNotSuggested('Object');
     assertNotSuggested('a');
     assertNotSuggested('main');
   }
 
   test_IsExpression_type_subtype_implements_filter() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         foo() { }
         class A {} class B implements A {} class C implements B {}
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         main(){A a; if (a is ^)}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('B');
     assertSuggestClass('C');
     assertNotSuggested('A');
     assertNotSuggested('X');
     assertNotSuggested('Object');
     assertNotSuggested('a');
     assertNotSuggested('main');
   }
 
   test_keyword() async {
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
         lib B;
         int newT1;
         int T1;
         nowIsIt() { }
         class X {factory X.c(); factory X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         String newer() {}
         var m;
         main() {new^ X.c();}''');
@@ skipping 40 matching lines @@
 
   test_localVariableDeclarationName() async {
     addTestSource('main() {String m^}');
     await computeSuggestions();
     assertNotSuggested('main');
     assertNotSuggested('min');
   }
 
   test_MapLiteralEntry() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
@@ skipping 13 matching lines @@
     assertSuggestFunctionTypeAlias('D1', /* null */ 'dynamic');
     assertSuggestClass('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
   }
 
   test_MapLiteralEntry1() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         foo = {T^''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     // Simulate unresolved imported library,
     // in which case suggestions will have null return types (unresolved)
     // The current DartCompletionRequest#resolveExpression resolves
     // the world (which it should not) and causes the imported library
     // to be resolved.
     assertSuggestTopLevelVar('T1', /* null */ 'int');
     assertNotSuggested('T2');
   }
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         foo = {7:T^};''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertSuggestTopLevelVar('T1', 'int');
     assertNotSuggested('T2');
   }
 
   test_method_parameters_mixed_required_and_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, {int y}) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_method_parameters_mixed_required_and_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, [int y]) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m({x, int y}) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_method_parameters_none() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m() {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
 
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, isEmpty);
     expect(suggestion.parameterTypes, isEmpty);
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m([x, int y]) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_required() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, int y) {}
 ''');
     addTestSource('''
 import '/libA.dart';
 class B {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
@@ skipping 13 matching lines @@
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('a');
     assertNotSuggested('f');
     assertNotSuggested('_g');
   }
 
   test_MethodDeclaration_body_static() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testC.dart',
-        '''
+    addSource('/testC.dart', '''
         class C {
           c1() {}
           var c2;
           static c3() {}
           static var c4;}''');
     addTestSource('''
         import "/testC.dart";
         class B extends C {
           b1() {}
           var b2;
@@ skipping 62 matching lines @@
     assertNotSuggested('foo');
     assertNotSuggested('bar');
     assertNotSuggested('a');
     assertNotSuggested('x');
     assertNotSuggested('y');
     assertSuggestClass('String');
   }
 
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {^ zoo(z) { } String name; }''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertSuggestFunctionTypeAlias('D1', 'dynamic');
     assertSuggestClass('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {/* */ ^ zoo(z) { } String name; }''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertSuggestFunctionTypeAlias('D1', 'dynamic');
     assertSuggestClass('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {/** */ ^ zoo(z) { } String name; }''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertSuggestFunctionTypeAlias('D1', 'dynamic');
     assertSuggestClass('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
         import "/testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {
@@ skipping 42 matching lines @@
     assertNotSuggested('m');
     assertNotSuggested('_n');
     assertNotSuggested('a');
     assertNotSuggested('A');
     assertNotSuggested('X');
     assertNotSuggested('Object');
     assertNotSuggested('==');
   }
 
   test_mixin_ordering() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 class B {}
 class M1 {
   void m() {}
 }
 class M2 {
   void m() {}
 }
 ''');
     addTestSource('''
 import '/libA.dart';
@@ skipping 23 matching lines @@
     context2.applyChanges(changeSet);
     context2.setContents(source2, content2);
 
     // Resolve the source in the 2nd context and update the index
     var result = context2.performAnalysisTask();
     while (result.hasMoreWork) {
       result = context2.performAnalysisTask();
     }
 
     // Check that source in 2nd context does not appear in completion in 1st
-    addSource(
-        '/context1/libA.dart',
-        '''
+    addSource('/context1/libA.dart', '''
       library libA;
       class ClassInLocalContext {int x;}''');
     testFile = '/context1/completionTest.dart';
     addTestSource('''
       import "/context1/libA.dart";
       import "/foo.dart";
       main() {C^}
       ''');
 
     await computeSuggestions();
     assertSuggestClass('ClassInLocalContext');
     // Assert contributor does not include results from 2nd context.
     assertNotSuggested('ClassFromAnotherContext');
   }
 
   test_new_instance() async {
     addTestSource('import "dart:math"; class A {x() {new Random().^}}');
 
     await computeSuggestions();
     assertNotSuggested('nextBool');
     assertNotSuggested('nextDouble');
     assertNotSuggested('nextInt');
     assertNotSuggested('Random');
     assertNotSuggested('Object');
     assertNotSuggested('A');
   }
 
   test_no_parameters_field() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 int x;
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestTopLevelVar('x', null);
     assertHasNoParameterInfo(suggestion);
   }
 
   test_no_parameters_getter() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 int get x => null;
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestGetter('x', 'int');
     assertHasNoParameterInfo(suggestion);
   }
 
   test_no_parameters_setter() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 set x(int value) {};
 ''');
     addTestSource('''
 import '/libA.dart';
 class B extends A {
   main() {^}
 }
 ''');
     await computeSuggestions();
     CompletionSuggestion suggestion = assertSuggestSetter('x');
     assertHasNoParameterInfo(suggestion);
   }
 
   test_parameterName_excludeTypes() async {
     addTestSource('m(int ^) {}');
     await computeSuggestions();
     assertNotSuggested('int');
     assertNotSuggested('bool');
   }
 
   test_partFile_TypeName() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         library libA;
         import "/testB.dart";
         part "$testFile";
         class A { }
         var m;''');
     addTestSource('''
         part of libA;
         class B { factory B.bar(int x) => null; }
         main() {new ^}''');
 
@@ skipping 10 matching lines @@
     assertNotSuggested('A');
     assertNotSuggested('F1');
     assertNotSuggested('T1');
     assertNotSuggested('_d');
     assertNotSuggested('z');
     assertNotSuggested('m');
   }
 
   test_partFile_TypeName2() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib libB;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class B { }''');
     addTestSource('''
         library libA;
         import "/testB.dart";
         part "/testA.dart";
         class A { A({String boo: 'hoo'}) { } }
         main() {new ^}
         var m;''');
 
@@ skipping 10 matching lines @@
     assertNotSuggested('B');
     assertNotSuggested('F1');
     assertNotSuggested('T1');
     assertNotSuggested('_d');
     assertNotSuggested('z');
     assertNotSuggested('m');
   }
 
   test_PrefixedIdentifier_class_const() async {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {
           static const scI = 'boo';
           X get f => new A();
           get _g => new A();}
         class B implements I {
           static const int scB = 12;
           var b; X _c;
           X get d => new A();get _e => new A();
           set s1(I x) {} set _s2(I x) {}
@@ skipping 26 matching lines @@
     assertNotSuggested('a');
     assertNotSuggested('A');
     assertNotSuggested('X');
     assertNotSuggested('w');
     assertNotSuggested('Object');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_class_imported() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {X get f => new A();get _g => new A();}
         class A implements I {
           static const int sc = 12;
           @deprecated var b; X _c;
           X get d => new A();get _e => new A();
           set s1(I x) {} set _s2(I x) {}
           m(X x) {} I _n(X x) {}}
         class X{}''');
     addTestSource('''
@@ skipping 58 matching lines @@
   test_PrefixedIdentifier_getter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addTestSource('String get g => "one"; f() {g.^}');
 
     await computeSuggestions();
     assertNotSuggested('length');
   }
 
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
     addTestSource('''
         import "/testB.dart" as b;
         var T2;
         class A { }
         main() {b.^}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LibraryMemberContributor
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('T1');
     assertNotSuggested('T2');
     assertNotSuggested('Object');
     assertNotSuggested('b');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
     addTestSource('''
         import "/testB.dart" as b;
         var T2;
         class A { }
         foo(b.^ f) {}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LibraryMemberContributor
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('T1');
     assertNotSuggested('T2');
     assertNotSuggested('Object');
     assertNotSuggested('b');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
     addTestSource('''
         import "/testB.dart" as b;
         var T2;
         class A { }
         foo(b.^) {}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LibraryMemberContributor
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('T1');
     assertNotSuggested('T2');
     assertNotSuggested('Object');
     assertNotSuggested('b');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class _W {M y; var _z;}
         class X extends _W {}
         class M{}''');
     addTestSource('''
         import "/testB.dart";
         foo(X x) {x.^}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('y');
     assertNotSuggested('_z');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class A {static int bar = 10;}
         _B() {}''');
     addTestSource('''
         import "/testA.dart";
         class X {foo(){A^.bar}}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertSuggestClass('A');
@@ skipping 420 matching lines @@
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // TopLevelVariableDeclaration
     addTestSource('class A {} var ^');
 
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
     addTestSource('''
         import "/testA.dart";'
         class C2 {int x;}
         F2() => 0;
         typedef int T2(int blat);
         class C<E> {}
         main() { C<^> c; }''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('Object');
     assertSuggestClass('C1');
     assertSuggestFunctionTypeAlias('T1', 'String');
     assertNotSuggested('C2');
     assertNotSuggested('T2');
     assertNotSuggested('F1');
     assertNotSuggested('F2');
   }
 
   test_TypeArgumentList2() async {
     // TypeName  TypeArgumentList  TypeName
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
     addTestSource('''
         import "/testA.dart";'
         class C2 {int x;}
         F2() => 0;
         typedef int T2(int blat);
         class C<E> {}
         main() { C<C^> c; }''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertSuggestClass('C1');
     assertNotSuggested('C2');
   }
 
   test_VariableDeclaration_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class _B { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         class Y {Y.c(); Y._d(); z() {}}
         main() {var ^}''');
 
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_VariableDeclarationList_final() async {
     // VariableDeclarationList  VariableDeclarationStatement  Block
     addTestSource('main() {final ^} class C { }');
 
     await computeSuggestions();
     assertSuggestClass('Object');
     assertNotSuggested('C');
     assertNotSuggested('==');
   }
 
   test_VariableDeclarationStatement_RHS() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class _B { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         class Y {Y.c(); Y._d(); z() {}}
         class C {bar(){var f; {var x;} var e = ^}}''');
 
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('X');
     assertNotSuggested('_B');
     assertNotSuggested('Y');
     assertNotSuggested('C');
     assertNotSuggested('f');
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
         lib B;
         foo1() { }
         void bar1() { }
         class _B { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
         import "/testB.dart";
         foo2() { }
         void bar2() { }
         class Y {Y.c(); Y._d(); z() {}}
         class C {bar(){var f; {var x;} var e = ^ var g}}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestClass('X');
     assertSuggestFunction('foo1', 'dynamic');
     assertNotSuggested('bar1');
     assertNotSuggested('foo2');
     assertNotSuggested('bar2');
     assertNotSuggested('_B');
     assertNotSuggested('Y');
     assertNotSuggested('C');
     assertNotSuggested('f');
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 }