Rollback https://codereview.chromium.org/1380223003

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/analysis_server.dart';
 import 'package:analysis_server/src/protocol.dart' as protocol
@@ skipping 102 matching lines @@
   }
 
   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,
-      docCompleteMatcher,
-      docSummaryMatcher}) {
+      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 11 matching lines @@
       expect(cs.element.location.length, isNotNull);
       expect(cs.element.location.startColumn, isNotNull);
       expect(cs.element.location.startLine, isNotNull);
     }
     if (elemFile != null) {
       expect(cs.element.location.file, elemFile);
     }
     if (elemOffset != null) {
       expect(cs.element.location.offset, elemOffset);
     }
-    if (docCompleteMatcher != null) {
-      expect(cs.docComplete, docCompleteMatcher);
-    }
-    if (docSummaryMatcher != null) {
-      expect(cs.docSummary, docSummaryMatcher);
-    }
     return cs;
   }
 
   CompletionSuggestion assertSuggestClass(String name,
       {int relevance: DART_RELEVANCE_DEFAULT,
       String importUri,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false,
       String elemFile,
-      int elemOffset,
-      docCompleteMatcher,
-      docSummaryMatcher}) {
+      int elemOffset}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
         isDeprecated: isDeprecated,
         elemFile: elemFile,
-        elemOffset: elemOffset,
-        docCompleteMatcher: docCompleteMatcher,
-        docSummaryMatcher: docSummaryMatcher);
+        elemOffset: elemOffset);
     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;
   }
 
@@ skipping 47 matching lines @@
     // 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,
-      String importUri,
-      docCompleteMatcher,
-      docSummaryMatcher}) {
+      String importUri}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
-        isDeprecated: deprecated,
-        docCompleteMatcher: docCompleteMatcher,
-        docSummaryMatcher: docSummaryMatcher);
+        isDeprecated: deprecated);
     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(deprecated));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
@@ skipping 76 matching lines @@
       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,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      bool isDeprecated: false,
-      docCompleteMatcher,
-      docSummaryMatcher}) {
+      bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         importUri: importUri,
-        isDeprecated: isDeprecated,
-        docCompleteMatcher: docCompleteMatcher,
-        docSummaryMatcher: docSummaryMatcher);
+        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(')'));
@@ skipping 4346 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }