danrubel@google.com
5194a2b1b4
BUG=dartbug.com/22171 R=scheglov@google.com Review URL: https://codereview.chromium.org//908493003 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@43580 260f80e4-7a28-3924-810f-c04153c831b5
2977 lines
99 KiB
Dart
2977 lines
99 KiB
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' hide Element, ElementKind;
|
|
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';
|
|
import 'package:analyzer/src/generated/ast.dart';
|
|
import 'package:analyzer/src/generated/element.dart';
|
|
import 'package:analyzer/src/generated/engine.dart';
|
|
import 'package:analyzer/src/generated/source.dart';
|
|
import 'package:unittest/unittest.dart';
|
|
|
|
import '../../abstract_context.dart';
|
|
|
|
int suggestionComparator(CompletionSuggestion s1, CompletionSuggestion s2) {
|
|
String c1 = s1.completion.toLowerCase();
|
|
String c2 = s2.completion.toLowerCase();
|
|
return c1.compareTo(c2);
|
|
}
|
|
|
|
abstract class AbstractCompletionTest extends AbstractContextTest {
|
|
Index index;
|
|
SearchEngineImpl searchEngine;
|
|
DartCompletionComputer computer;
|
|
String testFile = '/completionTest.dart';
|
|
Source testSource;
|
|
CompilationUnit testUnit;
|
|
int completionOffset;
|
|
AstNode completionNode;
|
|
bool _computeFastCalled = false;
|
|
DartCompletionRequest request;
|
|
DartCompletionCache cache;
|
|
DartCompletionManager _completionManager;
|
|
|
|
void addResolvedUnit(String file, String code) {
|
|
Source source = addSource(file, code);
|
|
CompilationUnit unit = resolveLibraryUnit(source);
|
|
index.indexUnit(context, unit);
|
|
}
|
|
|
|
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());
|
|
}
|
|
|
|
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,
|
|
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);
|
|
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}) {
|
|
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 {
|
|
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) {
|
|
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);
|
|
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) {
|
|
int index = 0;
|
|
while (index < expectedNames.length) {
|
|
if (actualNames[index] != expectedNames[index] ||
|
|
actualTypes[index] != expectedTypes[index]) {
|
|
break;
|
|
}
|
|
++index;
|
|
}
|
|
if (index == expectedNames.length) {
|
|
return;
|
|
}
|
|
}
|
|
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);
|
|
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 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,
|
|
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);
|
|
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,
|
|
equals(returnType != null ? returnType : 'dynamic'));
|
|
assertHasParameterInfo(cs);
|
|
return cs;
|
|
}
|
|
|
|
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);
|
|
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,
|
|
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,
|
|
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,
|
|
equals(returnType != null ? returnType : 'dynamic'));
|
|
assertHasNoParameterInfo(cs);
|
|
return cs;
|
|
}
|
|
|
|
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]) {
|
|
// 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,
|
|
CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
|
|
bool isDeprecated: false}) {
|
|
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,
|
|
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,
|
|
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]) {
|
|
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]);
|
|
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);
|
|
}
|
|
|
|
// 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);
|
|
if (libSourceList.length > 0) {
|
|
LibraryElement library = context.getLibraryElement(libSourceList[0]);
|
|
if (library != null) {
|
|
CompilationUnit unit =
|
|
context.getResolvedCompilationUnit(testSource, library);
|
|
if (unit != null) {
|
|
request.unit = unit;
|
|
request.node =
|
|
new NodeLocator.con1(completionOffset).searchWithin(unit);
|
|
resolved = true;
|
|
if (!fullAnalysis) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
result = context.performAnalysisTask();
|
|
}
|
|
if (!resolved) {
|
|
fail('expected unit to be resolved');
|
|
}
|
|
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');
|
|
});
|
|
}
|
|
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}) {
|
|
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;
|
|
}
|
|
|
|
@override
|
|
void setUp() {
|
|
super.setUp();
|
|
index = createLocalMemoryIndex();
|
|
searchEngine = new SearchEngineImpl(index);
|
|
setUpComputer();
|
|
}
|
|
|
|
void setUpComputer();
|
|
}
|
|
|
|
/**
|
|
* Common tests for `ImportedTypeComputerTest`, `InvocationComputerTest`,
|
|
* and `LocalComputerTest`.
|
|
*/
|
|
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]) {
|
|
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]) {
|
|
if (computer is ImportedComputer) {
|
|
return assertSuggestFunction(
|
|
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]) {
|
|
if (computer is ImportedComputer) {
|
|
return assertSuggestFunctionTypeAlias(
|
|
name,
|
|
returnType,
|
|
isDeprecated,
|
|
relevance,
|
|
kind);
|
|
} else {
|
|
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,
|
|
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]) {
|
|
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}) {
|
|
if (computer is InvocationComputer) {
|
|
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]) {
|
|
if (computer is InvocationComputer) {
|
|
return assertSuggestMethod(
|
|
name,
|
|
declaringType,
|
|
returnType,
|
|
relevance: relevance);
|
|
} else {
|
|
return assertNotSuggested(name);
|
|
}
|
|
}
|
|
|
|
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]) {
|
|
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}) {
|
|
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}) {
|
|
return assertNotSuggested(name);
|
|
}
|
|
|
|
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}) {
|
|
return assertNotSuggested(name);
|
|
}
|
|
|
|
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}) {
|
|
return assertNotSuggested(name);
|
|
}
|
|
|
|
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]) {
|
|
return assertSuggestImportedClass(name, relevance, kind);
|
|
}
|
|
|
|
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', '''
|
|
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', '''
|
|
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_local_function() {
|
|
// ArgumentList MethodInvocation ExpressionStatement Block
|
|
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', '''
|
|
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_namedParam() {
|
|
// SimpleIdentifier NamedExpression ArgumentList MethodInvocation
|
|
// ExpressionStatement
|
|
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);
|
|
assertSuggestLocalFunction('bar', 'String');
|
|
assertSuggestImportedFunction('hasLength', 'bool');
|
|
assertNotSuggested('main');
|
|
});
|
|
}
|
|
|
|
test_AsExpression() {
|
|
// SimpleIdentifier TypeName AsExpression
|
|
addTestSource('''
|
|
class A {var b; X _c; foo() {var a; (a as ^).foo();}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertNotSuggested('b');
|
|
assertNotSuggested('_c');
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestLocalClass('A');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_AssignmentExpression_name() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
addTestSource('class A {} main() {int a; int ^b = 1;}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_AssignmentExpression_RHS() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
addTestSource('class A {} main() {int a; int b = ^}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', 'int');
|
|
assertSuggestLocalFunction('main', null);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_AssignmentExpression_type() {
|
|
// SimpleIdentifier TypeName VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
addTestSource('''
|
|
class A {} main() {
|
|
int a;
|
|
^ b = 1;}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('int');
|
|
// TODO (danrubel) When entering 1st of 2 identifiers on assignment LHS
|
|
// the user may be either (1) entering a type for the assignment
|
|
// or (2) starting a new statement.
|
|
// Consider suggesting only types
|
|
// if only spaces separates the 1st and 2nd identifiers.
|
|
//assertNotSuggested('a');
|
|
//assertNotSuggested('main');
|
|
//assertNotSuggested('identical');
|
|
});
|
|
}
|
|
|
|
test_AssignmentExpression_type_newline() {
|
|
// SimpleIdentifier TypeName VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
addTestSource('''
|
|
class A {} main() {
|
|
int a;
|
|
^
|
|
b = 1;}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('int');
|
|
// Allow non-types preceding an identifier on LHS of assignment
|
|
// if newline follows first identifier
|
|
// because user is probably starting a new statement
|
|
assertSuggestLocalVariable('a', 'int');
|
|
assertSuggestLocalFunction('main', null);
|
|
assertSuggestImportedFunction('identical', 'bool');
|
|
});
|
|
}
|
|
|
|
test_AssignmentExpression_type_partial() {
|
|
// SimpleIdentifier TypeName VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
addTestSource('''
|
|
class A {} main() {
|
|
int a;
|
|
int^ b = 1;}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 3);
|
|
expect(request.replacementLength, 3);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('int');
|
|
// TODO (danrubel) When entering 1st of 2 identifiers on assignment LHS
|
|
// the user may be either (1) entering a type for the assignment
|
|
// or (2) starting a new statement.
|
|
// Consider suggesting only types
|
|
// if only spaces separates the 1st and 2nd identifiers.
|
|
//assertNotSuggested('a');
|
|
//assertNotSuggested('main');
|
|
//assertNotSuggested('identical');
|
|
});
|
|
}
|
|
|
|
test_AssignmentExpression_type_partial_newline() {
|
|
// SimpleIdentifier TypeName VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
addTestSource('''
|
|
class A {} main() {
|
|
int a;
|
|
i^
|
|
b = 1;}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('int');
|
|
// Allow non-types preceding an identifier on LHS of assignment
|
|
// if newline follows first identifier
|
|
// because user is probably starting a new statement
|
|
assertSuggestLocalVariable('a', 'int');
|
|
assertSuggestLocalFunction('main', null);
|
|
assertSuggestImportedFunction('identical', 'bool');
|
|
});
|
|
}
|
|
|
|
test_AwaitExpression() {
|
|
// SimpleIdentifier AwaitExpression ExpressionStatement
|
|
addTestSource('''
|
|
class A {int x; int y() => 0;}
|
|
main() async {A a; await ^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', 'A');
|
|
assertSuggestLocalFunction('main', null);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_BinaryExpression_LHS() {
|
|
// SimpleIdentifier BinaryExpression VariableDeclaration
|
|
// VariableDeclarationList VariableDeclarationStatement
|
|
addTestSource('main() {int a = 1, b = ^ + 2;}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', 'int');
|
|
assertSuggestImportedClass('Object');
|
|
assertNotSuggested('b');
|
|
});
|
|
}
|
|
|
|
test_BinaryExpression_RHS() {
|
|
// SimpleIdentifier BinaryExpression VariableDeclaration
|
|
// VariableDeclarationList VariableDeclarationStatement
|
|
addTestSource('main() {int a = 1, b = 2 + ^;}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', 'int');
|
|
assertSuggestImportedClass('Object');
|
|
assertNotSuggested('b');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_Block() {
|
|
// Block BlockFunctionBody MethodDeclaration
|
|
addSource('/testAB.dart', '''
|
|
export "dart:math" hide max;
|
|
class A {int x;}
|
|
@deprecated D1() {int x;}
|
|
class _B { }''');
|
|
addSource('/testCD.dart', '''
|
|
String T1;
|
|
var _T2;
|
|
class C { }
|
|
class D { }''');
|
|
addSource('/testEEF.dart', '''
|
|
class EE { }
|
|
class F { }''');
|
|
addSource('/testG.dart', 'class G { }');
|
|
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;
|
|
String get T7 => 'hello';
|
|
set T8(int value) { }
|
|
Z D2() {int x;}
|
|
class X {
|
|
int get clog => 8;
|
|
set blog(value) { }
|
|
a() {
|
|
var f;
|
|
localF(int arg1) { }
|
|
{var x;}
|
|
^ var r;
|
|
}
|
|
void b() { }}
|
|
class Z { }''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
|
|
assertSuggestLocalClass('X');
|
|
assertSuggestLocalClass('Z');
|
|
assertSuggestLocalMethod('a', 'X', null);
|
|
assertSuggestLocalMethod('b', 'X', 'void');
|
|
assertSuggestLocalFunction('localF', null);
|
|
assertSuggestLocalVariable('f', null);
|
|
// Don't suggest locals out of scope
|
|
assertNotSuggested('r');
|
|
assertNotSuggested('x');
|
|
|
|
assertSuggestImportedClass('A');
|
|
assertNotSuggested('_B');
|
|
assertSuggestImportedClass('C');
|
|
// hidden element suggested as low relevance
|
|
// but imported results are partially filtered
|
|
//assertSuggestImportedClass('D', COMPLETION_RELEVANCE_LOW);
|
|
//assertSuggestImportedFunction(
|
|
// 'D1', null, true, COMPLETION_RELEVANCE_LOW);
|
|
assertSuggestLocalFunction('D2', 'Z');
|
|
assertSuggestImportedClass('EE');
|
|
// hidden element suggested as low relevance
|
|
//assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
|
|
assertSuggestLibraryPrefix('g');
|
|
assertNotSuggested('G');
|
|
//assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestImportedFunction('min', 'num', false);
|
|
//assertSuggestImportedFunction(
|
|
// 'max',
|
|
// 'num',
|
|
// false,
|
|
// COMPLETION_RELEVANCE_LOW);
|
|
assertSuggestTopLevelVarGetterSetter('T1', 'String');
|
|
assertNotSuggested('_T2');
|
|
//assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
|
|
assertNotSuggested('_T4');
|
|
assertSuggestLocalTopLevelVar('T5', 'int');
|
|
assertSuggestLocalTopLevelVar('_T6', null);
|
|
assertNotSuggested('==');
|
|
assertSuggestLocalGetter('T7', 'String');
|
|
assertSuggestLocalSetter('T8');
|
|
assertSuggestLocalGetter('clog', 'int');
|
|
assertSuggestLocalSetter('blog');
|
|
// TODO (danrubel) suggest HtmlElement as low relevance
|
|
assertNotSuggested('HtmlElement');
|
|
});
|
|
}
|
|
|
|
test_Block_identifier_partial() {
|
|
addSource('/testAB.dart', '''
|
|
export "dart:math" hide max;
|
|
class A {int x;}
|
|
@deprecated D1() {int x;}
|
|
class _B { }''');
|
|
addSource('/testCD.dart', '''
|
|
String T1;
|
|
var _T2;
|
|
class C { }
|
|
class D { }''');
|
|
addSource('/testEEF.dart', '''
|
|
class EE { }
|
|
class F { }''');
|
|
addSource('/testG.dart', 'class G { }');
|
|
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;
|
|
Z D2() {int x;}
|
|
class X {a() {var f; {var x;} D^ var r;} void b() { }}
|
|
class Z { }''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
|
|
assertSuggestLocalClass('X');
|
|
assertSuggestLocalClass('Z');
|
|
assertSuggestLocalMethod('a', 'X', null);
|
|
assertSuggestLocalMethod('b', 'X', 'void');
|
|
assertSuggestLocalVariable('f', null);
|
|
// Don't suggest locals out of scope
|
|
assertNotSuggested('r');
|
|
assertNotSuggested('x');
|
|
|
|
// imported elements are portially filtered
|
|
//assertSuggestImportedClass('A');
|
|
assertNotSuggested('_B');
|
|
//assertSuggestImportedClass('C');
|
|
// hidden element suggested as low relevance
|
|
assertSuggestImportedClass('D', DART_RELEVANCE_LOW);
|
|
assertSuggestImportedFunction('D1', null, true, DART_RELEVANCE_LOW);
|
|
assertSuggestLocalFunction('D2', 'Z');
|
|
//assertSuggestImportedClass('EE');
|
|
// hidden element suggested as low relevance
|
|
//assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
|
|
//assertSuggestLibraryPrefix('g');
|
|
assertNotSuggested('G');
|
|
//assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
|
|
//assertSuggestImportedClass('Object');
|
|
//assertSuggestImportedFunction('min', 'num', false);
|
|
//assertSuggestImportedFunction(
|
|
// 'max',
|
|
// 'num',
|
|
// false,
|
|
// COMPLETION_RELEVANCE_LOW);
|
|
//assertSuggestTopLevelVarGetterSetter('T1', 'String');
|
|
assertNotSuggested('_T2');
|
|
//assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
|
|
assertNotSuggested('_T4');
|
|
//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', '''
|
|
lib B;
|
|
class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
|
|
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) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
// TODO (danrubel) prefer fields over getters
|
|
// If add `get e1;` to interface I
|
|
// then suggestions include getter e1 rather than field e1
|
|
assertSuggestImportedField('e1', null);
|
|
assertSuggestImportedField('f1', null);
|
|
assertSuggestImportedField('i1', 'int');
|
|
assertSuggestImportedField('m1', null);
|
|
assertSuggestImportedGetter('f3', null);
|
|
assertSuggestImportedSetter('f4');
|
|
assertSuggestImportedMethod('e2', 'E', null);
|
|
assertSuggestImportedMethod('f2', 'F', null);
|
|
assertSuggestImportedMethod('i2', 'I', null);
|
|
//assertSuggestImportedMethod('m2', null, null);
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_Block_inherited_local() {
|
|
// Block BlockFunctionBody MethodDeclaration ClassDeclaration
|
|
addTestSource('''
|
|
class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
|
|
class E extends F { var e1; e2() { } }
|
|
class I { int i1; i2() { } }
|
|
class M { var m1; int m2() { } }
|
|
class A extends E implements I with M {a() {^}}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalField('e1', null);
|
|
assertSuggestLocalField('f1', null);
|
|
assertSuggestLocalField('i1', 'int');
|
|
assertSuggestLocalField('m1', null);
|
|
assertSuggestLocalGetter('f3', null);
|
|
assertSuggestLocalSetter('f4');
|
|
assertSuggestLocalMethod('e2', 'E', null);
|
|
assertSuggestLocalMethod('f2', 'F', null);
|
|
assertSuggestLocalMethod('i2', 'I', null);
|
|
assertSuggestLocalMethod('m2', 'M', 'int');
|
|
});
|
|
}
|
|
|
|
test_CascadeExpression_selector1() {
|
|
// PropertyAccess CascadeExpression ExpressionStatement Block
|
|
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', '''
|
|
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', '''
|
|
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);
|
|
assertSuggestInvocationField('b', null);
|
|
assertSuggestInvocationField('_c', 'X');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('B');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_CascadeExpression_target() {
|
|
// SimpleIdentifier CascadeExpression ExpressionStatement
|
|
addTestSource('''
|
|
class A {var b; X _c;}
|
|
class X{}
|
|
main() {A a; a^..b}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
assertNotSuggested('b');
|
|
assertNotSuggested('_c');
|
|
assertSuggestLocalVariable('a', 'A');
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestLocalClass('X');
|
|
// top level results are partially filtered
|
|
//assertSuggestImportedClass('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_CatchClause_typed() {
|
|
// Block CatchClause TryStatement
|
|
addTestSource('class A {a() {try{var x;} on E catch (e) {^}}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestParameter('e', 'E');
|
|
assertSuggestLocalMethod('a', 'A', null);
|
|
assertSuggestImportedClass('Object');
|
|
assertNotSuggested('x');
|
|
});
|
|
}
|
|
|
|
test_CatchClause_untyped() {
|
|
// Block CatchClause TryStatement
|
|
addTestSource('class A {a() {try{var x;} catch (e, s) {^}}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestParameter('e', null);
|
|
assertSuggestParameter('s', 'StackTrace');
|
|
assertSuggestLocalMethod('a', 'A', null);
|
|
assertSuggestImportedClass('Object');
|
|
assertNotSuggested('x');
|
|
});
|
|
}
|
|
|
|
test_ClassDeclaration_body() {
|
|
// ClassDeclaration CompilationUnit
|
|
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);
|
|
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');
|
|
if (suggestionO != null) {
|
|
expect(suggestionO.element.isDeprecated, isFalse);
|
|
expect(suggestionO.element.isPrivate, isFalse);
|
|
}
|
|
assertNotSuggested('T');
|
|
assertSuggestLibraryPrefix('x');
|
|
});
|
|
}
|
|
|
|
test_Combinator_hide() {
|
|
// SimpleIdentifier HideCombinator ImportDirective
|
|
addSource('/testAB.dart', '''
|
|
library libAB;
|
|
part '/partAB.dart';
|
|
class A { }
|
|
class B { }''');
|
|
addSource('/partAB.dart', '''
|
|
part of libAB;
|
|
var T1;
|
|
PB F1() => new PB();
|
|
class PB { }''');
|
|
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', '''
|
|
library libAB;
|
|
part '/partAB.dart';
|
|
class A { }
|
|
class B { }''');
|
|
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', '''
|
|
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', '''
|
|
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', '''
|
|
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', '''
|
|
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', '''
|
|
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', '''
|
|
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', '''
|
|
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', '''
|
|
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) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestNamedConstructor('c', 'X');
|
|
assertNotSuggested('F1');
|
|
assertNotSuggested('T1');
|
|
assertNotSuggested('_d');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('m');
|
|
});
|
|
}
|
|
|
|
test_ConstructorName_importedFactory2() {
|
|
// SimpleIdentifier PrefixedIdentifier TypeName ConstructorName
|
|
// InstanceCreationExpression
|
|
addTestSource('''
|
|
main() {new String.fr^omCharCodes([]);}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 2);
|
|
expect(request.replacementLength, 13);
|
|
assertSuggestNamedConstructor('fromCharCodes', 'String');
|
|
assertNotSuggested('isEmpty');
|
|
assertNotSuggested('isNotEmpty');
|
|
assertNotSuggested('length');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('String');
|
|
});
|
|
}
|
|
|
|
test_ConstructorName_localClass() {
|
|
// SimpleIdentifier PrefixedIdentifier TypeName ConstructorName
|
|
// InstanceCreationExpression
|
|
addTestSource('''
|
|
int T1;
|
|
F1() { }
|
|
class X {X.c(); X._d(); z() {}}
|
|
main() {new X.^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestNamedConstructor('c', 'X');
|
|
assertSuggestNamedConstructor('_d', 'X');
|
|
assertNotSuggested('F1');
|
|
assertNotSuggested('T1');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('m');
|
|
});
|
|
}
|
|
|
|
test_ConstructorName_localFactory() {
|
|
// SimpleIdentifier PrefixedIdentifier TypeName ConstructorName
|
|
// InstanceCreationExpression
|
|
addTestSource('''
|
|
int T1;
|
|
F1() { }
|
|
class X {factory X.c(); factory X._d(); z() {}}
|
|
main() {new X.^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestNamedConstructor('c', 'X');
|
|
assertSuggestNamedConstructor('_d', 'X');
|
|
assertNotSuggested('F1');
|
|
assertNotSuggested('T1');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('m');
|
|
});
|
|
}
|
|
|
|
test_DefaultFormalParameter_named_expression() {
|
|
// DefaultFormalParameter FormalParameterList MethodDeclaration
|
|
addTestSource('''
|
|
foo() { }
|
|
void bar() { }
|
|
class A {a(blat: ^) { }}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalFunction('foo', null);
|
|
assertSuggestLocalMethod('a', 'A', null);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('String');
|
|
assertSuggestImportedFunction('identical', 'bool');
|
|
assertNotSuggested('bar');
|
|
});
|
|
}
|
|
|
|
test_ExpressionStatement_identifier() {
|
|
// SimpleIdentifier ExpressionStatement Block
|
|
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', false);
|
|
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', '''
|
|
B T1;
|
|
class B{}''');
|
|
addTestSource('''
|
|
import "/testA.dart";
|
|
class C {a() {C ^}}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_FieldDeclaration_name_typed() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// FieldDeclaration
|
|
addSource('/testA.dart', 'class A { }');
|
|
addTestSource('''
|
|
import "/testA.dart";
|
|
class C {A ^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_FieldDeclaration_name_var() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// FieldDeclaration
|
|
addSource('/testA.dart', 'class A { }');
|
|
addTestSource('''
|
|
import "/testA.dart";
|
|
class C {var ^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_ForEachStatement_body_typed() {
|
|
// Block ForEachStatement
|
|
addTestSource('main(args) {for (int foo in bar) {^}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestParameter('args', null);
|
|
assertSuggestLocalVariable('foo', 'int');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_ForEachStatement_body_untyped() {
|
|
// Block ForEachStatement
|
|
addTestSource('main(args) {for (foo in bar) {^}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestParameter('args', null);
|
|
assertSuggestLocalVariable('foo', null);
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_ForEachStatement_iterable() {
|
|
// SimpleIdentifier ForEachStatement Block
|
|
addTestSource('main(args) {for (int foo in ^) {}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestParameter('args', null);
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_ForEachStatement_loopVariable() {
|
|
// SimpleIdentifier ForEachStatement Block
|
|
addTestSource('main(args) {for (^ in args) {}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertNotSuggested('args');
|
|
assertSuggestImportedClass('String');
|
|
});
|
|
}
|
|
|
|
test_ForEachStatement_loopVariable_type() {
|
|
// SimpleIdentifier ForEachStatement Block
|
|
addTestSource('main(args) {for (^ foo in args) {}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertNotSuggested('args');
|
|
assertNotSuggested('foo');
|
|
assertSuggestImportedClass('String');
|
|
});
|
|
}
|
|
|
|
test_ForEachStatement_loopVariable_type2() {
|
|
// DeclaredIdentifier ForEachStatement Block
|
|
addTestSource('main(args) {for (S^ foo in args) {}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
assertNotSuggested('args');
|
|
assertNotSuggested('foo');
|
|
assertSuggestImportedClass('String');
|
|
});
|
|
}
|
|
|
|
test_FormalParameterList() {
|
|
// FormalParameterList MethodDeclaration
|
|
addTestSource('''
|
|
foo() { }
|
|
void bar() { }
|
|
class A {a(^) { }}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalFunction('foo', null);
|
|
assertSuggestLocalMethod('a', 'A', null);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('String');
|
|
assertSuggestImportedFunction('identical', 'bool');
|
|
assertNotSuggested('bar');
|
|
});
|
|
}
|
|
|
|
test_ForStatement_body() {
|
|
// Block ForStatement
|
|
addTestSource('main(args) {for (int i; i < 10; ++i) {^}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('i', 'int');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_ForStatement_condition() {
|
|
// SimpleIdentifier ForStatement
|
|
addTestSource('main() {for (int index = 0; i^)}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
assertSuggestLocalVariable('index', 'int');
|
|
});
|
|
}
|
|
|
|
test_ForStatement_initializer() {
|
|
// SimpleIdentifier ForStatement
|
|
addTestSource('main() {List a; for (^)}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', 'List');
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestImportedClass('int');
|
|
});
|
|
}
|
|
|
|
test_ForStatement_updaters() {
|
|
// SimpleIdentifier ForStatement
|
|
addTestSource('main() {for (int index = 0; index < 10; i^)}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
assertSuggestLocalVariable('index', 'int');
|
|
});
|
|
}
|
|
|
|
test_ForStatement_updaters_prefix_expression() {
|
|
// SimpleIdentifier PrefixExpression ForStatement
|
|
addTestSource('''
|
|
void bar() { }
|
|
main() {for (int index = 0; index < 10; ++i^)}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 1);
|
|
expect(request.replacementLength, 1);
|
|
assertSuggestLocalVariable('index', 'int');
|
|
assertSuggestLocalFunction('main', null);
|
|
assertNotSuggested('bar');
|
|
});
|
|
}
|
|
|
|
test_FunctionExpression_body_function() {
|
|
// Block BlockFunctionBody FunctionExpression
|
|
addTestSource('''
|
|
void bar() { }
|
|
String foo(List args) {x.then((R b) {^});}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
var f = assertSuggestLocalFunction('foo', 'String', deprecated: false);
|
|
if (f != null) {
|
|
expect(f.element.isPrivate, isFalse);
|
|
}
|
|
assertSuggestLocalFunction('bar', 'void');
|
|
assertSuggestParameter('args', 'List');
|
|
assertSuggestParameter('b', 'R');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_IfStatement() {
|
|
// SimpleIdentifier IfStatement
|
|
addTestSource('''
|
|
class A {var b; X _c; foo() {A a; if (true) ^}}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalField('b', null);
|
|
assertSuggestLocalField('_c', 'X');
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestLocalClass('A');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_IfStatement_condition() {
|
|
// SimpleIdentifier IfStatement Block BlockFunctionBody
|
|
addTestSource('''
|
|
class A {int x; int y() => 0;}
|
|
main(){var a; if (^)}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', null);
|
|
assertSuggestLocalFunction('main', null);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_IfStatement_empty() {
|
|
// SimpleIdentifier IfStatement
|
|
addTestSource('''
|
|
class A {var b; X _c; foo() {A a; if (^) something}}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalField('b', null);
|
|
assertSuggestLocalField('_c', 'X');
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestLocalClass('A');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_IfStatement_invocation() {
|
|
// SimpleIdentifier PrefixIdentifier IfStatement
|
|
addTestSource('''
|
|
main() {var a; if (a.^) something}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationMethod('toString', 'Object', 'String');
|
|
//TODO (danrubel) type for '_c' should be 'X' not null
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_ImportDirective_dart() {
|
|
// SimpleStringLiteral ImportDirective
|
|
addTestSource('''
|
|
import "dart^";
|
|
main() {}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_IndexExpression() {
|
|
// ExpressionStatement Block
|
|
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', '''
|
|
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', '''
|
|
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;} new ^}}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestImportedClass('A');
|
|
assertSuggestLocalClass('B');
|
|
assertSuggestLocalClass('C');
|
|
assertNotSuggested('f');
|
|
assertNotSuggested('x');
|
|
assertNotSuggested('foo');
|
|
assertNotSuggested('F1');
|
|
assertNotSuggested('F2');
|
|
assertNotSuggested('T1');
|
|
assertNotSuggested('T2');
|
|
});
|
|
}
|
|
|
|
test_InterpolationExpression() {
|
|
// SimpleIdentifier InterpolationExpression StringInterpolation
|
|
addTestSource('main() {String name; print("hello \$^");}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('name', 'String');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_InterpolationExpression_block() {
|
|
// SimpleIdentifier InterpolationExpression StringInterpolation
|
|
addTestSource('main() {String name; print("hello \${n^}");}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertSuggestLocalVariable('name', 'String');
|
|
// top level results are partially filtered
|
|
//assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_InterpolationExpression_prefix_selector() {
|
|
// SimpleIdentifier PrefixedIdentifier InterpolationExpression
|
|
addTestSource('main() {String name; print("hello \${name.^}");}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationGetter('length', 'int');
|
|
assertNotSuggested('name');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_InterpolationExpression_prefix_target() {
|
|
// SimpleIdentifier PrefixedIdentifier InterpolationExpression
|
|
addTestSource('main() {String name; print("hello \${nam^e.length}");}');
|
|
computeFast();
|
|
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', '''
|
|
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);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestImportedClass('X');
|
|
assertSuggestLocalClass('Y');
|
|
assertNotSuggested('x');
|
|
assertNotSuggested('main');
|
|
assertNotSuggested('foo');
|
|
});
|
|
}
|
|
|
|
test_IsExpression_target() {
|
|
// IfStatement Block BlockFunctionBody
|
|
addTestSource('''
|
|
foo() { }
|
|
void bar() { }
|
|
class A {int x; int y() => 0;}
|
|
main(){var a; if (^ is A)}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalVariable('a', null);
|
|
assertSuggestLocalFunction('main', null);
|
|
assertSuggestLocalFunction('foo', null);
|
|
assertNotSuggested('bar');
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_IsExpression_type() {
|
|
// SimpleIdentifier TypeName IsExpression IfStatement
|
|
addTestSource('''
|
|
class A {int x; int y() => 0;}
|
|
main(){var a; if (a is ^)}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('main');
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_IsExpression_type_partial() {
|
|
// SimpleIdentifier TypeName IsExpression IfStatement
|
|
addTestSource('''
|
|
class A {int x; int y() => 0;}
|
|
main(){var a; if (a is Obj^)}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 3);
|
|
expect(request.replacementLength, 3);
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('main');
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
});
|
|
}
|
|
|
|
test_keyword() {
|
|
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();}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 3);
|
|
expect(request.replacementLength, 3);
|
|
assertNotSuggested('c');
|
|
assertNotSuggested('_d');
|
|
// Imported suggestion are filtered by 1st character
|
|
assertSuggestImportedFunction('nowIsIt', null);
|
|
assertNotSuggested('T1');
|
|
// TODO (danrubel) this really should be TopLevelVar not getter/setter
|
|
assertSuggestTopLevelVarGetterSetter('newT1', 'int');
|
|
assertNotSuggested('z');
|
|
assertSuggestLocalTopLevelVar('m', 'dynamic');
|
|
assertSuggestLocalFunction('newer', 'String');
|
|
});
|
|
}
|
|
|
|
test_Literal_list() {
|
|
// ']' ListLiteral ArgumentList MethodInvocation
|
|
addTestSource('main() {var Some; print([^]);}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertSuggestLocalVariable('Some', null);
|
|
assertSuggestImportedClass('String');
|
|
});
|
|
}
|
|
|
|
test_Literal_list2() {
|
|
// SimpleIdentifier ListLiteral ArgumentList MethodInvocation
|
|
addTestSource('main() {var Some; print([S^]);}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertSuggestLocalVariable('Some', null);
|
|
assertSuggestImportedClass('String');
|
|
});
|
|
}
|
|
|
|
test_Literal_string() {
|
|
// SimpleStringLiteral ExpressionStatement Block
|
|
addTestSource('class A {a() {"hel^lo"}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_MethodDeclaration_body_getters() {
|
|
// Block BlockFunctionBody MethodDeclaration
|
|
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);
|
|
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);
|
|
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);
|
|
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('_');
|
|
});
|
|
}
|
|
|
|
test_MethodDeclaration_parameters_positional() {
|
|
// Block BlockFunctionBody MethodDeclaration
|
|
addTestSource('''
|
|
foo() { }
|
|
void bar() { }
|
|
class A {Z a(X x, [int y=1]) {^}}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalFunction('foo', null);
|
|
assertSuggestLocalFunction('bar', 'void');
|
|
assertSuggestLocalMethod('a', 'A', 'Z');
|
|
assertSuggestParameter('x', 'X');
|
|
assertSuggestParameter('y', 'int');
|
|
assertSuggestImportedClass('String');
|
|
});
|
|
}
|
|
|
|
test_MethodInvocation_no_semicolon() {
|
|
// MethodInvocation ExpressionStatement Block
|
|
addTestSource('''
|
|
main() { }
|
|
class I {X get f => new A();get _g => new A();}
|
|
class A implements I {
|
|
var b; X _c;
|
|
X get d => new A();get _e => new A();
|
|
// no semicolon between completion point and next statement
|
|
set s1(I x) {} set _s2(I x) {x.^ m(null);}
|
|
m(X x) {} I _n(X x) {}}
|
|
class X{}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationGetter('f', 'X');
|
|
assertSuggestInvocationGetter('_g', null);
|
|
assertNotSuggested('b');
|
|
assertNotSuggested('_c');
|
|
assertNotSuggested('d');
|
|
assertNotSuggested('_e');
|
|
assertNotSuggested('s1');
|
|
assertNotSuggested('_s2');
|
|
assertNotSuggested('m');
|
|
assertNotSuggested('_n');
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_partFile_TypeName() {
|
|
// SimpleIdentifier TypeName ConstructorName
|
|
addSource('/testB.dart', '''
|
|
lib B;
|
|
int T1;
|
|
F1() { }
|
|
class X {X.c(); X._d(); z() {}}''');
|
|
addSource('/testA.dart', '''
|
|
library libA;
|
|
import "/testB.dart";
|
|
part "$testFile";
|
|
class A { }
|
|
var m;''');
|
|
addTestSource('''
|
|
part of libA;
|
|
class B { }
|
|
main() {new ^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalClass('B');
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestImportedClass('X');
|
|
assertSuggestNonLocalClass('A');
|
|
assertNotSuggested('F1');
|
|
assertNotSuggested('T1');
|
|
assertNotSuggested('_d');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('m');
|
|
});
|
|
}
|
|
|
|
test_partFile_TypeName2() {
|
|
// SimpleIdentifier TypeName ConstructorName
|
|
addSource('/testB.dart', '''
|
|
lib B;
|
|
int T1;
|
|
F1() { }
|
|
class X {X.c(); X._d(); z() {}}''');
|
|
addSource('/testA.dart', '''
|
|
part of libA;
|
|
class B { }''');
|
|
addTestSource('''
|
|
library libA;
|
|
import "/testB.dart";
|
|
part "/testA.dart";
|
|
class A { }
|
|
main() {new ^}
|
|
var m;''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestLocalClass('A');
|
|
assertSuggestImportedClass('Object');
|
|
assertSuggestImportedClass('X');
|
|
assertSuggestNonLocalClass('B');
|
|
assertNotSuggested('F1');
|
|
assertNotSuggested('T1');
|
|
assertNotSuggested('_d');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('m');
|
|
});
|
|
}
|
|
|
|
test_PrefixedIdentifier_class_const() {
|
|
// SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
|
|
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) {}
|
|
m(X x) {} I _n(X x) {}}
|
|
class X{}''');
|
|
addTestSource('''
|
|
import "/testB.dart";
|
|
class A extends B {
|
|
static const String scA = 'foo';
|
|
w() { }}
|
|
main() {A.^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationField('scA', 'String');
|
|
assertSuggestInvocationField('scB', 'int');
|
|
assertSuggestInvocationField('scI', null);
|
|
assertNotSuggested('b');
|
|
assertNotSuggested('_c');
|
|
assertNotSuggested('d');
|
|
assertNotSuggested('_e');
|
|
assertNotSuggested('f');
|
|
assertNotSuggested('_g');
|
|
assertNotSuggested('s1');
|
|
assertNotSuggested('_s2');
|
|
assertNotSuggested('m');
|
|
assertNotSuggested('_n');
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('w');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_PrefixedIdentifier_class_imported() {
|
|
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
|
|
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('''
|
|
import "/testB.dart";
|
|
main() {A a; a.^}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertNotSuggested('sc');
|
|
assertSuggestInvocationField('b', null, isDeprecated: true);
|
|
assertNotSuggested('_c');
|
|
assertSuggestInvocationGetter('d', 'X');
|
|
assertNotSuggested('_e');
|
|
assertSuggestInvocationGetter('f', 'X');
|
|
assertNotSuggested('_g');
|
|
assertSuggestInvocationSetter('s1');
|
|
assertNotSuggested('_s2');
|
|
assertSuggestInvocationMethod('m', 'A', null);
|
|
assertNotSuggested('_n');
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_PrefixedIdentifier_class_local() {
|
|
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
|
|
addTestSource('''
|
|
main() {A a; a.^}
|
|
class I {X get f => new A();get _g => new A();}
|
|
class A implements I {
|
|
static const int sc = 12;
|
|
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{}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertNotSuggested('sc');
|
|
assertSuggestInvocationField('b', null);
|
|
assertSuggestInvocationField('_c', 'X');
|
|
assertSuggestInvocationGetter('d', 'X');
|
|
assertSuggestInvocationGetter('_e', null);
|
|
assertSuggestInvocationGetter('f', 'X');
|
|
assertSuggestInvocationGetter('_g', null);
|
|
assertSuggestInvocationSetter('s1');
|
|
assertSuggestInvocationSetter('_s2');
|
|
assertSuggestInvocationMethod('m', 'A', null);
|
|
assertSuggestInvocationMethod('_n', 'A', 'I');
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_PrefixedIdentifier_library() {
|
|
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
|
|
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_parameter() {
|
|
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
|
|
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', '''
|
|
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');
|
|
assertSuggestLocalClass('X');
|
|
assertSuggestLocalMethod('foo', 'X', null);
|
|
assertNotSuggested('bar');
|
|
assertNotSuggested('_B');
|
|
});
|
|
}
|
|
|
|
test_PrefixedIdentifier_propertyAccess() {
|
|
// PrefixedIdentifier ExpressionStatement Block BlockFunctionBody
|
|
addTestSource('class A {String x; int get foo {x.^}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationGetter('isEmpty', 'bool');
|
|
assertSuggestInvocationMethod('compareTo', 'Comparable', 'int');
|
|
});
|
|
}
|
|
|
|
test_PrefixedIdentifier_propertyAccess_newStmt() {
|
|
// PrefixedIdentifier ExpressionStatement Block BlockFunctionBody
|
|
addTestSource('class A {String x; int get foo {x.^ int y = 0;}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationGetter('isEmpty', 'bool');
|
|
assertSuggestInvocationMethod('compareTo', 'Comparable', 'int');
|
|
});
|
|
}
|
|
|
|
test_PropertyAccess_expression() {
|
|
// SimpleIdentifier MethodInvocation PropertyAccess ExpressionStatement
|
|
addTestSource('class A {a() {"hello".to^String().length}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset - 2);
|
|
expect(request.replacementLength, 8);
|
|
assertSuggestInvocationGetter('length', 'int');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_PropertyAccess_selector() {
|
|
// SimpleIdentifier PropertyAccess ExpressionStatement Block
|
|
addTestSource('class A {a() {"hello".length.^}}');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationGetter('isEven', 'bool');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('a');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_ThisExpression_block() {
|
|
// MethodInvocation ExpressionStatement Block
|
|
addTestSource('''
|
|
main() { }
|
|
class I {X get f => new A();get _g => new A();}
|
|
class A implements I {
|
|
A() {}
|
|
A.z() {}
|
|
var b; X _c;
|
|
X get d => new A();get _e => new A();
|
|
// no semicolon between completion point and next statement
|
|
set s1(I x) {} set _s2(I x) {this.^ m(null);}
|
|
m(X x) {} I _n(X x) {}}
|
|
class X{}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationField('b', null);
|
|
assertSuggestInvocationField('_c', 'X');
|
|
assertSuggestInvocationGetter('d', 'X');
|
|
assertSuggestInvocationGetter('_e', null);
|
|
assertSuggestInvocationGetter('f', 'X');
|
|
assertSuggestInvocationGetter('_g', null);
|
|
assertSuggestInvocationMethod('m', 'A', null);
|
|
assertSuggestInvocationMethod('_n', 'A', 'I');
|
|
assertSuggestInvocationSetter('s1');
|
|
assertSuggestInvocationSetter('_s2');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('I');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_ThisExpression_constructor() {
|
|
// MethodInvocation ExpressionStatement Block
|
|
addTestSource('''
|
|
main() { }
|
|
class I {X get f => new A();get _g => new A();}
|
|
class A implements I {
|
|
A() {this.^}
|
|
A.z() {}
|
|
var b; X _c;
|
|
X get d => new A();get _e => new A();
|
|
// no semicolon between completion point and next statement
|
|
set s1(I x) {} set _s2(I x) {m(null);}
|
|
m(X x) {} I _n(X x) {}}
|
|
class X{}''');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
expect(request.replacementOffset, completionOffset);
|
|
expect(request.replacementLength, 0);
|
|
assertSuggestInvocationField('b', null);
|
|
assertSuggestInvocationField('_c', 'X');
|
|
assertSuggestInvocationGetter('d', 'X');
|
|
assertSuggestInvocationGetter('_e', null);
|
|
assertSuggestInvocationGetter('f', 'X');
|
|
assertSuggestInvocationGetter('_g', null);
|
|
assertSuggestInvocationMethod('m', 'A', null);
|
|
assertSuggestInvocationMethod('_n', 'A', 'I');
|
|
assertSuggestInvocationSetter('s1');
|
|
assertSuggestInvocationSetter('_s2');
|
|
assertNotSuggested('z');
|
|
assertNotSuggested('I');
|
|
assertNotSuggested('A');
|
|
assertNotSuggested('X');
|
|
assertNotSuggested('Object');
|
|
assertNotSuggested('==');
|
|
});
|
|
}
|
|
|
|
test_TopLevelVariableDeclaration_typed_name() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// TopLevelVariableDeclaration
|
|
addTestSource('class A {} B ^');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_TopLevelVariableDeclaration_untyped_name() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// TopLevelVariableDeclaration
|
|
addTestSource('class A {} var ^');
|
|
computeFast();
|
|
return computeFull((bool result) {
|
|
assertNoSuggestions();
|
|
});
|
|
}
|
|
|
|
test_VariableDeclaration_name() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// VariableDeclarationStatement Block
|
|
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_VariableDeclarationStatement_RHS() {
|
|
// SimpleIdentifier VariableDeclaration VariableDeclarationList
|
|
// VariableDeclarationStatement
|
|
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', '''
|
|
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');
|
|
});
|
|
}
|
|
}
|