reformat and 2 new tests for #23501

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
+

[Paul Berry, 2015/08/12 17:00:59]

Unintentional extra newline.

[danrubel, 2015/08/26 14:03:57]

Removed

 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.services.completion.util;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/protocol.dart' as protocol
     show Element, ElementKind;
@@ skipping 76 matching lines @@
   }
 
   void assertNoSuggestions({CompletionSuggestionKind kind: null}) {
     if (kind == null) {
       if (request.suggestions.length > 0) {
         failedCompletion('Expected no suggestions', request.suggestions);
       }
       return;
     }
     CompletionSuggestion suggestion = request.suggestions.firstWhere(
-        (CompletionSuggestion cs) => cs.kind == kind, orElse: () => null);
+        (CompletionSuggestion cs) => cs.kind == kind,
+        orElse: () => null);
     if (suggestion != null) {
       failedCompletion('did not expect completion: $completion\n  $suggestion');
     }
   }
 
   CompletionSuggestion assertNotSuggested(String completion) {
     CompletionSuggestion suggestion = request.suggestions.firstWhere(
         (CompletionSuggestion cs) => cs.completion == completion,
         orElse: () => null);
     if (suggestion != null) {
       failedCompletion('did not expect completion: $completion\n  $suggestion');
     }
     return null;
   }
 
   CompletionSuggestion assertSuggest(String completion,
       {CompletionSuggestionKind csKind: CompletionSuggestionKind.INVOCATION,
-      int relevance: DART_RELEVANCE_DEFAULT, String importUri,
-      protocol.ElementKind elemKind: null, bool isDeprecated: false,
-      bool isPotential: false, String elemFile, int elemOffset}) {
+      int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
+      protocol.ElementKind elemKind: null,
+      bool isDeprecated: false,
+      bool isPotential: false,
+      String elemFile,
+      int elemOffset}) {
     CompletionSuggestion cs =
         getSuggest(completion: completion, csKind: csKind, elemKind: elemKind);
     if (cs == null) {
       failedCompletion(
           'expected $completion $csKind $elemKind', request.suggestions);
     }
     expect(cs.kind, equals(csKind));
     if (isDeprecated) {
       expect(cs.relevance, equals(DART_RELEVANCE_LOW));
     } else {
@@ skipping 15 matching lines @@
     if (elemFile != null) {
       expect(cs.element.location.file, elemFile);
     }
     if (elemOffset != null) {
       expect(cs.element.location.offset, elemOffset);
     }
     return cs;
   }
 
   CompletionSuggestion assertSuggestClass(String name,
-      {int relevance: DART_RELEVANCE_DEFAULT, String importUri,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      bool isDeprecated: false, String elemFile, int elemOffset}) {
+      bool isDeprecated: false,
+      String elemFile,
+      int elemOffset}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         isDeprecated: isDeprecated,
         elemFile: elemFile,
         elemOffset: elemOffset);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS));
@@ skipping 13 matching lines @@
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS_TYPE_ALIAS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestConstructor(String name,
-      {int relevance: DART_RELEVANCE_DEFAULT, String importUri,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
       int elemOffset}) {
     CompletionSuggestion cs = assertSuggest(name,
         relevance: relevance, importUri: importUri, elemOffset: elemOffset);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
     int index = name.indexOf('.');
     expect(element.name, index >= 0 ? name.substring(index + 1) : '');
     return cs;
   }
 
   CompletionSuggestion assertSuggestField(String name, String type,
-      {int relevance: DART_RELEVANCE_DEFAULT, String importUri,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         elemKind: protocol.ElementKind.FIELD,
         isDeprecated: isDeprecated);
     // The returnType represents the type of a field
     expect(cs.returnType, type != null ? type : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FIELD));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     // The returnType represents the type of a field
     expect(element.returnType, type != null ? type : 'dynamic');
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunction(String name, String returnType,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT,
+      bool deprecated: false,
+      int relevance: DART_RELEVANCE_DEFAULT,
       String importUri}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         isDeprecated: deprecated);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION));
@@ skipping 31 matching lines @@
 //    expect(param[0], equals('('));
 //    expect(param[param.length - 1], equals(')'));
     expect(element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     // TODO (danrubel) Determine why param info is missing
 //    assertHasParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestGetter(String name, String returnType,
-      {int relevance: DART_RELEVANCE_DEFAULT, String importUri,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         elemKind: protocol.ElementKind.GETTER,
         isDeprecated: isDeprecated);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
@@ skipping 26 matching lines @@
 
   CompletionSuggestion assertSuggestLibraryPrefix(String prefix,
       [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Library prefix should only be suggested by ImportedReferenceContributor
     return assertNotSuggested(prefix);
   }
 
   CompletionSuggestion assertSuggestMethod(
       String name, String declaringType, String returnType,
-      {int relevance: DART_RELEVANCE_DEFAULT, String importUri,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         isDeprecated: isDeprecated);
     expect(cs.declaringType, equals(declaringType));
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.METHOD));
     expect(element.name, equals(name));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
     expect(element.returnType, returnType != null ? returnType : 'dynamic');
     assertHasParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestNamedConstructor(
-      String name, String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
+      String name, String returnType,
+      [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (contributor is PrefixedElementContributor) {
       CompletionSuggestion cs =
           assertSuggest(name, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
       expect(element.name, equals(name));
       String param = element.parameters;
       expect(param, isNotNull);
       expect(param[0], equals('('));
       expect(param[param.length - 1], equals(')'));
       expect(element.returnType, equals(returnType));
       assertHasParameterInfo(cs);
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestParameter(String name, String returnType,
       {int relevance: DART_RELEVANCE_PARAMETER}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestSetter(String name,
-      [int relevance = DART_RELEVANCE_DEFAULT, String importUri,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      String importUri,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         elemKind: protocol.ElementKind.SETTER);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.SETTER));
     expect(element.name, equals(name));
@@ skipping 74 matching lines @@
       sb.write('\n  in');
       AstNode node = completionNode;
       while (node != null) {
         sb.write('\n    ${node.runtimeType}');
         node = node.parent;
       }
     }
     fail(sb.toString());
   }
 
-  CompletionSuggestion getSuggest({String completion: null,
+  CompletionSuggestion getSuggest(
+      {String completion: null,
       CompletionSuggestionKind csKind: null,
       protocol.ElementKind elemKind: null}) {
     CompletionSuggestion cs;
     request.suggestions.forEach((CompletionSuggestion s) {
       if (completion != null && completion != s.completion) {
         return;
       }
       if (csKind != null && csKind != s.kind) {
         return;
       }
       if (elemKind != null) {
         protocol.Element element = s.element;
         if (element == null || elemKind != element.kind) {
           return;
         }
       }
       if (cs == null) {
         cs = s;
       } else {
         failedCompletion('expected exactly one $cs',
             request.suggestions.where((s) => s.completion == completion));
       }
     });
     return cs;
   }
 
   void resolve(bool fullAnalysis) {
-
     // Index SDK
     for (Source librarySource in context.librarySources) {
       CompilationUnit unit =
           context.getResolvedCompilationUnit2(librarySource, librarySource);
       if (unit != null) {
         index.indexUnit(context, unit);
       }
     }
 
     var result = context.performAnalysisTask();
     bool resolved = false;
     while (result.hasMoreWork) {
-
       // Update the index
       result.changeNotices.forEach((ChangeNotice notice) {
         CompilationUnit unit = notice.resolvedDartUnit;
         if (unit != null) {
           index.indexUnit(context, unit);
         }
       });
 
       // If the unit has been resolved, then finish the completion
       List<Source> libSourceList = context.getLibrariesContaining(testSource);
@@ skipping 30 matching lines @@
   }
 
   void setUpContributor();
 }
 
 /**
  * Common tests for `ImportedTypeContributorTest`, `InvocationContributorTest`,
  * and `LocalContributorTest`.
  */
 abstract class AbstractSelectorSuggestionTest extends AbstractCompletionTest {
-
   /**
    * Assert that the ImportedReferenceContributor uses cached results
    * to produce identical suggestions to the original set of suggestions.
    */
   void assertCachedCompute(_) {
     // Subclasses override
   }
 
   CompletionSuggestion assertSuggestEnum(String completion,
       {bool isDeprecated: false}) {
     CompletionSuggestion suggestion =
         assertSuggest(completion, isDeprecated: isDeprecated);
     expect(suggestion.isDeprecated, isDeprecated);
     expect(suggestion.element.kind, protocol.ElementKind.ENUM);
     return suggestion;
   }
 
   CompletionSuggestion assertSuggestEnumConst(String completion,
       {bool isDeprecated: false}) {
     CompletionSuggestion suggestion =
         assertSuggest(completion, isDeprecated: isDeprecated);
     expect(suggestion.isDeprecated, isDeprecated);
     expect(suggestion.element.kind, protocol.ElementKind.ENUM_CONSTANT);
     return suggestion;
   }
 
   CompletionSuggestion assertSuggestImportedClass(String name,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      int relevance: DART_RELEVANCE_DEFAULT, String importUri,
+      int relevance: DART_RELEVANCE_DEFAULT,
+      String importUri,
       String elemFile}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedConstructor(String name,
       {int relevance: DART_RELEVANCE_DEFAULT, String importUri}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(
       String name, String returnType,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT,
+      bool deprecated: false,
+      int relevance: DART_RELEVANCE_DEFAULT,
       String importUri}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunctionTypeAlias(
-      String name, String returnType, [bool isDeprecated = false,
+      String name, String returnType,
+      [bool isDeprecated = false,
       int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedGetter(
       String name, String returnType,
       {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedMethod(
       String name, String declaringType, String returnType,
       {int relevance: DART_RELEVANCE_INHERITED_METHOD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedSetter(String name,
       {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedTopLevelVar(
-      String name, String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
+      String name, String returnType,
+      [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION,
       String importUri]) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestInvocationClass(String name,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (contributor is PrefixedElementContributor) {
       return assertSuggestClass(name, relevance: relevance);
     } else {
@@ skipping 42 matching lines @@
       [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (contributor is PrefixedElementContributor) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClass(String name,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false,
-      String elemFile, int elemOffset}) {
+      int relevance: DART_RELEVANCE_DEFAULT,
+      bool isDeprecated: false,
+      String elemFile,
+      int elemOffset}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
       {int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalConstructor(String name,
       {int elemOffset}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalField(String name, String type,
       {int relevance: DART_RELEVANCE_LOCAL_FIELD, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunction(
-      String name, String returnType, {bool deprecated: false,
+      String name, String returnType,
+      {bool deprecated: false,
       int relevance: DART_RELEVANCE_LOCAL_FUNCTION,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunctionTypeAlias(
       String name, String returnType,
       {bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
@@ skipping 33 matching lines @@
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     return super
         .computeFull(assertFunction, fullAnalysis: fullAnalysis)
         .then(assertCachedCompute);
   }
 
   test_ArgumentList() {
     // 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(^)}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_imported_function() {
     // 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(^)}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_InstanceCreationExpression_functionalArg() {
     // 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 14 matching lines @@
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_InstanceCreationExpression_typedefArg() {
     // 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 15 matching lines @@
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_local_function() {
     // 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(^)}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_local_method() {
     // 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;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_MethodInvocation_functionalArg() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource('/libA.dart', '''
+    addSource(
+        '/libA.dart',
+        '''
       library A;
       class A { A(f()) { } }
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import 'dart:async';
       import '/libA.dart';
       class B { }
       String bar(f()) => true;
       void main() {bar(^);}''');
@@ skipping 14 matching lines @@
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_MethodInvocation_methodArg() {
     // 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(^);}''');
     computeFast();
@@ skipping 12 matching lines @@
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_namedParam() {
     // 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: ^)}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
@@ skipping 178 matching lines @@
       expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', 'int');
       assertSuggestImportedClass('Object');
       assertNotSuggested('b');
       assertNotSuggested('==');
     });
   }
 
   test_Block() {
     // 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 67 matching lines @@
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
       assertSuggestImportedClass('Uri');
       assertNotSuggested('parseIPv6Address');
       assertNotSuggested('parseHex');
     });
   }
 
   test_Block_final() {
     // 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 80 matching lines @@
   test_Block_final3() {
     addTestSource('main() {final ^ v;}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestImportedClass('String');
     });
   }
 
   test_Block_final_final() {
     // 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 @@
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
       assertSuggestImportedClass('Uri');
       assertNotSuggested('parseIPv6Address');
       assertNotSuggested('parseHex');
     });
   }
 
   test_Block_final_var() {
     // 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');
       assertSuggestImportedClass('Uri');
       assertNotSuggested('parseIPv6Address');
       assertNotSuggested('parseHex');
     });
   }
 
   test_Block_identifier_partial() {
-    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 48 matching lines @@
       //assertSuggestLocalTopLevelVar('T5', 'int');
       //assertSuggestLocalTopLevelVar('_T6', null);
       assertNotSuggested('==');
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
     });
   }
 
   test_Block_inherited_imported() {
     // 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() {^}}''');
     computeFast();
     return computeFull((bool result) {
@@ skipping 35 matching lines @@
       assertSuggestLocalGetter('f3', null);
       assertSuggestLocalSetter('f4');
       assertSuggestLocalMethod('e2', 'E', null);
       assertSuggestLocalMethod('f2', 'F', null);
       assertSuggestLocalMethod('i2', 'I', null);
       assertSuggestLocalMethod('m2', 'M', 'int');
     });
   }
 
   test_Block_local_function() {
-    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 38 matching lines @@
       // TODO(danrubel) implement
       assertSuggestImportedClass('Foo2',
           relevance: DART_RELEVANCE_LOW, importUri: 'package:myBar/bar.dart');
       assertSuggestImportedClass('Future',
           relevance: DART_RELEVANCE_LOW, importUri: 'dart:async');
     });
   }
 
   test_CascadeExpression_selector1() {
     // 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}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2() {
     // 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}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 1);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2_withTrailingReturn() {
     // 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}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
@@ skipping 80 matching lines @@
       assertSuggestParameter('e', null);
       assertSuggestParameter('s', 'StackTrace');
       assertSuggestLocalMethod('a', 'A', null);
       assertSuggestImportedClass('Object');
       assertNotSuggested('x');
     });
   }
 
   test_ClassDeclaration_body() {
     // ClassDeclaration  CompilationUnit
-    addSource('/testB.dart', '''
+    addSource(
+        '/testB.dart',
+        '''
       class B { }''');
     addTestSource('''
       import "testB.dart" as x;
       @deprecated class A {^}
       class _B {}
       A T;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
@@ skipping 13 matching lines @@
         expect(suggestionO.element.isDeprecated, isFalse);
         expect(suggestionO.element.isPrivate, isFalse);
       }
       assertNotSuggested('T');
       assertSuggestLibraryPrefix('x');
     });
   }
 
   test_ClassDeclaration_body_final() {
     // ClassDeclaration  CompilationUnit
-    addSource('/testB.dart', '''
+    addSource(
+        '/testB.dart',
+        '''
       class B { }''');
     addTestSource('''
       import "testB.dart" as x;
       class A {final ^}
       class _B {}
       A T;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('_B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('T');
       assertSuggestLibraryPrefix('x');
     });
   }
 
+  test_ClassDeclaration_body_final_field() {
+    // ClassDeclaration  CompilationUnit
+    addSource(
+        '/testB.dart',
+        '''
+      class B { }''');
+    addTestSource('''
+      import "testB.dart" as x;
+      class A {final ^ A(){}}
+      class _B {}
+      A T;''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertSuggestLocalClass('A');
+      assertSuggestLocalClass('_B');
+      assertSuggestImportedClass('String');
+      assertNotSuggested('T');
+      assertSuggestLibraryPrefix('x');
+    });
+  }
+
+  test_ClassDeclaration_body_final_field2() {
+    // ClassDeclaration  CompilationUnit
+    addSource(
+        '/testB.dart',
+        '''
+      class B { }''');
+    addTestSource('''
+      import "testB.dart" as Soo;
+      class A {final S^ A();}
+      class _B {}
+      A Sew;''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
+      assertSuggestLocalClass('A');
+      assertSuggestLocalClass('_B');
+      assertSuggestImportedClass('String');
+      assertNotSuggested('Sew');
+      assertSuggestLibraryPrefix('Soo');
+    });
+  }
+
   test_ClassDeclaration_body_final_final() {
     // 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;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('_B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('T');
       assertSuggestLibraryPrefix('x');
     });
   }
 
   test_ClassDeclaration_body_final_var() {
     // 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;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('_B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('T');
       assertSuggestLibraryPrefix('x');
     });
   }
 
   test_Combinator_hide() {
     // 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 {}''');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_Combinator_show() {
     // 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 {}''');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_ConditionalExpression_elseExpression() {
     // 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^}}''');
     computeFast();
     return computeFull((bool result) {
       // top level results are partially filtered based on first char
       assertSuggestLocalTopLevelVar('T2', 'int');
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_ConditionalExpression_elseExpression_empty() {
     // 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 : ^}}''');
     computeFast();
     return computeFull((bool result) {
       assertNotSuggested('x');
       assertSuggestLocalVariable('f', null);
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalClass('C');
       assertSuggestLocalFunction('F2', null);
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestImportedClass('A');
       assertSuggestImportedFunction('F1', null);
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_ConditionalExpression_partial_thenExpression() {
     // 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^}}''');
     computeFast();
     return computeFull((bool result) {
       // top level results are partially filtered based on first char
       assertSuggestLocalTopLevelVar('T2', 'int');
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_ConditionalExpression_partial_thenExpression_empty() {
     // 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 ? ^}}''');
     computeFast();
     return computeFull((bool result) {
       assertNotSuggested('x');
       assertSuggestLocalVariable('f', null);
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalClass('C');
       assertSuggestLocalFunction('F2', null);
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestImportedClass('A');
       assertSuggestImportedFunction('F1', null);
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_ConditionalExpression_thenExpression() {
     // 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}}''');
     computeFast();
     return computeFull((bool result) {
       // top level results are partially filtered based on first char
       assertSuggestLocalTopLevelVar('T2', 'int');
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_ConstructorName_importedClass() {
     // 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.^}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestNamedConstructor('c', 'X');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_ConstructorName_importedFactory() {
     // 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.^}''');
     computeFast();
     return computeFull((bool result) {
@@ skipping 82 matching lines @@
       assertSuggestLocalMethod('a', 'A', null);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('String');
       assertSuggestImportedFunction('identical', 'bool');
       assertNotSuggested('bar');
     });
   }
 
   test_ExpressionStatement_identifier() {
     // 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() {}}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('A');
       assertSuggestImportedFunction('F1', '_B');
       assertSuggestLocalClass('C');
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalMethod('bar', 'C', 'void');
       assertSuggestLocalFunctionTypeAlias('F2', 'int');
       assertSuggestLocalClassTypeAlias('Clz');
       assertSuggestLocalClass('C');
       assertNotSuggested('x');
       assertNotSuggested('_B');
     });
   }
 
   test_ExpressionStatement_name() {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
-    addSource('/testA.dart', '''
+    addSource(
+        '/testA.dart',
+        '''
       B T1;
       class B{}''');
     addTestSource('''
       import "/testA.dart";
       class C {a() {C ^}}''');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
@@ skipping 186 matching lines @@
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
       assertSuggestLocalVariable('index', 'int');
       assertSuggestLocalFunction('main', null);
       assertNotSuggested('bar');
     });
   }
 
   test_FunctionDeclaration_returnType_afterComment() {
     // 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 10 matching lines @@
       assertNotSuggested('T2');
       assertNotSuggested('F2');
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
       assertNotSuggested('name');
     });
   }
 
   test_FunctionDeclaration_returnType_afterComment2() {
     // 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 { }
@@ skipping 10 matching lines @@
       assertNotSuggested('T2');
       assertNotSuggested('F2');
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
       assertNotSuggested('name');
     });
   }
 
   test_FunctionDeclaration_returnType_afterComment3() {
     // 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 105 matching lines @@
       import "dart^";
       main() {}''');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_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[^]}}''');
     computeFast();
     return computeFull((bool result) {
       assertNotSuggested('x');
       assertSuggestLocalVariable('f', null);
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalClass('C');
       assertSuggestLocalFunction('F2', null);
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestImportedClass('A');
       assertSuggestImportedFunction('F1', null);
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_IndexExpression2() {
     // 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^]}}''');
     computeFast();
     return computeFull((bool result) {
       // top level results are partially filtered based on first char
       assertSuggestLocalTopLevelVar('T2', 'int');
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_InstanceCreationExpression_imported() {
     // 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 26 matching lines @@
       expect(request.replacementLength, 1);
       assertSuggestImportedConstructor('Future',
           relevance: DART_RELEVANCE_LOW, importUri: 'dart:async');
       assertSuggestImportedConstructor('Foo',
           relevance: DART_RELEVANCE_LOW, importUri: 'testAB.dart');
     });
   }
 
   test_InterpolationExpression() {
     // 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 14 matching lines @@
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestLocalFunction('F2', null);
       assertNotSuggested('D2');
       assertNotSuggested('C2');
       assertSuggestLocalVariable('name', 'String');
     });
   }
 
   test_InterpolationExpression_block() {
     // 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 60 matching lines @@
     return computeFull((bool result) {
       assertSuggestLocalVariable('name', 'String');
       // top level results are partially filtered
       //assertSuggestImportedClass('Object');
       assertNotSuggested('length');
     });
   }
 
   test_IsExpression() {
     // 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 ^) { }}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
@@ skipping 52 matching lines @@
       expect(request.replacementOffset, completionOffset - 3);
       expect(request.replacementLength, 3);
       assertNotSuggested('a');
       assertNotSuggested('main');
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_keyword() {
-    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 40 matching lines @@
     // SimpleStringLiteral  ExpressionStatement  Block
     addTestSource('class A {a() {"hel^lo"}}');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_MapLiteralEntry() {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource('/testA.dart', '''
+    addSource(
+        '/testA.dart',
+        '''
       int T1;
       F1() { }
       typedef D1();
       class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
       import "/testA.dart";
       int T2;
       F2() { }
       typedef D2();
       class C2 { }
@@ skipping 13 matching lines @@
       assertSuggestImportedClass('C1');
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestLocalFunction('F2', null);
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
     });
   }
 
   test_MapLiteralEntry1() {
     // 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^''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
       // TODO(danrubel) Should be top level variable
       if (contributor is ImportedReferenceContributor) {
         assertSuggestGetter('T1', 'int');
         // assertSuggestImportedTopLevelVar('T1', 'int');
       }
       assertSuggestLocalTopLevelVar('T2', 'int');
     });
   }
 
   test_MapLiteralEntry2() {
     // 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 101 matching lines @@
       assertSuggestLocalFunction('bar', 'void');
       assertSuggestLocalMethod('a', 'A', 'Z');
       assertSuggestParameter('x', 'X');
       assertSuggestParameter('y', 'int');
       assertSuggestImportedClass('String');
     });
   }
 
   test_MethodDeclaration_returnType() {
     // 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; }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       assertNotSuggested('T1');
       assertNotSuggested('F1');
       assertSuggestImportedFunctionTypeAlias('D1', null);
       assertSuggestImportedClass('C1');
       assertNotSuggested('T2');
       assertNotSuggested('F2');
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
       assertNotSuggested('name');
     });
   }
 
   test_MethodDeclaration_returnType_afterComment() {
     // 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; }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       assertNotSuggested('T1');
       assertNotSuggested('F1');
       assertSuggestImportedFunctionTypeAlias('D1', null);
       assertSuggestImportedClass('C1');
       assertNotSuggested('T2');
       assertNotSuggested('F2');
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
       assertNotSuggested('name');
     });
   }
 
   test_MethodDeclaration_returnType_afterComment2() {
     // 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; }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       assertNotSuggested('T1');
       assertNotSuggested('F1');
       assertSuggestImportedFunctionTypeAlias('D1', null);
       assertSuggestImportedClass('C1');
       assertNotSuggested('T2');
       assertNotSuggested('F2');
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
       assertNotSuggested('name');
     });
   }
 
   test_MethodDeclaration_returnType_afterComment3() {
     // 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 58 matching lines @@
       assertSuggestInvocationMethod('nextDouble', 'Random', 'double');
       assertSuggestInvocationMethod('nextInt', 'Random', 'int');
       assertNotSuggested('Random');
       assertNotSuggested('Object');
       assertNotSuggested('A');
     });
   }
 
   test_partFile_TypeName() {
     // 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 ^}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestLocalConstructor('B.bar');
       assertSuggestImportedConstructor('Object');
       assertSuggestImportedConstructor('X.c');
       assertNotSuggested('X._d');
       assertSuggestImportedConstructor('A');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_partFile_TypeName2() {
     // 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;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestLocalConstructor('A');
       assertSuggestImportedConstructor('Object');
       assertSuggestImportedConstructor('X.c');
       assertNotSuggested('X._d');
       assertSuggestImportedConstructor('B');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_PrefixedIdentifier_class_const() {
     // 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('X');
       assertNotSuggested('w');
       assertNotSuggested('Object');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_class_imported() {
     // 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 61 matching lines @@
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addTestSource('String get g => "one"; f() {g.^}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestInvocationGetter('length', 'int');
     });
   }
 
   test_PrefixedIdentifier_library() {
     // 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.^}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestInvocationClass('X');
       assertSuggestInvocationClass('Y');
       assertSuggestInvocationTopLevelVar('T1', null);
       assertNotSuggested('T2');
       assertNotSuggested('Object');
       assertNotSuggested('b');
       assertNotSuggested('A');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_library_typesOnly() {
     // 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) {}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestInvocationClass('X');
       assertSuggestInvocationClass('Y');
       assertNotSuggested('T1');
       assertNotSuggested('T2');
       assertNotSuggested('Object');
       assertNotSuggested('b');
       assertNotSuggested('A');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_library_typesOnly2() {
     // 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.^) {}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestInvocationClass('X');
       assertSuggestInvocationClass('Y');
       assertNotSuggested('T1');
       assertNotSuggested('T2');
       assertNotSuggested('Object');
       assertNotSuggested('b');
       assertNotSuggested('A');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_parameter() {
     // 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.^}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestInvocationField('y', 'M');
       assertNotSuggested('_z');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_prefix() {
     // 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}}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
       assertSuggestImportedClass('A');
@@ skipping 450 matching lines @@
     // TopLevelVariableDeclaration
     addTestSource('class A {} var ^');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_TypeArgumentList() {
     // 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; }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       assertSuggestImportedClass('C1');
       assertSuggestImportedFunctionTypeAlias('T1', 'String');
       assertSuggestLocalClass('C2');
       assertSuggestLocalFunctionTypeAlias('T2', 'int');
       assertNotSuggested('F1');
       assertNotSuggested('F2');
     });
   }
 
   test_TypeArgumentList2() {
     // 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; }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
       assertSuggestImportedClass('C1');
       assertSuggestLocalClass('C2');
     });
   }
 
   test_VariableDeclaration_name() {
     // 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 ^}''');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_VariableDeclarationList_final() {
     // VariableDeclarationList  VariableDeclarationStatement  Block
     addTestSource('main() {final ^} class C { }');
     computeFast();
     return computeFull((bool result) {
       assertSuggestImportedClass('Object');
       assertSuggestLocalClass('C');
       assertNotSuggested('==');
     });
   }
 
   test_VariableDeclarationStatement_RHS() {
     // 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 = ^}}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('X');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 
   test_VariableDeclarationStatement_RHS_missing_semicolon() {
     // 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}}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('X');
       assertSuggestImportedFunction('foo1', null);
       assertNotSuggested('bar1');
       assertSuggestLocalFunction('foo2', null);
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }