Reformat

pkg/analysis_server/test/services/completion/completion_test_util.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.
 
 library test.services.completion.util;
 
 import 'dart:async';
 
-import 'package:analysis_server/src/protocol.dart' as protocol show Element,
-    ElementKind;
+import 'package:analysis_server/src/protocol.dart' as protocol
+    show Element, ElementKind;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/common_usage_computer.dart';
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/imported_computer.dart';
 import 'package:analysis_server/src/services/completion/invocation_computer.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_memory_index.dart';
 import 'package:analysis_server/src/services/search/search_engine_internal.dart';
@@ skipping 34 matching lines @@
   void addTestSource(String content) {
     expect(completionOffset, isNull, reason: 'Call addTestUnit exactly once');
     completionOffset = content.indexOf('^');
     expect(completionOffset, isNot(equals(-1)), reason: 'missing ^');
     int nextOffset = content.indexOf('^', completionOffset + 1);
     expect(nextOffset, equals(-1), reason: 'too many ^');
     content = content.substring(0, completionOffset) +
         content.substring(completionOffset + 1);
     testSource = addSource(testFile, content);
     cache = new DartCompletionCache(context, testSource);
-    request = new DartCompletionRequest(
-        context,
-        searchEngine,
-        testSource,
-        completionOffset,
-        cache,
-        new CompletionPerformance());
+    request = new DartCompletionRequest(context, searchEngine, testSource,
+        completionOffset, cache, new CompletionPerformance());
   }
 
   void assertHasNoParameterInfo(CompletionSuggestion suggestion) {
     expect(suggestion.parameterNames, isNull);
     expect(suggestion.parameterTypes, isNull);
     expect(suggestion.requiredParameterCount, isNull);
     expect(suggestion.hasNamedParameters, isNull);
   }
 
   void assertHasParameterInfo(CompletionSuggestion suggestion) {
     expect(suggestion.parameterNames, isNotNull);
     expect(suggestion.parameterTypes, isNotNull);
     expect(suggestion.parameterNames.length, suggestion.parameterTypes.length);
-    expect(
-        suggestion.requiredParameterCount,
+    expect(suggestion.requiredParameterCount,
         lessThanOrEqualTo(suggestion.parameterNames.length));
     expect(suggestion.hasNamedParameters, isNotNull);
   }
 
   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, protocol.ElementKind elemKind: null,
-      bool isDeprecated: false, bool isPotential: false}) {
+      int relevance: DART_RELEVANCE_DEFAULT,
+      protocol.ElementKind elemKind: null, bool isDeprecated: false,
+      bool isPotential: false}) {
     CompletionSuggestion cs =
         getSuggest(completion: completion, csKind: csKind, elemKind: elemKind);
     if (cs == null) {
       failedCompletion(
-          'expected $completion $csKind $elemKind',
-          request.suggestions);
+          'expected $completion $csKind $elemKind', request.suggestions);
     }
     expect(cs.kind, equals(csKind));
     if (isDeprecated) {
       expect(cs.relevance, equals(DART_RELEVANCE_LOW));
     } else {
       expect(cs.relevance, equals(relevance));
     }
     expect(cs.selectionOffset, equals(completion.length));
     expect(cs.selectionLength, equals(0));
     expect(cs.isDeprecated, equals(isDeprecated));
     expect(cs.isPotential, equals(isPotential));
     return cs;
   }
 
-  void assertSuggestArgumentList(List<String> paramNames,
-      List<String> paramTypes) {
+  void assertSuggestArgumentList(
+      List<String> paramNames, List<String> paramTypes) {
     CompletionSuggestionKind csKind = CompletionSuggestionKind.ARGUMENT_LIST;
     CompletionSuggestion cs = getSuggest(csKind: csKind);
     if (cs == null) {
       failedCompletion('expected completion $csKind', request.suggestions);
     }
     assertSuggestArgumentList_params(
-        paramNames,
-        paramTypes,
-        cs.parameterNames,
-        cs.parameterTypes);
+        paramNames, paramTypes, cs.parameterNames, cs.parameterTypes);
     expect(cs.relevance, DART_RELEVANCE_HIGH);
   }
 
   void assertSuggestArgumentList_params(List<String> expectedNames,
       List<String> expectedTypes, List<String> actualNames,
       List<String> actualTypes) {
     if (actualNames != null &&
         actualNames.length == expectedNames.length &&
         actualTypes != null &&
         actualTypes.length == expectedTypes.length) {
@@ skipping 11 matching lines @@
     }
     StringBuffer msg = new StringBuffer();
     msg.writeln('Argument list not the same');
     msg.writeln('  Expected names: $expectedNames');
     msg.writeln('           found: $actualNames');
     msg.writeln('  Expected types: $expectedTypes');
     msg.writeln('           found: $actualTypes');
     fail(msg.toString());
   }
 
-  CompletionSuggestion assertSuggestClass(String name, {int relevance:
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind:
-      CompletionSuggestionKind.INVOCATION, bool isDeprecated: false}) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
-        csKind: kind,
-        relevance: relevance,
-        isDeprecated: isDeprecated);
+  CompletionSuggestion assertSuggestClass(String name,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool isDeprecated: false}) {
+    CompletionSuggestion cs = assertSuggest(name,
+        csKind: kind, relevance: relevance, isDeprecated: isDeprecated);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
-  CompletionSuggestion assertSuggestClassTypeAlias(String name, [int relevance =
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestClassTypeAlias(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     protocol.Element element = cs.element;
     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 assertSuggestField(String name, String type,
-      {int relevance: DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind:
-      CompletionSuggestionKind.INVOCATION, bool isDeprecated: false}) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool isDeprecated: false}) {
+    CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         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,
       [bool isDeprecated = false, int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
-        csKind: kind,
-        relevance: relevance,
-        isDeprecated: isDeprecated);
+    CompletionSuggestion cs = assertSuggest(name,
+        csKind: kind, relevance: relevance, isDeprecated: isDeprecated);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION));
     expect(element.name, equals(name));
     expect(element.isDeprecated, equals(isDeprecated));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
-    expect(
-        element.returnType,
+    expect(element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     assertHasParameterInfo(cs);
     return cs;
   }
 
-  CompletionSuggestion assertSuggestFunctionTypeAlias(String name,
-      String returnType, bool isDeprecated, [int relevance = DART_RELEVANCE_DEFAULT,
+  CompletionSuggestion assertSuggestFunctionTypeAlias(
+      String name, String returnType, bool isDeprecated,
+      [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
-        csKind: kind,
-        relevance: relevance,
-        isDeprecated: isDeprecated);
+    CompletionSuggestion cs = assertSuggest(name,
+        csKind: kind, relevance: relevance, isDeprecated: isDeprecated);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION_TYPE_ALIAS));
     expect(element.name, equals(name));
     expect(element.isDeprecated, equals(isDeprecated));
     // TODO (danrubel) Determine why params are null
 //    String param = element.parameters;
 //    expect(param, isNotNull);
 //    expect(param[0], equals('('));
 //    expect(param[param.length - 1], equals(')'));
-    expect(
-        element.returnType,
+    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, CompletionSuggestionKind kind:
-      CompletionSuggestionKind.INVOCATION, bool isDeprecated: false}) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool isDeprecated: false}) {
+    CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.GETTER,
         isDeprecated: isDeprecated);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.GETTER));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
-    expect(
-        element.returnType,
+    expect(element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
-  CompletionSuggestion assertSuggestLabel(String name, [int relevance =
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.IDENTIFIER]) {
+  CompletionSuggestion assertSuggestLabel(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.IDENTIFIER]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     expect(cs.returnType, isNull);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.flags, 0);
     expect(element.kind, equals(protocol.ElementKind.LABEL));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
-  CompletionSuggestion assertSuggestLibraryPrefix(String prefix, [int relevance
-      = DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestLibraryPrefix(String prefix,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Library prefix should only be suggested by ImportedComputer
     if (computer is ImportedComputer) {
       CompletionSuggestion cs =
           assertSuggest(prefix, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LIBRARY));
       expect(element.parameters, isNull);
       expect(element.returnType, isNull);
       assertHasNoParameterInfo(cs);
       return cs;
     } else {
       return assertNotSuggested(prefix);
     }
   }
 
-  CompletionSuggestion assertSuggestMethod(String name, String declaringType,
-      String returnType, {int relevance: DART_RELEVANCE_DEFAULT,
+  CompletionSuggestion assertSuggestMethod(
+      String name, String declaringType, String returnType,
+      {int relevance: DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
-        csKind: kind,
-        relevance: relevance,
-        isDeprecated: isDeprecated);
+    CompletionSuggestion cs = assertSuggest(name,
+        csKind: kind, relevance: relevance, 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,
+  CompletionSuggestion assertSuggestNamedConstructor(
+      String name, String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is InvocationComputer) {
       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, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
-    CompletionSuggestion cs = assertSuggest(
-        name,
+  CompletionSuggestion assertSuggestSetter(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+    CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.SETTER);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.SETTER));
     expect(element.name, equals(name));
     // TODO (danrubel) assert setter param
     //expect(element.parameters, isNull);
     // TODO (danrubel) it would be better if this was always null
     if (element.returnType != null) {
       expect(element.returnType, 'dynamic');
     }
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestTopLevelVar(String name, String returnType,
-      [int relevance = DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.TOP_LEVEL_VARIABLE));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, returnType != null ? returnType : 'dynamic');
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   void assertSuggestTopLevelVarGetterSetter(String name, String returnType,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       assertSuggestGetter(name, returnType);
       assertSuggestSetter(name);
     } else {
       assertNotSuggested(name);
     }
   }
 
   bool computeFast() {
     _computeFastCalled = true;
-    _completionManager = new DartCompletionManager(
-        context,
-        searchEngine,
-        testSource,
-        cache,
-        [computer],
-        new CommonUsageComputer({}));
+    _completionManager = new DartCompletionManager(context, searchEngine,
+        testSource, cache, [computer], new CommonUsageComputer({}));
     var result = _completionManager.computeFast(request);
     expect(request.replacementOffset, isNotNull);
     expect(request.replacementLength, isNotNull);
     return result.isEmpty;
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     if (!_computeFastCalled) {
       expect(computeFast(), isFalse);
     }
@@ skipping 45 matching lines @@
     }
     return computer.computeFull(request).then(assertFunction);
   }
 
   void failedCompletion(String message,
       [Iterable<CompletionSuggestion> completions]) {
     StringBuffer sb = new StringBuffer(message);
     if (completions != null) {
       sb.write('\n  found');
       completions.toList()
-          ..sort(suggestionComparator)
-          ..forEach((CompletionSuggestion suggestion) {
-            sb.write('\n    ${suggestion.completion} -> $suggestion');
-          });
+        ..sort(suggestionComparator)
+        ..forEach((CompletionSuggestion suggestion) {
+          sb.write('\n    ${suggestion.completion} -> $suggestion');
+        });
     }
     if (completionNode != null) {
       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,
-      CompletionSuggestionKind csKind: null, protocol.ElementKind elemKind: 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',
+        failedCompletion('expected exactly one $cs',
             request.suggestions.where((s) => s.completion == completion));
       }
     });
     return cs;
   }
 
   @override
   void setUp() {
     super.setUp();
     index = createLocalMemoryIndex();
@@ skipping 11 matching lines @@
 abstract class AbstractSelectorSuggestionTest extends AbstractCompletionTest {
 
   /**
    * Assert that the ImportedComputer uses cached results to produce identical
    * suggestions to the original set of suggestions.
    */
   void assertCachedCompute(_) {
     // Subclasses override
   }
 
-  CompletionSuggestion assertSuggestImportedClass(String name, [int relevance =
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestImportedClass(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance: relevance, kind: kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestImportedFunction(String name,
-      String returnType, [bool isDeprecated = false, int relevance =
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestImportedFunction(
+      String name, String returnType, [bool isDeprecated = false,
+      int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunction(
-          name,
-          returnType,
-          isDeprecated,
-          relevance,
-          kind);
+          name, returnType, isDeprecated, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestImportedFunctionTypeAlias(String name,
-      String returnType, [bool isDeprecated = false, int relevance =
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestImportedFunctionTypeAlias(
+      String name, String returnType, [bool isDeprecated = false,
+      int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunctionTypeAlias(
-          name,
-          returnType,
-          isDeprecated,
-          relevance,
-          kind);
+          name, returnType, isDeprecated, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestImportedGetter(String name,
-      String returnType, {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
+  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}) {
+  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}) {
+  CompletionSuggestion assertSuggestImportedSetter(String name,
+      {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestImportedTopLevelVar(String name,
-      String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
+  CompletionSuggestion assertSuggestImportedTopLevelVar(
+      String name, String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestInvocationClass(String name, [int relevance
-      = DART_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestInvocationClass(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestClass(name, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationField(String name, String type,
       {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestInvocationGetter(String name,
-      String returnType, {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated:
-      false}) {
+  CompletionSuggestion assertSuggestInvocationGetter(
+      String name, String returnType,
+      {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     if (computer is InvocationComputer) {
-      return assertSuggestGetter(
-          name,
-          returnType,
-          relevance: relevance,
-          isDeprecated: isDeprecated);
+      return assertSuggestGetter(name, returnType,
+          relevance: relevance, isDeprecated: isDeprecated);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestInvocationMethod(String name,
-      String declaringType, String returnType, [int relevance =
-      DART_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestInvocationMethod(
+      String name, String declaringType, String returnType,
+      [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
-      return assertSuggestMethod(
-          name,
-          declaringType,
-          returnType,
+      return assertSuggestMethod(name, declaringType, returnType,
           relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestInvocationSetter(String name, [int relevance
-      = DART_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestInvocationSetter(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestSetter(name);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestInvocationTopLevelVar(String name,
-      String returnType, [int relevance = DART_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestInvocationTopLevelVar(
+      String name, String returnType,
+      [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestLocalClass(String name, {int relevance:
-      DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+  CompletionSuggestion assertSuggestLocalClass(String name,
+      {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
       {int relevance: DART_RELEVANCE_DEFAULT}) {
     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, int relevance:
-      DART_RELEVANCE_LOCAL_FUNCTION}) {
+  CompletionSuggestion assertSuggestLocalFunction(
+      String name, String returnType,
+      {bool deprecated: false, int relevance: DART_RELEVANCE_LOCAL_FUNCTION}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestLocalFunctionTypeAlias(String name,
-      String returnType, {bool deprecated: false, int relevance:
-      DART_RELEVANCE_DEFAULT}) {
+  CompletionSuggestion assertSuggestLocalFunctionTypeAlias(
+      String name, String returnType,
+      {bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
       {int relevance: DART_RELEVANCE_LOCAL_ACCESSOR, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestLocalMethod(String name,
-      String declaringType, String returnType, {int relevance:
-      DART_RELEVANCE_LOCAL_METHOD, bool deprecated: false}) {
+  CompletionSuggestion assertSuggestLocalMethod(
+      String name, String declaringType, String returnType,
+      {int relevance: DART_RELEVANCE_LOCAL_METHOD, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestLocalSetter(String name, {int relevance:
-      DART_RELEVANCE_LOCAL_ACCESSOR}) {
+  CompletionSuggestion assertSuggestLocalSetter(String name,
+      {int relevance: DART_RELEVANCE_LOCAL_ACCESSOR}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
-      String returnType, {int relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE}) {
+  CompletionSuggestion assertSuggestLocalTopLevelVar(
+      String name, String returnType,
+      {int relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestLocalVariable(String name,
-      String returnType, {int relevance: DART_RELEVANCE_LOCAL_VARIABLE}) {
+  CompletionSuggestion assertSuggestLocalVariable(
+      String name, String returnType,
+      {int relevance: DART_RELEVANCE_LOCAL_VARIABLE}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestNonLocalClass(String name, [int relevance =
-      DART_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestNonLocalClass(String name,
+      [int relevance = DART_RELEVANCE_DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     return assertSuggestImportedClass(name, relevance, kind);
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
-    return super.computeFull(
-        assertFunction,
-        fullAnalysis: fullAnalysis).then(assertCachedCompute);
+    return super
+        .computeFull(assertFunction, fullAnalysis: fullAnalysis)
+        .then(assertCachedCompute);
   }
 
   test_ArgumentList() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart';
@@ skipping 657 matching lines @@
       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);
-      CompletionSuggestion suggestionA = assertSuggestLocalClass(
-          'A',
-          relevance: DART_RELEVANCE_LOW,
-          isDeprecated: true);
+      CompletionSuggestion suggestionA = assertSuggestLocalClass('A',
+          relevance: DART_RELEVANCE_LOW, isDeprecated: true);
       if (suggestionA != null) {
         expect(suggestionA.element.isDeprecated, isTrue);
         expect(suggestionA.element.isPrivate, isFalse);
       }
       CompletionSuggestion suggestionB = assertSuggestLocalClass('_B');
       if (suggestionB != null) {
         expect(suggestionB.element.isDeprecated, isFalse);
         expect(suggestionB.element.isPrivate, isTrue);
       }
       CompletionSuggestion suggestionO = assertSuggestImportedClass('Object');
@@ skipping 896 matching lines @@
     addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isFalse);
       }
-      CompletionSuggestion getterF = assertSuggestLocalGetter(
-          'f',
-          'X',
-          relevance: DART_RELEVANCE_LOW,
-          deprecated: true);
+      CompletionSuggestion getterF = assertSuggestLocalGetter('f', 'X',
+          relevance: DART_RELEVANCE_LOW, deprecated: true);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
       }
     });
   }
 
   test_MethodDeclaration_members() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X f; Z _a() {^} var _g;}');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isTrue);
       }
-      CompletionSuggestion getterF = assertSuggestLocalField(
-          'f',
-          'X',
-          relevance: DART_RELEVANCE_LOW,
-          deprecated: true);
+      CompletionSuggestion getterF = assertSuggestLocalField('f', 'X',
+          relevance: DART_RELEVANCE_LOW, deprecated: true);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
         expect(getterF.element.parameters, isNull);
       }
       CompletionSuggestion getterG = assertSuggestLocalField('_g', null);
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
         expect(getterF.element.parameters, isNull);
       }
       assertSuggestImportedClass('bool');
     });
   }
 
   test_MethodDeclaration_parameters_named() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated Z a(X x, _, b, {y: boo}) {^}}');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
-      CompletionSuggestion methodA = assertSuggestLocalMethod(
-          'a',
-          'A',
-          'Z',
-          relevance: DART_RELEVANCE_LOW,
-          deprecated: true);
+      CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z',
+          relevance: DART_RELEVANCE_LOW, deprecated: true);
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isTrue);
         expect(methodA.element.isPrivate, isFalse);
       }
       assertSuggestParameter('x', 'X');
       assertSuggestParameter('y', null);
       assertSuggestParameter('b', null);
       assertSuggestImportedClass('int');
       assertNotSuggested('_');
     });
@@ skipping 644 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }