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

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 
 import 'package:analysis_server/src/provisional/completion/dart/completion_dart.dart';
 import 'package:analysis_server/src/services/completion/dart/type_member_contributor.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:test/test.dart';
@@ skipping 95 matching lines @@
 
 void main() {new A().f^}''');
     await computeSuggestions();
 
     assertSuggestMethod('foo', 'A', 'bool',
         defaultArgListString: 'bar, baz: null');
   }
 
   test_ArgumentList() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/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');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_imported_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/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');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('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(^)}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('A');
     assertNotSuggested('Object');
     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;
         void main() {new A(^)}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('A');
     assertNotSuggested('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_local_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/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');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_local_method() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/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');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('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(^);}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
     assertNotSuggested('bar');
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('A');
     assertNotSuggested('Object');
     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);
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertNotSuggested('B');
     assertNotSuggested('A');
     assertNotSuggested('Object');
     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);
     assertNotSuggested('bar');
@@ skipping 156 matching lines @@
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('a');
     assertNotSuggested('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 57 matching lines @@
     assertNotSuggested('blog');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
     assertNotSuggested('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 77 matching lines @@
 
   test_Block_final3() async {
     addTestSource('main() {final ^ v;}');
     await computeSuggestions();
 
     assertNotSuggested('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;
         int T5;
         var _T6;
@@ skipping 63 matching lines @@
     assertNotSuggested('blog');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
     assertNotSuggested('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 62 matching lines @@
     assertNotSuggested('clog');
     assertNotSuggested('blog');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
     assertNotSuggested('Uri');
     assertNotSuggested('parseIPv6Address');
     assertNotSuggested('parseHex');
   }
 
   test_Block_identifier_partial() async {
-    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 { }
         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 44 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 32 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 30 matching lines @@
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('Foo');
     // TODO(danrubel) implement
     assertNotSuggested('Foo2');
     assertNotSuggested('Future');
   }
 
   test_CascadeExpression_method1() 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);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     assertNotSuggested('Object');
     assertNotSuggested('A');
     assertNotSuggested('B');
     assertNotSuggested('X');
     assertNotSuggested('z');
     assertNotSuggested('==');
   }
 
   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);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     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);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     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);
     assertSuggestField('b', null);
@@ skipping 68 matching lines @@
     expect(replacementLength, 0);
     assertNotSuggested('e');
     assertNotSuggested('s');
     assertNotSuggested('a');
     assertNotSuggested('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');
     assertNotSuggested('Object');
     assertNotSuggested('T');
     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');
     assertNotSuggested('Object');
     assertNotSuggested('T');
     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');
     assertNotSuggested('String');
     assertNotSuggested('T');
     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');
     assertNotSuggested('String');
     assertNotSuggested('Sew');
     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');
     assertNotSuggested('Object');
     assertNotSuggested('T');
     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');
     assertNotSuggested('Object');
     assertNotSuggested('T');
     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
-    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 : ^}}''');
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // 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
-    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 ? ^}}''');
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // 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();
     expect(replacementOffset, completionOffset);
@@ skipping 139 matching lines @@
     await computeSuggestions();
     assertNotSuggested('E');
     assertNotSuggested('one');
     assertNotSuggested('two');
     assertSuggestField('index', 'int');
     assertNotSuggested('values');
   }
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/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);
     assertNotSuggested('A');
     assertNotSuggested('F1');
     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();
   }
 
   test_FieldDeclaration_name_typed() async {
@@ skipping 155 matching lines @@
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('index');
     assertNotSuggested('main');
     assertNotSuggested('bar');
   }
 
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    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 { }
         /* */ ^ zoo(z) { } String name;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    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 { }
         /** */ ^ zoo(z) { } String name;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    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();
         /// some dartdoc
@@ skipping 148 matching lines @@
     // SimpleStringLiteral  ImportDirective
     addTestSource('''
         import "dart^";
         main() {}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_IndexExpression() async {
     // 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[^]}}''');
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // 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_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 20 matching lines @@
     addTestSource('class C {foo(){new F^}}');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('Future');
     assertNotSuggested('Foo');
   }
 
   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');
     // TODO(danrubel) should return top level var rather than getter
     assertNotSuggested('F1');
     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 45 matching lines @@
     addTestSource('main() {String name; print("hello \${nam^e.length}");}');
     await computeSuggestions();
     assertNotSuggested('name');
     // top level results are partially filtered
     //assertNotSuggested('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);
     expect(replacementLength, 0);
@@ skipping 51 matching lines @@
   }
 
   test_keyword() async {
     addTestSource('class C { static C get instance => null; } main() {C.in^}');
     await computeSuggestions();
     // Suggested by StaticMemberContributor
     assertNotSuggested('instance');
   }
 
   test_keyword2() async {
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/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 98 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 { }
         foo = {^''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('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);
     assertNotSuggested('T2');
   }
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  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 109 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 58 matching lines @@
     assertNotSuggested('foo');
     assertNotSuggested('bar');
     assertNotSuggested('a');
     assertNotSuggested('x');
     assertNotSuggested('y');
     assertNotSuggested('String');
   }
 
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
-    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 {^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    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 {/* */ ^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    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 {/** */ ^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    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 176 matching lines @@
 
   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 ^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('B.bar');
     assertNotSuggested('Object');
     assertNotSuggested('X.c');
     assertNotSuggested('X._d');
     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 B;
         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;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('Object');
     assertNotSuggested('X.c');
     assertNotSuggested('X._d');
     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 25 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 55 matching lines @@
 
   test_PrefixedIdentifier_getter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addTestSource('String get g => "one"; f() {g.^}');
     await computeSuggestions();
     assertSuggestGetter('length', 'int');
   }
 
   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);
     assertSuggestField('y', 'M');
     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);
     assertNotSuggested('A');
     assertNotSuggested('X');
@@ skipping 548 matching lines @@
   test_TopLevelVariableDeclaration_untyped_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // TopLevelVariableDeclaration
     addTestSource('class A {} var ^');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
-    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; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('C1');
     assertNotSuggested('T1');
     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);
     assertNotSuggested('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();
     assertNotSuggested('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);
     assertNotSuggested('X');
     assertNotSuggested('_B');
     assertNotSuggested('Y');
     assertNotSuggested('C');
     assertNotSuggested('f');
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/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);
     assertNotSuggested('X');
     assertNotSuggested('foo1');
     assertNotSuggested('bar1');
     assertNotSuggested('foo2');
     assertNotSuggested('bar2');
     assertNotSuggested('_B');
     assertNotSuggested('Y');
     assertNotSuggested('C');
     assertNotSuggested('f');
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 }