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

pkg/analysis_server/test/services/completion/dart/local_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/local_reference_contributor.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ skipping 112 matching lines @@
     await computeSuggestions();
 
     assertSuggestMethod('foo', 'A', 'bool',
         relevance: DART_RELEVANCE_LOCAL_METHOD,
         defaultArgListString: 'bar, baz: null',
         defaultArgumentListTextRanges: [0, 3, 10, 4]);
   }
 
   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);
     assertSuggestFunction('bar', 'String',
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertSuggestClass('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);
     assertSuggestFunction('bar', 'String',
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertSuggestClass('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(^)}''');
@@ skipping 10 matching lines @@
     assertSuggestClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
     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;
@@ skipping 11 matching lines @@
     assertSuggestClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
     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);
     assertSuggestFunction('bar', 'String',
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertSuggestClass('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);
     assertSuggestFunction('bar', 'String',
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertNotSuggested('hasLength');
     assertNotSuggested('identical');
     assertSuggestClass('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() {boo(){} bar(^);}''');
@@ skipping 13 matching lines @@
     assertSuggestClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('A');
     assertNotSuggested('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_MethodInvocation_functionalArg2() 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({inc()}) => true;
 void main() {boo(){} bar(inc: ^);}''');
@@ skipping 13 matching lines @@
     assertSuggestClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
     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');
     assertSuggestClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
     assertNotSuggested('A');
     assertNotSuggested('Object');
     assertNotSuggested('main');
     assertNotSuggested('baz');
     assertNotSuggested('print');
   }
 
   test_ArgumentList_namedFieldParam_tear_off() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
   final VoidCallback onPressed;
   Button({this.onPressed});
 }
 ''');
     addTestSource('''
 import '/libA.dart';
 
@@ skipping 10 matching lines @@
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
 
     assertSuggest('_incrementCounter',
         csKind: CompletionSuggestionKind.IDENTIFIER);
   }
 
   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 34 matching lines @@
     assertSuggestTopLevelVar('c', 'C',
         relevance:
             DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE + DART_RELEVANCE_INCREMENT);
     assertSuggestTopLevelVar('d', 'D',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     assertSuggestTopLevelVar('e', 'E',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
   }
 
   test_ArgumentList_namedParam_tear_off() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
   Button({VoidCallback onPressed});
 }
 ''');
     addTestSource('''
 import '/libA.dart';
 
 class PageState {
   void _incrementCounter() { }
   build() =>
     new Button(
       onPressed: ^
     );  
 }    
 ''');
     await computeSuggestions();
 
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
 
     assertSuggest('_incrementCounter',
         csKind: CompletionSuggestionKind.IDENTIFIER);
   }
 
   test_ArgumentList_namedParam_tear_off_1() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
   Button({VoidCallback onPressed, int x});
 }
 ''');
     addTestSource('''
 import '/libA.dart';
 
 class PageState {
   void _incrementCounter() { }
   build() =>
     new Button(
       onPressed: ^
     );  
 }    
 ''');
     await computeSuggestions();
 
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
 
     assertSuggest('_incrementCounter',
         csKind: CompletionSuggestionKind.IDENTIFIER);
   }
 
   test_ArgumentList_namedParam_tear_off_2() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
   Button({ int x, VoidCallback onPressed);
 }
 ''');
     addTestSource('''
 import '/libA.dart';
 
 class PageState {
@@ skipping 248 matching lines @@
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestLocalVariable('a', 'int');
     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 63 matching lines @@
     assertSuggestSetter('blog', relevance: DART_RELEVANCE_LOCAL_ACCESSOR);
     // 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 78 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 64 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 63 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 45 matching lines @@
     assertNotSuggested('_T4');
     //assertSuggestTopLevelVar('T5', 'int', relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     //assertSuggestTopLevelVar('_T6', null);
     assertNotSuggested('==');
     // TODO (danrubel) suggest HtmlElement as low relevance
     assertNotSuggested('HtmlElement');
   }
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/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 33 matching lines @@
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('Foo');
     // TODO(danrubel) implement
     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);
     assertSuggestParameter('e', null);
     assertSuggestParameter('s', 'StackTrace');
     assertSuggestMethod('a', 'A', null, relevance: DART_RELEVANCE_LOCAL_METHOD);
     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);
     CompletionSuggestion suggestionA = assertSuggestClass('A',
         relevance: DART_RELEVANCE_LOW, isDeprecated: true);
     if (suggestionA != null) {
       expect(suggestionA.element.isDeprecated, isTrue);
       expect(suggestionA.element.isPrivate, isFalse);
     }
     CompletionSuggestion suggestionB = assertSuggestClass('_B');
     if (suggestionB != null) {
       expect(suggestionB.element.isDeprecated, isFalse);
       expect(suggestionB.element.isPrivate, isTrue);
     }
     assertNotSuggested('Object');
     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);
     assertSuggestClass('A');
     assertSuggestClass('_B');
     assertNotSuggested('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);
     assertSuggestClass('A');
     assertSuggestClass('_B');
     assertNotSuggested('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);
     assertSuggestClass('A');
     assertSuggestClass('_B');
     assertNotSuggested('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);
     assertSuggestClass('A');
     assertSuggestClass('_B');
     assertNotSuggested('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);
     assertSuggestClass('A');
     assertSuggestClass('_B');
     assertNotSuggested('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
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertNotSuggested('T1');
   }
 
   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');
     assertSuggestLocalVariable('f', null);
     assertSuggestMethod('foo', 'C', null,
         relevance: DART_RELEVANCE_LOCAL_METHOD);
     assertSuggestClass('C');
     assertSuggestFunction('F2', null, relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertNotSuggested('T1');
   }
 
   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
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertNotSuggested('T1');
   }
 
   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');
     assertSuggestLocalVariable('f', null);
     assertSuggestMethod('foo', 'C', null,
         relevance: DART_RELEVANCE_LOCAL_METHOD);
     assertSuggestClass('C');
     assertSuggestFunction('F2', null, relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertNotSuggested('T1');
   }
 
   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();
@@ skipping 36 matching lines @@
   test_constructor_parameters_required() async {
     addTestSource('class A {A(x, int y) {^}}');
     await computeSuggestions();
     assertSuggestParameter('x', null);
     assertSuggestParameter('y', '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 231 matching lines @@
         relevance: DART_RELEVANCE_DEFAULT + DART_RELEVANCE_INCREMENT);
     assertSuggestEnumConst('E.two',
         relevance: DART_RELEVANCE_DEFAULT + DART_RELEVANCE_INCREMENT);
     assertNotSuggested('a');
     assertNotSuggested('F.three');
     assertNotSuggested('F.four');
   }
 
   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');
     assertSuggestClass('C');
     assertSuggestMethod('foo', 'C', null,
         relevance: DART_RELEVANCE_LOCAL_METHOD);
     assertSuggestMethod('bar', 'C', 'void',
         relevance: DART_RELEVANCE_LOCAL_METHOD);
     assertSuggestFunctionTypeAlias('F2', 'int');
     assertSuggestClassTypeAlias('Clz');
     assertSuggestClass('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 316 matching lines @@
     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
-    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');
     assertSuggestFunctionTypeAlias('D2', null);
     assertSuggestClass('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');
     assertSuggestFunctionTypeAlias('D2', null);
     assertSuggestClass('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 143 matching lines @@
 /// The [m^]
 main(aaa, bbb) {}''');
     await computeSuggestions();
     assertSuggestFunction('main', null,
         kind: CompletionSuggestionKind.IDENTIFIER,
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
   }
 
   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');
     assertSuggestLocalVariable('f', null);
     assertSuggestMethod('foo', 'C', null,
         relevance: DART_RELEVANCE_LOCAL_METHOD);
     assertSuggestClass('C');
     assertSuggestFunction('F2', null, relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertNotSuggested('T1');
   }
 
   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();
@@ skipping 11 matching lines @@
 class B {B(this.x, [String boo]) { } int x;}
 class C {C.bar({boo: 'hoo', int z: 0}) { } }
 main() {new ^ String x = "hello";}''');
     await computeSuggestions();
     // Suggested by LocalConstructorContributor
     assertNoSuggestions();
   }
 
   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 23 matching lines @@
     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 { }
@@ skipping 10 matching lines @@
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     assertSuggestFunction('F2', null, relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertSuggestLocalVariable('name', 'String');
   }
 
   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 52 matching lines @@
     await computeSuggestions();
 
     assertSuggestLocalVariable('name', 'String');
     // 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);
@@ skipping 94 matching lines @@
 
     expect(replacementOffset, completionOffset - 3);
     expect(replacementLength, 3);
     assertNotSuggested('a');
     assertNotSuggested('main');
     assertSuggestClass('A');
     assertNotSuggested('Object');
   }
 
   test_keyword() 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 43 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('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
     assertSuggestFunction('F2', null, relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertSuggestFunctionTypeAlias('D2', null);
     assertSuggestClass('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('T1');
     assertSuggestTopLevelVar('T2', 'int',
         relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
   }
 
   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 107 matching lines @@
     CompletionSuggestion getterG =
         assertSuggestGetter('_g', null, relevance: DART_RELEVANCE_DEFAULT);
     if (getterG != null) {
       expect(getterG.element.isDeprecated, isFalse);
       expect(getterG.element.isPrivate, isTrue);
     }
   }
 
   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 120 matching lines @@
     assertSuggestFunction('bar', 'void',
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertSuggestMethod('a', 'A', 'Z', relevance: DART_RELEVANCE_LOCAL_METHOD);
     assertSuggestParameter('x', 'X');
     assertSuggestParameter('y', 'int');
     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');
     assertSuggestFunctionTypeAlias('D2', null);
     assertSuggestClass('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');
     assertSuggestFunctionTypeAlias('D2', null);
     assertSuggestClass('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');
     assertSuggestFunctionTypeAlias('D2', null);
     assertSuggestClass('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 87 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);
     // Suggested by LocalConstructorContributor
     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 computeLibrariesContaining();
     await computeSuggestions();
 
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LocalConstructorContributor
     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 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);
     assertNotSuggested('A');
@@ skipping 464 matching lines @@
     // 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');
     assertSuggestClass('C2');
     assertSuggestFunctionTypeAlias('T2', 'int');
     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');
     assertSuggestClass('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');
     assertSuggestClass('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');
     assertSuggestClass('Y');
     assertSuggestClass('C');
     assertSuggestLocalVariable('f', null);
     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');
     assertSuggestFunction('foo2', null,
         relevance: DART_RELEVANCE_LOCAL_FUNCTION);
     assertNotSuggested('bar2');
     assertNotSuggested('_B');
     assertSuggestClass('Y');
     assertSuggestClass('C');
     assertSuggestLocalVariable('f', null);
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 }