Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(325)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart

Issue 1526303003: convert ImportedReferenceContributor to new API (Closed) Base URL: git@github.com:dart-lang/sdk.git@master
Patch Set: merge Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/analysis_server/test/services/completion/completion_test_util.dart ('k') | pkg/analysis_server/test/services/completion/dart/library_member_contributor_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
diff --git a/pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
similarity index 80%
copy from pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart
copy to pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
index 8d176b8ebd9580d11c3202c78ad4761d41b2fcd0..231ce1d56ddb257ce15053df93a06ab7d83f0905 100644
--- a/pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
@@ -1,270 +1,271 @@
-// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// 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.contributor.dart.type_member;
+library test.services.completion.contributor.dart.imported_ref;
-import 'dart:async';
-
-import 'package:analysis_server/plugin/protocol/protocol.dart';
+import 'package:analysis_server/plugin/protocol/protocol.dart'
+ hide Element, ElementKind;
+import 'package:analysis_server/src/protocol_server.dart';
import 'package:analysis_server/src/provisional/completion/dart/completion_dart.dart';
-import 'package:analysis_server/src/services/completion/dart/type_member_contributor.dart';
+import 'package:analysis_server/src/services/completion/dart/imported_reference_contributor.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/source.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'package:unittest/unittest.dart';
+import '../../../abstract_context.dart';
import '../../../utils.dart';
import 'completion_contributor_util.dart';
main() {
initializeTestEnvironment();
- defineReflectiveTests(TypeMemberContributorTest);
+ defineReflectiveTests(ImportedReferenceContributorTest);
}
@reflectiveTest
-class TypeMemberContributorTest extends DartCompletionContributorTest {
- /**
- * Check whether a declaration of the form [shadower] in a derived class
- * shadows a declaration of the form [shadowee] in a base class, for the
- * purposes of what is shown during completion. [shouldBeShadowed] indicates
- * whether shadowing is expected.
- */
- Future check_shadowing(
- String shadower, String shadowee, bool shouldBeShadowed) async {
- addTestSource('''
-class Base {
- $shadowee
-}
-class Derived extends Base {
- $shadower
-}
-void f(Derived d) {
- d.^
-}
-''');
- await computeSuggestions();
- List<CompletionSuggestion> suggestionsForX = suggestions
- .where((CompletionSuggestion s) => s.completion == 'x')
- .toList();
- expect(suggestionsForX, hasLength(1));
- if (shouldBeShadowed) {
- expect(suggestionsForX[0].declaringType, 'Derived');
- } else {
- expect(suggestionsForX[0].declaringType, 'Base');
- }
- }
-
- fail_test_PrefixedIdentifier_trailingStmt_const_untyped() async {
- // SimpleIdentifier PrefixedIdentifier ExpressionStatement
- addTestSource('const g = "hello"; f() {g.^ int y = 0;}');
- await computeSuggestions();
- assertSuggestGetter('length', 'int');
- }
+class ImportedReferenceContributorTest extends DartCompletionContributorTest {
+ @override
+ bool get isNullExpectedReturnTypeConsideredDynamic => false;
@override
DartCompletionContributor createContributor() {
- return new TypeMemberContributor();
+ return new ImportedReferenceContributor();
}
- test_enumConst() async {
- addTestSource('enum E { one, two } main() {E.^}');
+ fail_enum_deprecated() async {
+ addSource('/libA.dart', 'library A; @deprecated enum E { one, two }');
+ addTestSource('import "/libA.dart"; main() {^}');
await computeSuggestions();
- assertNotSuggested('E');
- // Suggested by StaticMemberContributor
+ // TODO(danrube) investigate why suggestion/element is not deprecated
+ // when AST node has correct @deprecated annotation
+ assertSuggestEnum('E', isDeprecated: true);
assertNotSuggested('one');
assertNotSuggested('two');
- assertNotSuggested('index');
- assertNotSuggested('values');
}
- test_enumConst2() async {
- addTestSource('enum E { one, two } main() {E.o^}');
+ test_enum() async {
+ addSource('/libA.dart', 'library A; enum E { one, two }');
+ addTestSource('import "/libA.dart"; main() {^}');
await computeSuggestions();
- assertNotSuggested('E');
- // Suggested by StaticMemberContributor
+ assertSuggestEnum('E');
assertNotSuggested('one');
assertNotSuggested('two');
- assertNotSuggested('index');
- assertNotSuggested('values');
- }
-
- test_enumConst3() async {
- addTestSource('enum E { one, two } main() {E.^ int g;}');
- await computeSuggestions();
- assertNotSuggested('E');
- // Suggested by StaticMemberContributor
- assertNotSuggested('one');
- assertNotSuggested('two');
- assertNotSuggested('index');
- assertNotSuggested('values');
- }
-
- test_enumConst_index() async {
- addTestSource('enum E { one, two } main() {E.one.^}');
- await computeSuggestions();
- assertNotSuggested('E');
- assertNotSuggested('one');
- assertNotSuggested('two');
- assertSuggestField('index', 'int');
- assertNotSuggested('values');
}
- test_enumConst_index2() async {
- addTestSource('enum E { one, two } main() {E.one.i^}');
+ test_function_parameters_mixed_required_and_named() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+int m(x, {int y}) {}
+''');
+ addTestSource('''
+import '/libA.dart';
+class B extends A {
+ main() {^}
+}
+''');
await computeSuggestions();
- assertNotSuggested('E');
- assertNotSuggested('one');
- assertNotSuggested('two');
- assertSuggestField('index', 'int');
- assertNotSuggested('values');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'int');
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'x');
+ expect(suggestion.parameterTypes[0], 'dynamic');
+ expect(suggestion.parameterNames[1], 'y');
+ expect(suggestion.parameterTypes[1], 'int');
+ expect(suggestion.requiredParameterCount, 1);
+ expect(suggestion.hasNamedParameters, true);
}
- test_enumConst_index3() async {
- addTestSource('enum E { one, two } main() {E.one.^ int g;}');
+ test_function_parameters_mixed_required_and_positional() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m(x, [int y]) {}
+''');
+ addTestSource('''
+import '/libA.dart';
+class B extends A {
+ main() {^}
+}
+''');
await computeSuggestions();
- assertNotSuggested('E');
- assertNotSuggested('one');
- assertNotSuggested('two');
- assertSuggestField('index', 'int');
- assertNotSuggested('values');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'x');
+ expect(suggestion.parameterTypes[0], 'dynamic');
+ expect(suggestion.parameterNames[1], 'y');
+ expect(suggestion.parameterTypes[1], 'int');
+ expect(suggestion.requiredParameterCount, 1);
+ expect(suggestion.hasNamedParameters, false);
}
- test_generic_field() async {
+ test_function_parameters_named() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m({x, int y}) {}
+''');
addTestSource('''
-class C<T> {
- T t;
-}
-void f(C<int> c) {
- c.^
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
''');
await computeSuggestions();
- assertSuggestField('t', 'int');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'x');
+ expect(suggestion.parameterTypes[0], 'dynamic');
+ expect(suggestion.parameterNames[1], 'y');
+ expect(suggestion.parameterTypes[1], 'int');
+ expect(suggestion.requiredParameterCount, 0);
+ expect(suggestion.hasNamedParameters, true);
}
- test_generic_getter() async {
+ test_function_parameters_none() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m() {}
+''');
addTestSource('''
-class C<T> {
- T get t => null;
-}
-void f(C<int> c) {
- c.^
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
''');
+
await computeSuggestions();
- assertSuggestGetter('t', 'int');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+ expect(suggestion.parameterNames, isEmpty);
+ expect(suggestion.parameterTypes, isEmpty);
+ expect(suggestion.requiredParameterCount, 0);
+ expect(suggestion.hasNamedParameters, false);
}
- test_generic_method() async {
+ test_function_parameters_positional() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m([x, int y]) {}
+''');
addTestSource('''
-class C<T> {
- T m(T t) {}
-}
-void f(C<int> c) {
- c.^
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
''');
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'int');
- expect(suggestion.parameterTypes[0], 'int');
- expect(suggestion.element.returnType, 'int');
- expect(suggestion.element.parameters, '(int t)');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'x');
+ expect(suggestion.parameterTypes[0], 'dynamic');
+ expect(suggestion.parameterNames[1], 'y');
+ expect(suggestion.parameterTypes[1], 'int');
+ expect(suggestion.requiredParameterCount, 0);
+ expect(suggestion.hasNamedParameters, false);
}
- test_generic_setter() async {
+ test_function_parameters_required() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m(x, int y) {}
+''');
addTestSource('''
-class C<T> {
- set t(T value) {}
-}
-void f(C<int> c) {
- c.^
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
''');
await computeSuggestions();
- // TODO(paulberry): modify assertSuggestSetter so that we can pass 'int'
- // as a parmeter to it, and it will check the appropriate field in
- // the suggestion object.
- CompletionSuggestion suggestion = assertSuggestSetter('t');
- expect(suggestion.element.parameters, '(int value)');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'x');
+ expect(suggestion.parameterTypes[0], 'dynamic');
+ expect(suggestion.parameterNames[1], 'y');
+ expect(suggestion.parameterTypes[1], 'int');
+ expect(suggestion.requiredParameterCount, 2);
+ expect(suggestion.hasNamedParameters, false);
}
- test_keyword() async {
- addTestSource('class C { static C get instance => null; } main() {C.in^}');
- await computeSuggestions();
- // Suggested by StaticMemberContributor
- assertNotSuggested('instance');
- }
+ test_InstanceCreationExpression() async {
+ resolveSource(
+ '/testA.dart',
+ '''
+class A {foo(){var f; {var x;}}}
+class B {B(this.x, [String boo]) { } int x;}
+class C {C.bar({boo: 'hoo', int z: 0}) { } }''');
+ addTestSource('''
+import "/testA.dart";
+import "dart:math" as math;
+main() {new ^ String x = "hello";}''');
- test_libraryPrefix() async {
- // SimpleIdentifier PrefixedIdentifier ExpressionStatement
- addTestSource('import "dart:async" as bar; foo() {bar.^}');
await computeSuggestions();
- // Suggested by LibraryMemberContributor
- assertNotSuggested('Future');
- assertNotSuggested('loadLibrary');
- }
+ CompletionSuggestion suggestion;
- test_libraryPrefix2() async {
- // SimpleIdentifier MethodInvocation ExpressionStatement
- addTestSource('import "dart:async" as bar; foo() {bar.^ print("f")}');
- await computeSuggestions();
- // Suggested by LibraryMemberContributor
- assertNotSuggested('Future');
- }
+ suggestion = assertSuggestConstructor('Object');
+ expect(suggestion.element.parameters, '()');
+ expect(suggestion.parameterNames, hasLength(0));
+ expect(suggestion.requiredParameterCount, 0);
+ expect(suggestion.hasNamedParameters, false);
- test_libraryPrefix3() async {
- // SimpleIdentifier MethodInvocation ExpressionStatement
- addTestSource('import "dart:async" as bar; foo() {new bar.F^ print("f")}');
- await computeSuggestions();
- // Suggested by LibraryMemberContributor
- assertNotSuggested('Future');
- assertNotSuggested('Future.delayed');
- }
+ suggestion = assertSuggestConstructor('A');
+ expect(suggestion.element.parameters, '()');
+ expect(suggestion.parameterNames, hasLength(0));
+ expect(suggestion.requiredParameterCount, 0);
+ expect(suggestion.hasNamedParameters, false);
- test_libraryPrefix_deferred() async {
- // SimpleIdentifier PrefixedIdentifier ExpressionStatement
- addTestSource('import "dart:async" deferred as bar; foo() {bar.^}');
- await computeSuggestions();
- // Suggested by LibraryMemberContributor
- assertNotSuggested('Future');
- assertNotSuggested('loadLibrary');
- }
+ suggestion = assertSuggestConstructor('B');
+ expect(suggestion.element.parameters, '(int x, [String boo])');
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'x');
+ expect(suggestion.parameterTypes[0], 'int');
+ expect(suggestion.parameterNames[1], 'boo');
+ expect(suggestion.parameterTypes[1], 'String');
+ expect(suggestion.requiredParameterCount, 1);
+ expect(suggestion.hasNamedParameters, false);
- test_libraryPrefix_with_exports() async {
- addSource('/libA.dart', 'library libA; class A { }');
- addSource('/libB.dart', 'library libB; export "/libA.dart"; class B { }');
- addTestSource('import "/libB.dart" as foo; main() {foo.^} class C { }');
- await computeSuggestions();
- // Suggested by LibraryMemberContributor
- assertNotSuggested('B');
- assertNotSuggested('A');
- }
+ suggestion = assertSuggestConstructor('C.bar');
+ expect(suggestion.element.parameters, "({dynamic boo: 'hoo', int z: 0})");
+ expect(suggestion.parameterNames, hasLength(2));
+ expect(suggestion.parameterNames[0], 'boo');
+ expect(suggestion.parameterTypes[0], 'dynamic');
+ expect(suggestion.parameterNames[1], 'z');
+ expect(suggestion.parameterTypes[1], 'int');
+ expect(suggestion.requiredParameterCount, 0);
+ expect(suggestion.hasNamedParameters, true);
- test_local() async {
- addTestSource('foo() {String x = "bar"; x.^}');
- await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ // Suggested by LibraryPrefixContributor
+ assertNotSuggested('math');
}
- test_local_is() async {
- addTestSource('foo() {var x; if (x is String) x.^}');
- await computeSuggestions();
- assertSuggestGetter('length', 'int');
- }
+ test_internal_sdk_libs() async {
+ addTestSource('main() {p^}');
- test_local_propogatedType() async {
- addTestSource('foo() {var x = "bar"; x.^}');
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertSuggest('print');
+ // Not imported, so not suggested
+ assertNotSuggested('pow');
+ // Do not suggest completions from internal SDK library
+ assertNotSuggested('printToConsole');
}
test_method_parameters_mixed_required_and_named() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m(x, {int y}) {}
+''');
addTestSource('''
-class C {
- void m(x, {int y}) {}
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
-void main() {new C().^}''');
+''');
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'void');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
expect(suggestion.parameterNames, hasLength(2));
expect(suggestion.parameterNames[0], 'x');
expect(suggestion.parameterTypes[0], 'dynamic');
@@ -275,13 +276,19 @@ void main() {new C().^}''');
}
test_method_parameters_mixed_required_and_positional() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m(x, [int y]) {}
+''');
addTestSource('''
-class C {
- void m(x, [int y]) {}
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
-void main() {new C().^}''');
+''');
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'void');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
expect(suggestion.parameterNames, hasLength(2));
expect(suggestion.parameterNames[0], 'x');
expect(suggestion.parameterTypes[0], 'dynamic');
@@ -292,13 +299,19 @@ void main() {new C().^}''');
}
test_method_parameters_named() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m({x, int y}) {}
+''');
addTestSource('''
-class C {
- void m({x, int y}) {}
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
-void main() {new C().^}''');
+''');
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'void');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
expect(suggestion.parameterNames, hasLength(2));
expect(suggestion.parameterNames[0], 'x');
expect(suggestion.parameterTypes[0], 'dynamic');
@@ -309,13 +322,20 @@ void main() {new C().^}''');
}
test_method_parameters_none() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m() {}
+''');
addTestSource('''
-class C {
- void m() {}
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
-void main() {new C().^}''');
+''');
+
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'void');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
expect(suggestion.parameterNames, isEmpty);
expect(suggestion.parameterTypes, isEmpty);
expect(suggestion.requiredParameterCount, 0);
@@ -323,13 +343,19 @@ void main() {new C().^}''');
}
test_method_parameters_positional() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m([x, int y]) {}
+''');
addTestSource('''
-class C {
- void m([x, int y]) {}
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
-void main() {new C().^}''');
+''');
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'void');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
expect(suggestion.parameterNames, hasLength(2));
expect(suggestion.parameterNames[0], 'x');
expect(suggestion.parameterTypes[0], 'dynamic');
@@ -340,13 +366,19 @@ void main() {new C().^}''');
}
test_method_parameters_required() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+void m(x, int y) {}
+''');
addTestSource('''
-class C {
- void m(x, int y) {}
+import '/libA.dart';
+class B {
+ main() {^}
}
-void main() {new C().^}''');
+''');
await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestMethod('m', 'C', 'void');
+ CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
expect(suggestion.parameterNames, hasLength(2));
expect(suggestion.parameterNames[0], 'x');
expect(suggestion.parameterTypes[0], 'dynamic');
@@ -356,273 +388,131 @@ void main() {new C().^}''');
expect(suggestion.hasNamedParameters, false);
}
- test_no_parameters_field() async {
- addTestSource('''
-class C {
- int x;
-}
-void main() {new C().^}''');
- await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestField('x', 'int');
- assertHasNoParameterInfo(suggestion);
- }
-
- test_no_parameters_getter() async {
- addTestSource('''
-class C {
- int get x => null;
+ test_mixin_ordering() async {
+ addSource(
+ '/libA.dart',
+ '''
+class B {}
+class M1 {
+ void m() {}
}
-void main() {int y = new C().^}''');
- await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestGetter('x', 'int');
- assertHasNoParameterInfo(suggestion);
- }
-
- test_no_parameters_setter() async {
- addTestSource('''
-class C {
- set x(int value) {};
+class M2 {
+ void m() {}
}
-void main() {int y = new C().^}''');
- await computeSuggestions();
- CompletionSuggestion suggestion = assertSuggestSetter('x');
- assertHasNoParameterInfo(suggestion);
- }
-
- test_only_instance() async {
- // SimpleIdentifier PropertyAccess ExpressionStatement
+''');
addTestSource('''
-class C {
- int f1;
- static int f2;
- m1() {}
- static m2() {}
-}
-void main() {new C().^}''');
- await computeSuggestions();
- assertSuggestField('f1', 'int');
- assertNotSuggested('f2');
- assertSuggestMethod('m1', 'C', null);
- assertNotSuggested('m2');
+import '/libA.dart';
+class C extends B with M1, M2 {
+ void f() {
+ ^
}
-
- test_only_instance2() async {
- // SimpleIdentifier MethodInvocation ExpressionStatement
- addTestSource('''
-class C {
- int f1;
- static int f2;
- m1() {}
- static m2() {}
}
-void main() {new C().^ print("something");}''');
+''');
await computeSuggestions();
- assertSuggestField('f1', 'int');
- assertNotSuggested('f2');
- assertSuggestMethod('m1', 'C', null);
- assertNotSuggested('m2');
+ assertNotSuggested('m');
}
- test_only_static() async {
- // SimpleIdentifier PrefixedIdentifier ExpressionStatement
- addTestSource('''
-class C {
- int f1;
- static int f2;
- m1() {}
- static m2() {}
-}
-void main() {C.^}''');
- await computeSuggestions();
- assertNotSuggested('f1');
- // Suggested by StaticMemberContributor
- assertNotSuggested('f2');
- assertNotSuggested('m1');
- assertNotSuggested('m2');
- }
+ /**
+ * Ensure that completions in one context don't appear in another
+ */
+ test_multiple_contexts() async {
+ // Create a 2nd context with source
+ var context2 = AnalysisEngine.instance.createAnalysisContext();
+ context2.sourceFactory =
+ new SourceFactory([AbstractContextTest.SDK_RESOLVER, resourceResolver]);
+ String content2 = 'class ClassFromAnotherContext { }';
+ Source source2 =
+ provider.newFile('/context2/foo.dart', content2).createSource();
+ ChangeSet changeSet = new ChangeSet();
+ changeSet.addedSource(source2);
+ context2.applyChanges(changeSet);
+ context2.setContents(source2, content2);
+
+ // Resolve the source in the 2nd context and update the index
+ var result = context2.performAnalysisTask();
+ while (result.hasMoreWork) {
+ result.changeNotices.forEach((ChangeNotice notice) {
+ CompilationUnit unit = notice.resolvedDartUnit;
+ if (unit != null) {
+ index.index(context2, unit);
+ }
+ });
+ result = context2.performAnalysisTask();
+ }
- test_only_static2() async {
- // SimpleIdentifier MethodInvocation ExpressionStatement
+ // Check that source in 2nd context does not appear in completion in 1st
+ addSource(
+ '/context1/libA.dart',
+ '''
+ library libA;
+ class ClassInLocalContext {int x;}''');
+ testFile = '/context1/completionTest.dart';
addTestSource('''
-class C {
- int f1;
- static int f2;
- m1() {}
- static m2() {}
-}
-void main() {C.^ print("something");}''');
- await computeSuggestions();
- assertNotSuggested('f1');
- // Suggested by StaticMemberContributor
- assertNotSuggested('f2');
- assertNotSuggested('m1');
- assertNotSuggested('m2');
- }
+ import "/context1/libA.dart";
+ import "/foo.dart";
+ main() {C^}
+ ''');
- test_param() async {
- addTestSource('foo(String x) {x.^}');
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertSuggestClass('ClassInLocalContext');
+ // Assert contributor does not include results from 2nd context.
+ assertNotSuggested('ClassFromAnotherContext');
}
- test_param_is() async {
- addTestSource('foo(x) {if (x is String) x.^}');
- await computeSuggestions();
- assertSuggestGetter('length', 'int');
- }
-
- test_shadowing_field_over_field() =>
- check_shadowing('int x;', 'int x;', true);
-
- test_shadowing_field_over_getter() =>
- check_shadowing('int x;', 'int get x => null;', true);
-
- test_shadowing_field_over_method() =>
- check_shadowing('int x;', 'void x() {}', true);
-
- test_shadowing_field_over_setter() =>
- check_shadowing('int x;', 'set x(int value) {}', true);
-
- test_shadowing_getter_over_field() =>
- check_shadowing('int get x => null;', 'int x;', false);
-
- test_shadowing_getter_over_getter() =>
- check_shadowing('int get x => null;', 'int get x => null;', true);
-
- test_shadowing_getter_over_method() =>
- check_shadowing('int get x => null;', 'void x() {}', true);
-
- test_shadowing_getter_over_setter() =>
- check_shadowing('int get x => null;', 'set x(int value) {}', false);
-
- test_shadowing_method_over_field() =>
- check_shadowing('void x() {}', 'int x;', true);
-
- test_shadowing_method_over_getter() =>
- check_shadowing('void x() {}', 'int get x => null;', true);
-
- test_shadowing_method_over_method() =>
- check_shadowing('void x() {}', 'void x() {}', true);
-
- test_shadowing_method_over_setter() =>
- check_shadowing('void x() {}', 'set x(int value) {}', true);
-
- test_shadowing_mixin_order() async {
- addTestSource('''
-class Base {
-}
-class Mixin1 {
- void f() {}
-}
-class Mixin2 {
- void f() {}
-}
-class Derived extends Base with Mixin1, Mixin2 {
-}
-void test(Derived d) {
- d.^
-}
+ test_no_parameters_field() async {
+ addSource(
+ '/libA.dart',
+ '''
+int x;
''');
- await computeSuggestions();
- // Note: due to dartbug.com/22069, analyzer currently analyzes mixins in
- // reverse order. The correct order is that Derived inherits from
- // "Base with Mixin1, Mixin2", which inherits from "Base with Mixin1",
- // which inherits from "Base". So the definition of f in Mixin2 should
- // shadow the definition in Mixin1.
- assertSuggestMethod('f', 'Mixin2', 'void');
- }
-
- test_shadowing_mixin_over_superclass() async {
addTestSource('''
-class Base {
- void f() {}
-}
-class Mixin {
- void f() {}
-}
-class Derived extends Base with Mixin {
-}
-void test(Derived d) {
- d.^
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
''');
await computeSuggestions();
- assertSuggestMethod('f', 'Mixin', 'void');
+ CompletionSuggestion suggestion = assertSuggestTopLevelVar('x', null);
+ assertHasNoParameterInfo(suggestion);
}
- test_shadowing_setter_over_field() =>
- check_shadowing('set x(int value) {}', 'int x;', false);
-
- test_shadowing_setter_over_getter() =>
- check_shadowing('set x(int value) {}', 'int get x => null;', false);
-
- test_shadowing_setter_over_method() =>
- check_shadowing('set x(int value) {}', 'void x() {}', true);
-
- test_shadowing_setter_over_setter() =>
- check_shadowing('set x(int value) {}', 'set x(int value) {}', true);
-
- test_shadowing_superclass_over_interface() async {
+ test_no_parameters_getter() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+int get x => null;
+''');
addTestSource('''
-class Base {
- void f() {}
-}
-class Interface {
- void f() {}
-}
-class Derived extends Base implements Interface {
-}
-void test(Derived d) {
- d.^
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
''');
await computeSuggestions();
- assertSuggestMethod('f', 'Base', 'void');
+ CompletionSuggestion suggestion = assertSuggestGetter('x', 'int');
+ assertHasNoParameterInfo(suggestion);
}
- test_super() async {
- // SimpleIdentifier MethodInvocation ExpressionStatement
+ test_no_parameters_setter() async {
+ addSource(
+ '/libA.dart',
+ '''
+set x(int value) {};
+''');
addTestSource('''
-class C3 {
- int fi3;
- static int fs3;
- m() {}
- mi3() {}
- static ms3() {}
-}
-class C2 {
- int fi2;
- static int fs2;
- m() {}
- mi2() {}
- static ms2() {}
+import '/libA.dart';
+class B extends A {
+ main() {^}
}
-class C1 extends C2 implements C3 {
- int fi1;
- static int fs1;
- m() {super.^}
- mi1() {}
- static ms1() {}
-}''');
+''');
await computeSuggestions();
- assertNotSuggested('fi1');
- assertNotSuggested('fs1');
- assertNotSuggested('mi1');
- assertNotSuggested('ms1');
- assertSuggestField('fi2', 'int');
- assertNotSuggested('fs2');
- assertSuggestMethod('mi2', 'C2', null);
- assertNotSuggested('ms2');
- assertSuggestMethod('m', 'C2', null, relevance: DART_RELEVANCE_HIGH);
- assertNotSuggested('fi3');
- assertNotSuggested('fs3');
- assertNotSuggested('mi3');
- assertNotSuggested('ms3');
+ CompletionSuggestion suggestion = assertSuggestSetter('x');
+ assertHasNoParameterInfo(suggestion);
}
test_ArgumentList() async {
// ArgumentList MethodInvocation ExpressionStatement Block
- addSource(
+ resolveSource(
'/libA.dart',
'''
library A;
@@ -633,15 +523,16 @@ class C1 extends C2 implements C3 {
class B { }
String bar() => true;
void main() {expect(^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool');
+ assertSuggestFunction('identical', 'bool');
assertNotSuggested('B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -649,7 +540,7 @@ class C1 extends C2 implements C3 {
test_ArgumentList_imported_function() async {
// ArgumentList MethodInvocation ExpressionStatement Block
- addSource(
+ resolveSource(
'/libA.dart',
'''
library A;
@@ -661,15 +552,16 @@ class C1 extends C2 implements C3 {
class B { }
String bar() => true;
void main() {expect(^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool');
+ assertSuggestFunction('identical', 'bool');
assertNotSuggested('B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -690,16 +582,19 @@ class C1 extends C2 implements C3 {
class B { }
String bar() => true;
void main() {new A(^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestFunction('identical', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('B');
- assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -721,16 +616,19 @@ class C1 extends C2 implements C3 {
class B { }
String bar() => true;
void main() {new A(^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestFunction('identical', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('B');
- assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -738,7 +636,7 @@ class C1 extends C2 implements C3 {
test_ArgumentList_local_function() async {
// ArgumentList MethodInvocation ExpressionStatement Block
- addSource(
+ resolveSource(
'/libA.dart',
'''
library A;
@@ -750,15 +648,16 @@ class C1 extends C2 implements C3 {
class B { }
String bar() => true;
void main() {expect(^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool');
+ assertSuggestFunction('identical', 'bool');
assertNotSuggested('B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -766,7 +665,7 @@ class C1 extends C2 implements C3 {
test_ArgumentList_local_method() async {
// ArgumentList MethodInvocation ExpressionStatement Block
- addSource(
+ resolveSource(
'/libA.dart',
'''
library A;
@@ -778,15 +677,16 @@ class C1 extends C2 implements C3 {
expect(arg) { }
void foo() {expect(^)}}
String bar() => true;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool');
+ assertSuggestFunction('identical', 'bool');
assertNotSuggested('B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -807,16 +707,19 @@ class C1 extends C2 implements C3 {
class B { }
String bar(f()) => true;
void main() {bar(^);}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestFunction('identical', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('B');
- assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -836,15 +739,18 @@ class C1 extends C2 implements C3 {
import '/libA.dart';
class B { String bar(f()) => true; }
void main() {new B().bar(^);}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
- assertNotSuggested('hasLength');
- assertNotSuggested('identical');
+ assertSuggestFunction('hasLength', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestFunction('identical', 'bool',
+ kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('B');
- assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('A', kind: CompletionSuggestionKind.IDENTIFIER);
+ assertSuggestClass('Object', kind: CompletionSuggestionKind.IDENTIFIER);
assertNotSuggested('main');
assertNotSuggested('baz');
assertNotSuggested('print');
@@ -862,11 +768,14 @@ class C1 extends C2 implements C3 {
import '/libA.dart'
String bar() => true;
void main() {expect(foo: ^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('bar');
- assertNotSuggested('hasLength');
+ // An unresolved imported library will produce suggestions
+ // with a null returnType
+ assertSuggestFunction('hasLength', null);
assertNotSuggested('main');
}
@@ -874,12 +783,13 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier TypeName AsExpression
addTestSource('''
class A {var b; X _c; foo() {var a; (a as ^).foo();}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('b');
assertNotSuggested('_c');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('A');
assertNotSuggested('==');
}
@@ -888,6 +798,7 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier VariableDeclaration VariableDeclarationList
// VariableDeclarationStatement Block
addTestSource('class A {} main() {int a; int ^b = 1;}');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -896,13 +807,14 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier VariableDeclaration VariableDeclarationList
// VariableDeclarationStatement Block
addTestSource('class A {} main() {int a; int b = ^}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
assertNotSuggested('main');
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_AssignmentExpression_type() async {
@@ -912,11 +824,12 @@ class C1 extends C2 implements C3 {
class A {} main() {
int a;
^ b = 1;}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
- assertNotSuggested('int');
+ assertSuggestClass('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.
@@ -935,17 +848,18 @@ class C1 extends C2 implements C3 {
int a;
^
b = 1;}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
- assertNotSuggested('int');
+ assertSuggestClass('int');
// Allow non-types preceding an identifier on LHS of assignment
// if newline follows first identifier
// because user is probably starting a new statement
assertNotSuggested('a');
assertNotSuggested('main');
- assertNotSuggested('identical');
+ assertSuggestFunction('identical', 'bool');
}
test_AssignmentExpression_type_partial() async {
@@ -955,11 +869,12 @@ class C1 extends C2 implements C3 {
class A {} main() {
int a;
int^ b = 1;}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 3);
expect(replacementLength, 3);
assertNotSuggested('A');
- assertNotSuggested('int');
+ assertSuggestClass('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.
@@ -978,17 +893,18 @@ class C1 extends C2 implements C3 {
int a;
i^
b = 1;}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
assertNotSuggested('A');
- assertNotSuggested('int');
+ assertSuggestClass('int');
// Allow non-types preceding an identifier on LHS of assignment
// if newline follows first identifier
// because user is probably starting a new statement
assertNotSuggested('a');
assertNotSuggested('main');
- assertNotSuggested('identical');
+ assertSuggestFunction('identical', 'bool');
}
test_AwaitExpression() async {
@@ -996,24 +912,73 @@ class C1 extends C2 implements C3 {
addTestSource('''
class A {int x; int y() => 0;}
main() async {A a; await ^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
assertNotSuggested('main');
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
+ }
+
+ test_AwaitExpression_function() async {
+ resolveSource(
+ '/libA.dart',
+ '''
+Future y() async {return 0;}
+''');
+ addTestSource('''
+import '/libA.dart';
+class B extends A {
+ int x;
+ foo() async {await ^}
+}
+''');
+ await computeSuggestions();
+ expect(replacementOffset, completionOffset);
+ expect(replacementLength, 0);
+ assertSuggestFunction('y', 'dynamic');
+ assertNotSuggested('A');
+ assertSuggestClass('Object');
+ }
+
+ test_AwaitExpression_inherited() async {
+ // SimpleIdentifier AwaitExpression ExpressionStatement
+ addSource(
+ '/testB.dart',
+ '''
+lib libB;
+class A {
+ Future y() async { return 0; }
+}''');
+ addTestSource('''
+import "/testB.dart";
+class B extends A {
+ foo() async {await ^}
+}
+''');
+
+ await computeSuggestions();
+ expect(replacementOffset, completionOffset);
+ expect(replacementLength, 0);
+ assertNotSuggested('a');
+ assertNotSuggested('main');
+ assertSuggestClass('A');
+ assertSuggestClass('Object');
+ assertNotSuggested('y');
}
test_BinaryExpression_LHS() async {
// SimpleIdentifier BinaryExpression VariableDeclaration
// VariableDeclarationList VariableDeclarationStatement
addTestSource('main() {int a = 1, b = ^ + 2;}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('b');
}
@@ -1021,11 +986,12 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier BinaryExpression VariableDeclaration
// VariableDeclarationList VariableDeclarationStatement
addTestSource('main() {int a = 1, b = 2 + ^;}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('b');
assertNotSuggested('==');
}
@@ -1079,8 +1045,8 @@ class C1 extends C2 implements C3 {
}
void b() { }}
class Z { }''');
- await computeSuggestions();
+ await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -1095,24 +1061,32 @@ class C1 extends C2 implements C3 {
assertNotSuggested('x');
assertNotSuggested('partT8');
- assertNotSuggested('A');
+ assertSuggestClass('A', elemFile: '/testAB.dart');
assertNotSuggested('_B');
- assertNotSuggested('C');
+ assertSuggestClass('C');
assertNotSuggested('partBoo');
// hidden element suggested as low relevance
// but imported results are partially filtered
- //assertNotSuggested('D');
- //assertNotSuggested(
+ //assertSuggestClass('D', COMPLETION_RELEVANCE_LOW);
+ //assertSuggestFunction(
// 'D1', null, true, COMPLETION_RELEVANCE_LOW);
assertNotSuggested('D2');
- assertNotSuggested('EE');
+ assertSuggestClass('EE');
// hidden element suggested as low relevance
- //assertNotSuggested('F');
+ //assertSuggestClass('F', COMPLETION_RELEVANCE_LOW);
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('g');
+ assertSuggestClass('g.G', elemName: 'G');
assertNotSuggested('G');
- //assertNotSuggested('H');
- assertNotSuggested('Object');
- assertNotSuggested('min');
+ //assertSuggestClass('H', COMPLETION_RELEVANCE_LOW);
+ assertSuggestClass('Object');
+ assertSuggestFunction('min', 'num');
+ //assertSuggestFunction(
+ // 'max',
+ // 'num',
+ // false,
+ // COMPLETION_RELEVANCE_LOW);
+ assertSuggestTopLevelVar('T1', null);
assertNotSuggested('_T2');
//assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
assertNotSuggested('_T4');
@@ -1125,7 +1099,7 @@ class C1 extends C2 implements C3 {
assertNotSuggested('blog');
// TODO (danrubel) suggest HtmlElement as low relevance
assertNotSuggested('HtmlElement');
- assertNotSuggested('Uri');
+ assertSuggestClass('Uri');
assertNotSuggested('parseIPv6Address');
assertNotSuggested('parseHex');
}
@@ -1179,8 +1153,8 @@ class C1 extends C2 implements C3 {
}
void b() { }}
class Z { }''');
- await computeSuggestions();
+ await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -1195,30 +1169,31 @@ class C1 extends C2 implements C3 {
assertNotSuggested('x');
assertNotSuggested('partT8');
- assertNotSuggested('A');
+ assertSuggestClass('A');
assertNotSuggested('_B');
- assertNotSuggested('C');
+ assertSuggestClass('C');
assertNotSuggested('partBoo');
// hidden element suggested as low relevance
// but imported results are partially filtered
- //assertNotSuggested('D');
- //assertNotSuggested(
+ //assertSuggestClass('D', COMPLETION_RELEVANCE_LOW);
+ //assertSuggestFunction(
// 'D1', null, true, COMPLETION_RELEVANCE_LOW);
assertNotSuggested('D2');
- assertNotSuggested('EE');
+ assertSuggestClass('EE');
// hidden element suggested as low relevance
- //assertNotSuggested('F');
+ //assertSuggestClass('F', COMPLETION_RELEVANCE_LOW);
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('g');
- assertNotSuggested('G');
- //assertNotSuggested('H');
- assertNotSuggested('Object');
+ assertSuggestClass('g.G', elemName: 'G');
+ //assertSuggestClass('H', COMPLETION_RELEVANCE_LOW);
+ assertSuggestClass('Object');
assertNotSuggested('min');
- //assertNotSuggested(
+ //assertSuggestFunction(
// 'max',
// 'num',
// false,
// COMPLETION_RELEVANCE_LOW);
- assertNotSuggested('T1');
+ assertSuggestTopLevelVar('T1', null);
assertNotSuggested('_T2');
//assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
assertNotSuggested('_T4');
@@ -1231,23 +1206,23 @@ class C1 extends C2 implements C3 {
assertNotSuggested('blog');
// TODO (danrubel) suggest HtmlElement as low relevance
assertNotSuggested('HtmlElement');
- assertNotSuggested('Uri');
+ assertSuggestClass('Uri');
assertNotSuggested('parseIPv6Address');
assertNotSuggested('parseHex');
}
test_Block_final2() async {
addTestSource('main() {final S^ v;}');
- await computeSuggestions();
- assertNotSuggested('String');
+ await computeSuggestions();
+ assertSuggestClass('String');
}
test_Block_final3() async {
addTestSource('main() {final ^ v;}');
- await computeSuggestions();
- assertNotSuggested('String');
+ await computeSuggestions();
+ assertSuggestClass('String');
}
test_Block_final_final() async {
@@ -1282,7 +1257,7 @@ class C1 extends C2 implements C3 {
import "/testAB.dart";
import "/testCD.dart" hide D;
import "/testEEF.dart" show EE;
- import "/testG.dart" as g;
+ import "/testG.dart" as g hide G;
int T5;
var _T6;
String get T7 => 'hello';
@@ -1299,8 +1274,8 @@ class C1 extends C2 implements C3 {
}
void b() { }}
class Z { }''');
- await computeSuggestions();
+ await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -1315,30 +1290,33 @@ class C1 extends C2 implements C3 {
assertNotSuggested('x');
assertNotSuggested('partT8');
- assertNotSuggested('A');
+ assertSuggestClass('A');
assertNotSuggested('_B');
- assertNotSuggested('C');
+ assertSuggestClass('C');
assertNotSuggested('partBoo');
// hidden element suggested as low relevance
// but imported results are partially filtered
- //assertNotSuggested('D');
- //assertNotSuggested(
+ //assertSuggestClass('D', COMPLETION_RELEVANCE_LOW);
+ //assertSuggestFunction(
// 'D1', null, true, COMPLETION_RELEVANCE_LOW);
assertNotSuggested('D2');
- assertNotSuggested('EE');
+ assertSuggestClass('EE');
// hidden element suggested as low relevance
- //assertNotSuggested('F');
+ //assertSuggestClass('F', COMPLETION_RELEVANCE_LOW);
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('g');
assertNotSuggested('G');
- //assertNotSuggested('H');
- assertNotSuggested('Object');
+ // Hidden elements not suggested
+ assertNotSuggested('g.G');
+ //assertSuggestClass('H', COMPLETION_RELEVANCE_LOW);
+ assertSuggestClass('Object');
assertNotSuggested('min');
- //assertNotSuggested(
+ //assertSuggestFunction(
// 'max',
// 'num',
// false,
// COMPLETION_RELEVANCE_LOW);
- assertNotSuggested('T1');
+ assertSuggestTopLevelVar('T1', null);
assertNotSuggested('_T2');
//assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
assertNotSuggested('_T4');
@@ -1351,7 +1329,7 @@ class C1 extends C2 implements C3 {
assertNotSuggested('blog');
// TODO (danrubel) suggest HtmlElement as low relevance
assertNotSuggested('HtmlElement');
- assertNotSuggested('Uri');
+ assertSuggestClass('Uri');
assertNotSuggested('parseIPv6Address');
assertNotSuggested('parseHex');
}
@@ -1405,8 +1383,8 @@ class C1 extends C2 implements C3 {
}
void b() { }}
class Z { }''');
- await computeSuggestions();
+ await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -1421,30 +1399,31 @@ class C1 extends C2 implements C3 {
assertNotSuggested('x');
assertNotSuggested('partT8');
- assertNotSuggested('A');
+ assertSuggestClass('A');
assertNotSuggested('_B');
- assertNotSuggested('C');
+ assertSuggestClass('C');
assertNotSuggested('partBoo');
// hidden element suggested as low relevance
// but imported results are partially filtered
- //assertNotSuggested('D');
- //assertNotSuggested(
+ //assertSuggestClass('D', COMPLETION_RELEVANCE_LOW);
+ //assertSuggestFunction(
// 'D1', null, true, COMPLETION_RELEVANCE_LOW);
assertNotSuggested('D2');
- assertNotSuggested('EE');
+ assertSuggestClass('EE');
// hidden element suggested as low relevance
- //assertNotSuggested('F');
+ //assertSuggestClass('F', COMPLETION_RELEVANCE_LOW);
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('g');
- assertNotSuggested('G');
- //assertNotSuggested('H');
- assertNotSuggested('Object');
+ assertSuggestClass('g.G', elemName: 'G');
+ //assertSuggestClass('H', COMPLETION_RELEVANCE_LOW);
+ assertSuggestClass('Object');
assertNotSuggested('min');
- //assertNotSuggested(
+ //assertSuggestFunction(
// 'max',
// 'num',
// false,
// COMPLETION_RELEVANCE_LOW);
- assertNotSuggested('T1');
+ assertSuggestTopLevelVar('T1', null);
assertNotSuggested('_T2');
//assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
assertNotSuggested('_T4');
@@ -1457,13 +1436,13 @@ class C1 extends C2 implements C3 {
assertNotSuggested('blog');
// TODO (danrubel) suggest HtmlElement as low relevance
assertNotSuggested('HtmlElement');
- assertNotSuggested('Uri');
+ assertSuggestClass('Uri');
assertNotSuggested('parseIPv6Address');
assertNotSuggested('parseHex');
}
test_Block_identifier_partial() async {
- addSource(
+ resolveSource(
'/testAB.dart',
'''
export "dart:math" hide max;
@@ -1481,7 +1460,7 @@ class C1 extends C2 implements C3 {
'/testEEF.dart',
'''
class EE { }
- class F { }''');
+ class DF { }''');
addSource('/testG.dart', 'class G { }');
addSource(
'/testH.dart',
@@ -1501,7 +1480,6 @@ class C1 extends C2 implements C3 {
class X {a() {var f; {var x;} D^ var r;} void b() { }}
class Z { }''');
await computeSuggestions();
-
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
@@ -1515,24 +1493,24 @@ class C1 extends C2 implements C3 {
assertNotSuggested('x');
// imported elements are portially filtered
- //assertNotSuggested('A');
+ //assertSuggestClass('A');
assertNotSuggested('_B');
- //assertNotSuggested('C');
- // hidden element suggested as low relevance
+ // hidden element not suggested
assertNotSuggested('D');
- assertNotSuggested('D1');
+ assertSuggestFunction('D1', 'dynamic',
+ isDeprecated: true, relevance: DART_RELEVANCE_LOW);
assertNotSuggested('D2');
- // unimported elements suggested with low relevance
+ // Not imported, so not suggested
assertNotSuggested('D3');
- //assertNotSuggested('EE');
- // hidden element suggested as low relevance
- //assertNotSuggested('F');
- //assertNotSuggested('g');
- assertNotSuggested('G');
- //assertNotSuggested('H');
- //assertNotSuggested('Object');
- //assertNotSuggested('min');
- //assertNotSuggested(
+ //assertSuggestClass('EE');
+ // hidden element not suggested
+ assertNotSuggested('DF');
+ //assertSuggestLibraryPrefix('g');
+ assertSuggestClass('g.G', elemName: 'G');
+ //assertSuggestClass('H', COMPLETION_RELEVANCE_LOW);
+ //assertSuggestClass('Object');
+ //assertSuggestFunction('min', 'num', false);
+ //assertSuggestFunction(
// 'max',
// 'num',
// false,
@@ -1561,8 +1539,8 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testB.dart";
class A extends E implements I with M {a() {^}}''');
- await computeSuggestions();
+ await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
// TODO (danrubel) prefer fields over getters
@@ -1577,7 +1555,7 @@ class C1 extends C2 implements C3 {
assertNotSuggested('e2');
assertNotSuggested('f2');
assertNotSuggested('i2');
- //assertNotSuggested('m2');
+ //assertNotSuggested('m2', null, null);
assertNotSuggested('==');
}
@@ -1589,6 +1567,7 @@ class C1 extends C2 implements C3 {
class I { int i1; i2() { } }
class M { var m1; int m2() { } }
class A extends E implements I with M {a() {^}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -1652,56 +1631,76 @@ class C1 extends C2 implements C3 {
}
void b() { }}
class Z { }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
+
assertNotSuggested('partT8');
assertNotSuggested('partBoo');
assertNotSuggested('parseIPv6Address');
assertNotSuggested('parseHex');
}
+ test_Block_partial_results() async {
+ // 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;
+ Z D2() {int x;}
+ class X {a() {var f; {var x;} ^ var r;} void b() { }}
+ class Z { }''');
+ await computeSuggestions();
+ assertSuggestClass('C');
+ assertNotSuggested('H');
+ }
+
test_Block_unimported() async {
addPackageSource('myBar', 'bar.dart', 'class Foo2 { Foo2() { } }');
addSource(
'/proj/testAB.dart', 'import "package:myBar/bar.dart"; class Foo { }');
testFile = '/proj/completionTest.dart';
addTestSource('class C {foo(){F^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
+ // Not imported, so not suggested
assertNotSuggested('Foo');
- // TODO(danrubel) implement
assertNotSuggested('Foo2');
assertNotSuggested('Future');
}
- test_CascadeExpression_method1() async {
- // 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()}''');
- await computeSuggestions();
- expect(replacementOffset, completionOffset);
- expect(replacementLength, 0);
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
- assertNotSuggested('Object');
- assertNotSuggested('A');
- assertNotSuggested('B');
- assertNotSuggested('X');
- assertNotSuggested('z');
- assertNotSuggested('==');
- }
-
test_CascadeExpression_selector1() async {
// PropertyAccess CascadeExpression ExpressionStatement Block
addSource(
@@ -1715,11 +1714,12 @@ class C1 extends C2 implements C3 {
// looks like a cascade to the parser
// but the user is trying to get completions for a non-cascade
main() {A a; a.^.z}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
+ assertNotSuggested('b');
+ assertNotSuggested('_c');
assertNotSuggested('Object');
assertNotSuggested('A');
assertNotSuggested('B');
@@ -1739,11 +1739,12 @@ class C1 extends C2 implements C3 {
class A {var b; X _c;}
class X{}
main() {A a; a..^z}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 1);
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
+ assertNotSuggested('b');
+ assertNotSuggested('_c');
assertNotSuggested('Object');
assertNotSuggested('A');
assertNotSuggested('B');
@@ -1763,11 +1764,12 @@ class C1 extends C2 implements C3 {
class A {var b; X _c;}
class X{}
main() {A a; a..^ return}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
+ assertNotSuggested('b');
+ assertNotSuggested('_c');
assertNotSuggested('Object');
assertNotSuggested('A');
assertNotSuggested('B');
@@ -1782,6 +1784,7 @@ class C1 extends C2 implements C3 {
class A {var b; X _c;}
class X{}
main() {A a; a^..b}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
@@ -1791,18 +1794,19 @@ class C1 extends C2 implements C3 {
assertNotSuggested('A');
assertNotSuggested('X');
// top level results are partially filtered
- //assertNotSuggested('Object');
+ //assertSuggestClass('Object');
assertNotSuggested('==');
}
test_CatchClause_onType() async {
// TypeName CatchClause TryStatement
addTestSource('class A {a() {try{var x;} on ^ {}}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('a');
assertNotSuggested('x');
}
@@ -1810,36 +1814,39 @@ class C1 extends C2 implements C3 {
test_CatchClause_onType_noBrackets() async {
// TypeName CatchClause TryStatement
addTestSource('class A {a() {try{var x;} on ^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('x');
}
test_CatchClause_typed() async {
// Block CatchClause TryStatement
addTestSource('class A {a() {try{var x;} on E catch (e) {^}}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('e');
assertNotSuggested('a');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('x');
}
test_CatchClause_untyped() async {
// Block CatchClause TryStatement
addTestSource('class A {a() {try{var x;} catch (e, s) {^}}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('e');
assertNotSuggested('s');
assertNotSuggested('a');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('x');
}
@@ -1854,13 +1861,19 @@ class C1 extends C2 implements C3 {
@deprecated class A {^}
class _B {}
A T;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
assertNotSuggested('_B');
- assertNotSuggested('Object');
+ CompletionSuggestion suggestionO = assertSuggestClass('Object');
+ if (suggestionO != null) {
+ expect(suggestionO.element.isDeprecated, isFalse);
+ expect(suggestionO.element.isPrivate, isFalse);
+ }
assertNotSuggested('T');
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('x');
}
@@ -1875,13 +1888,15 @@ class C1 extends C2 implements C3 {
class A {final ^}
class _B {}
A T;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
assertNotSuggested('_B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('T');
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('x');
}
@@ -1896,13 +1911,15 @@ class C1 extends C2 implements C3 {
class A {final ^ A(){}}
class _B {}
A T;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
assertNotSuggested('_B');
- assertNotSuggested('String');
+ assertSuggestClass('String');
assertNotSuggested('T');
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('x');
}
@@ -1917,13 +1934,15 @@ class C1 extends C2 implements C3 {
class A {final S^ A();}
class _B {}
A Sew;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
assertNotSuggested('A');
assertNotSuggested('_B');
- assertNotSuggested('String');
+ assertSuggestClass('String');
assertNotSuggested('Sew');
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('Soo');
}
@@ -1938,13 +1957,15 @@ class C1 extends C2 implements C3 {
class A {final ^ final foo;}
class _B {}
A T;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
assertNotSuggested('_B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('T');
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('x');
}
@@ -1959,13 +1980,15 @@ class C1 extends C2 implements C3 {
class A {final ^ var foo;}
class _B {}
A T;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('A');
assertNotSuggested('_B');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('T');
+ // Suggested by LibraryPrefixContributor
assertNotSuggested('x');
}
@@ -1994,6 +2017,7 @@ class C1 extends C2 implements C3 {
import "/testAB.dart" hide ^;
import "/testCD.dart";
class X {}''');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -2025,6 +2049,7 @@ class C1 extends C2 implements C3 {
import "/testAB.dart" show ^;
import "/testCD.dart";
class X {}''');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -2043,6 +2068,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} return a ? T1 : T^}}''');
+
await computeSuggestions();
// top level results are partially filtered based on first char
assertNotSuggested('T2');
@@ -2052,7 +2078,7 @@ class C1 extends C2 implements C3 {
test_ConditionalExpression_elseExpression_empty() async {
// SimpleIdentifier ConditionalExpression ReturnStatement
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -2064,6 +2090,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} return a ? T1 : ^}}''');
+
await computeSuggestions();
assertNotSuggested('x');
assertNotSuggested('f');
@@ -2071,8 +2098,8 @@ class C1 extends C2 implements C3 {
assertNotSuggested('C');
assertNotSuggested('F2');
assertNotSuggested('T2');
- assertNotSuggested('A');
- assertNotSuggested('F1');
+ assertSuggestClass('A');
+ assertSuggestFunction('F1', 'dynamic');
// TODO (danrubel) getter is being suggested instead of top level var
//assertSuggestImportedTopLevelVar('T1', 'int');
}
@@ -2091,6 +2118,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} return a ? T^}}''');
+
await computeSuggestions();
// top level results are partially filtered based on first char
assertNotSuggested('T2');
@@ -2100,7 +2128,7 @@ class C1 extends C2 implements C3 {
test_ConditionalExpression_partial_thenExpression_empty() async {
// SimpleIdentifier ConditionalExpression ReturnStatement
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -2112,6 +2140,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} return a ? ^}}''');
+
await computeSuggestions();
assertNotSuggested('x');
assertNotSuggested('f');
@@ -2119,8 +2148,8 @@ class C1 extends C2 implements C3 {
assertNotSuggested('C');
assertNotSuggested('F2');
assertNotSuggested('T2');
- assertNotSuggested('A');
- assertNotSuggested('F1');
+ assertSuggestClass('A');
+ assertSuggestFunction('F1', 'dynamic');
// TODO (danrubel) getter is being suggested instead of top level var
//assertSuggestImportedTopLevelVar('T1', 'int');
}
@@ -2139,6 +2168,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} return a ? T^ : c}}''');
+
await computeSuggestions();
// top level results are partially filtered based on first char
assertNotSuggested('T2');
@@ -2160,6 +2190,7 @@ class C1 extends C2 implements C3 {
import "/testB.dart";
var m;
main() {new X.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -2186,6 +2217,7 @@ class C1 extends C2 implements C3 {
import "/testB.dart";
var m;
main() {new X.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -2203,6 +2235,7 @@ class C1 extends C2 implements C3 {
// InstanceCreationExpression
addTestSource('''
main() {new String.fr^omCharCodes([]);}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 2);
expect(replacementLength, 13);
@@ -2223,6 +2256,7 @@ class C1 extends C2 implements C3 {
F1() { }
class X {X.c(); X._d(); z() {}}
main() {new X.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -2243,6 +2277,7 @@ class C1 extends C2 implements C3 {
F1() { }
class X {factory X.c(); factory X._d(); z() {}}
main() {new X.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -2261,20 +2296,21 @@ class C1 extends C2 implements C3 {
foo() { }
void bar() { }
class A {a(blat: ^) { }}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('foo');
assertNotSuggested('a');
assertNotSuggested('A');
- assertNotSuggested('String');
- assertNotSuggested('identical');
+ assertSuggestClass('String');
+ assertSuggestFunction('identical', 'bool');
assertNotSuggested('bar');
}
test_ExpressionStatement_identifier() async {
// SimpleIdentifier ExpressionStatement Block
- addSource(
+ resolveSource(
'/testA.dart',
'''
_B F1() { }
@@ -2285,11 +2321,12 @@ class C1 extends C2 implements C3 {
typedef int F2(int blat);
class Clz = Object with Object;
class C {foo(){^} void bar() {}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('A');
- assertNotSuggested('F1');
+ assertSuggestClass('A');
+ assertSuggestFunction('F1', '_B');
assertNotSuggested('C');
assertNotSuggested('foo');
assertNotSuggested('bar');
@@ -2310,6 +2347,7 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testA.dart";
class C {a() {C ^}}''');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -2321,6 +2359,7 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testA.dart";
class C {A ^}''');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -2332,6 +2371,7 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testA.dart";
class C {var ^}''');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -2348,65 +2388,71 @@ class C1 extends C2 implements C3 {
test_ForEachStatement_body_typed() async {
// Block ForEachStatement
addTestSource('main(args) {for (int foo in bar) {^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('args');
assertNotSuggested('foo');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_ForEachStatement_body_untyped() async {
// Block ForEachStatement
addTestSource('main(args) {for (foo in bar) {^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('args');
assertNotSuggested('foo');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_ForEachStatement_iterable() async {
// SimpleIdentifier ForEachStatement Block
addTestSource('main(args) {for (int foo in ^) {}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('args');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_ForEachStatement_loopVariable() async {
// SimpleIdentifier ForEachStatement Block
addTestSource('main(args) {for (^ in args) {}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('args');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_ForEachStatement_loopVariable_type() async {
// SimpleIdentifier ForEachStatement Block
addTestSource('main(args) {for (^ foo in args) {}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('args');
assertNotSuggested('foo');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_ForEachStatement_loopVariable_type2() async {
// DeclaredIdentifier ForEachStatement Block
addTestSource('main(args) {for (S^ foo in args) {}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
assertNotSuggested('args');
assertNotSuggested('foo');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_FormalParameterList() async {
@@ -2415,13 +2461,14 @@ class C1 extends C2 implements C3 {
foo() { }
void bar() { }
class A {a(^) { }}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('foo');
assertNotSuggested('a');
assertNotSuggested('A');
- assertNotSuggested('String');
+ assertSuggestClass('String');
assertNotSuggested('identical');
assertNotSuggested('bar');
}
@@ -2429,16 +2476,18 @@ class C1 extends C2 implements C3 {
test_ForStatement_body() async {
// Block ForStatement
addTestSource('main(args) {for (int i; i < 10; ++i) {^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('i');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_ForStatement_condition() async {
// SimpleIdentifier ForStatement
addTestSource('main() {for (int index = 0; i^)}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
@@ -2448,17 +2497,19 @@ class C1 extends C2 implements C3 {
test_ForStatement_initializer() async {
// SimpleIdentifier ForStatement
addTestSource('main() {List a; for (^)}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
- assertNotSuggested('Object');
- assertNotSuggested('int');
+ assertSuggestClass('Object');
+ assertSuggestClass('int');
}
test_ForStatement_updaters() async {
// SimpleIdentifier ForStatement
addTestSource('main() {for (int index = 0; index < 10; i^)}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
@@ -2470,6 +2521,7 @@ class C1 extends C2 implements C3 {
addTestSource('''
void bar() { }
main() {for (int index = 0; index < 10; ++i^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
@@ -2480,7 +2532,7 @@ class C1 extends C2 implements C3 {
test_FunctionDeclaration_returnType_afterComment() async {
// ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -2494,14 +2546,15 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
/* */ ^ zoo(z) { } String name;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -2511,7 +2564,7 @@ class C1 extends C2 implements C3 {
test_FunctionDeclaration_returnType_afterComment2() async {
// FunctionDeclaration ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -2525,14 +2578,15 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
/** */ ^ zoo(z) { } String name;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -2542,7 +2596,7 @@ class C1 extends C2 implements C3 {
test_FunctionDeclaration_returnType_afterComment3() async {
// FunctionDeclaration ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -2557,14 +2611,15 @@ class C1 extends C2 implements C3 {
/// some dartdoc
class C2 { }
^ zoo(z) { } String name;''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -2576,28 +2631,29 @@ class C1 extends C2 implements C3 {
// Block BlockFunctionBody FunctionExpression
addTestSource('''
void bar() { }
- String foo(List args) {x.then((R b) {^}''');
- await computeSuggestions();
+ String foo(List args) {x.then((R b) {^});}''');
+ await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('foo');
assertNotSuggested('bar');
assertNotSuggested('args');
assertNotSuggested('b');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_IfStatement() async {
// SimpleIdentifier IfStatement
addTestSource('''
class A {var b; X _c; foo() {A a; if (true) ^}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('b');
assertNotSuggested('_c');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('A');
assertNotSuggested('==');
}
@@ -2607,25 +2663,27 @@ class C1 extends C2 implements C3 {
addTestSource('''
class A {int x; int y() => 0;}
main(){var a; if (^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
assertNotSuggested('main');
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_IfStatement_empty() async {
// SimpleIdentifier IfStatement
addTestSource('''
class A {var b; X _c; foo() {A a; if (^) something}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('b');
assertNotSuggested('_c');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('A');
assertNotSuggested('==');
}
@@ -2634,10 +2692,11 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier PrefixIdentifier IfStatement
addTestSource('''
main() {var a; if (a.^) something}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestMethod('toString', 'Object', 'String');
+ assertNotSuggested('toString');
assertNotSuggested('Object');
assertNotSuggested('A');
assertNotSuggested('==');
@@ -2648,13 +2707,14 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "dart^";
main() {}''');
+
await computeSuggestions();
assertNoSuggestions();
}
test_IndexExpression() async {
// ExpressionStatement Block
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -2666,6 +2726,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} f[^]}}''');
+
await computeSuggestions();
assertNotSuggested('x');
assertNotSuggested('f');
@@ -2673,8 +2734,8 @@ class C1 extends C2 implements C3 {
assertNotSuggested('C');
assertNotSuggested('F2');
assertNotSuggested('T2');
- assertNotSuggested('A');
- assertNotSuggested('F1');
+ assertSuggestClass('A');
+ assertSuggestFunction('F1', 'dynamic');
// TODO (danrubel) getter is being suggested instead of top level var
//assertSuggestImportedTopLevelVar('T1', 'int');
}
@@ -2693,6 +2754,7 @@ class C1 extends C2 implements C3 {
F2() { }
class B {int x;}
class C {foo(){var f; {var x;} f[T^]}}''');
+
await computeSuggestions();
// top level results are partially filtered based on first char
assertNotSuggested('T2');
@@ -2715,12 +2777,14 @@ class C1 extends C2 implements C3 {
F2() { }
class B {B(this.x, [String boo]) { } int x;}
class C {foo(){var f; {var x;} new ^}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('Future');
- assertNotSuggested('A');
+ assertSuggestConstructor('Object');
+ assertSuggestConstructor('Future');
+ assertSuggestConstructor('A');
+ // Suggested by ConstructorContributor
assertNotSuggested('B');
assertNotSuggested('C');
assertNotSuggested('f');
@@ -2728,7 +2792,7 @@ class C1 extends C2 implements C3 {
assertNotSuggested('foo');
assertNotSuggested('F1');
assertNotSuggested('F2');
- assertNotSuggested('T1');
+ assertSuggestTopLevelVar('T1', null);
assertNotSuggested('T2');
}
@@ -2736,9 +2800,11 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier TypeName ConstructorName InstanceCreationExpression
addSource('/testAB.dart', 'class Foo { }');
addTestSource('class C {foo(){new F^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
+ // Not imported, so not suggested
assertNotSuggested('Future');
assertNotSuggested('Foo');
}
@@ -2759,12 +2825,13 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
main() {String name; print("hello \$^");}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('Object');
- // TODO(danrubel) should return top level var rather than getter
- assertNotSuggested('F1');
+ assertSuggestTopLevelVar('T1', null);
+ assertSuggestFunction('F1', null);
assertNotSuggested('D1');
assertNotSuggested('C1');
assertNotSuggested('T2');
@@ -2790,13 +2857,17 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
main() {String name; print("hello \${^}");}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestClass('Object');
+ // Simulate unresolved imported library
+ // in which case suggestions will have null (unresolved) returnType
+ assertSuggestTopLevelVar('T1', null);
+ assertSuggestFunction('F1', null);
+ assertSuggestFunctionTypeAlias('D1', 'null');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -2807,19 +2878,21 @@ class C1 extends C2 implements C3 {
test_InterpolationExpression_block2() async {
// SimpleIdentifier InterpolationExpression StringInterpolation
addTestSource('main() {String name; print("hello \${n^}");}');
+
await computeSuggestions();
assertNotSuggested('name');
// top level results are partially filtered
- //assertNotSuggested('Object');
+ //assertSuggestClass('Object');
}
test_InterpolationExpression_prefix_selector() async {
// SimpleIdentifier PrefixedIdentifier InterpolationExpression
addTestSource('main() {String name; print("hello \${name.^}");}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
assertNotSuggested('name');
assertNotSuggested('Object');
assertNotSuggested('==');
@@ -2828,6 +2901,7 @@ class C1 extends C2 implements C3 {
test_InterpolationExpression_prefix_selector2() async {
// SimpleIdentifier PrefixedIdentifier InterpolationExpression
addTestSource('main() {String name; print("hello \$name.^");}');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -2835,10 +2909,11 @@ class C1 extends C2 implements C3 {
test_InterpolationExpression_prefix_target() async {
// SimpleIdentifier PrefixedIdentifier InterpolationExpression
addTestSource('main() {String name; print("hello \${nam^e.length}");}');
+
await computeSuggestions();
assertNotSuggested('name');
// top level results are partially filtered
- //assertNotSuggested('Object');
+ //assertSuggestClass('Object');
assertNotSuggested('length');
}
@@ -2854,10 +2929,11 @@ class C1 extends C2 implements C3 {
import "/testB.dart";
class Y {Y.c(); Y._d(); z() {}}
main() {var x; if (x is ^) { }}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('X');
+ assertSuggestClass('X');
assertNotSuggested('Y');
assertNotSuggested('x');
assertNotSuggested('main');
@@ -2871,6 +2947,7 @@ class C1 extends C2 implements C3 {
void bar() { }
class A {int x; int y() => 0;}
main(){var a; if (^ is A)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -2879,7 +2956,7 @@ class C1 extends C2 implements C3 {
assertNotSuggested('foo');
assertNotSuggested('bar');
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_IsExpression_type() async {
@@ -2887,13 +2964,14 @@ class C1 extends C2 implements C3 {
addTestSource('''
class A {int x; int y() => 0;}
main(){var a; if (a is ^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('a');
assertNotSuggested('main');
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
test_IsExpression_type_partial() async {
@@ -2901,17 +2979,18 @@ class C1 extends C2 implements C3 {
addTestSource('''
class A {int x; int y() => 0;}
main(){var a; if (a is Obj^)}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 3);
expect(replacementLength, 3);
assertNotSuggested('a');
assertNotSuggested('main');
assertNotSuggested('A');
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
}
- test_keyword2() async {
- addSource(
+ test_keyword() async {
+ resolveSource(
'/testB.dart',
'''
lib B;
@@ -2924,14 +3003,16 @@ class C1 extends C2 implements C3 {
String newer() {}
var m;
main() {new^ X.c();}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 3);
expect(replacementLength, 3);
assertNotSuggested('c');
assertNotSuggested('_d');
// Imported suggestion are filtered by 1st character
- assertNotSuggested('nowIsIt');
- assertNotSuggested('T1');
+ assertSuggestFunction('nowIsIt', 'dynamic');
+ assertSuggestTopLevelVar('T1', 'int');
+ assertSuggestTopLevelVar('newT1', 'int');
assertNotSuggested('z');
assertNotSuggested('m');
assertNotSuggested('newer');
@@ -2940,26 +3021,36 @@ class C1 extends C2 implements C3 {
test_Literal_list() async {
// ']' ListLiteral ArgumentList MethodInvocation
addTestSource('main() {var Some; print([^]);}');
+
await computeSuggestions();
assertNotSuggested('Some');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_Literal_list2() async {
// SimpleIdentifier ListLiteral ArgumentList MethodInvocation
addTestSource('main() {var Some; print([S^]);}');
+
await computeSuggestions();
assertNotSuggested('Some');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_Literal_string() async {
// SimpleStringLiteral ExpressionStatement Block
addTestSource('class A {a() {"hel^lo"}}');
+
await computeSuggestions();
assertNoSuggestions();
}
+ test_localVariableDeclarationName() async {
+ addTestSource('main() {String m^}');
+ await computeSuggestions();
+ assertNotSuggested('main');
+ assertNotSuggested('min');
+ }
+
test_MapLiteralEntry() async {
// MapLiteralEntry MapLiteral VariableDeclaration
addSource(
@@ -2976,13 +3067,15 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
foo = {^''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', null);
+ assertSuggestFunction('F1', null);
+ assertSuggestFunctionTypeAlias('D1', 'null');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -3005,15 +3098,19 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
foo = {T^''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
+ // Simulate unresolved imported library,
+ // in which case suggestions will have null return types (unresolved)
+ assertSuggestTopLevelVar('T1', null);
assertNotSuggested('T2');
}
test_MapLiteralEntry2() async {
// SimpleIdentifier MapLiteralEntry MapLiteral VariableDeclaration
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -3027,15 +3124,18 @@ class C1 extends C2 implements C3 {
typedef D2();
class C2 { }
foo = {7:T^};''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('T2');
}
test_MethodDeclaration_body_getters() async {
// Block BlockFunctionBody MethodDeclaration
addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3067,6 +3167,7 @@ class C1 extends C2 implements C3 {
static a3() {}
static var a4;
static a() {^}}''');
+
await computeSuggestions();
assertNotSuggested('a1');
assertNotSuggested('a2');
@@ -3085,18 +3186,20 @@ class C1 extends C2 implements C3 {
test_MethodDeclaration_members() async {
// Block BlockFunctionBody MethodDeclaration
addTestSource('class A {@deprecated X f; Z _a() {^} var _g;}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('_a');
assertNotSuggested('f');
assertNotSuggested('_g');
- assertNotSuggested('bool');
+ assertSuggestClass('bool');
}
test_MethodDeclaration_parameters_named() async {
// Block BlockFunctionBody MethodDeclaration
addTestSource('class A {@deprecated Z a(X x, _, b, {y: boo}) {^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3104,7 +3207,7 @@ class C1 extends C2 implements C3 {
assertNotSuggested('x');
assertNotSuggested('y');
assertNotSuggested('b');
- assertNotSuggested('int');
+ assertSuggestClass('int');
assertNotSuggested('_');
}
@@ -3114,6 +3217,7 @@ class C1 extends C2 implements C3 {
foo() { }
void bar() { }
class A {Z a(X x, [int y=1]) {^}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3122,12 +3226,12 @@ class C1 extends C2 implements C3 {
assertNotSuggested('a');
assertNotSuggested('x');
assertNotSuggested('y');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_MethodDeclaration_returnType() async {
// ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -3140,14 +3244,15 @@ class C1 extends C2 implements C3 {
F2() { }
typedef D2();
class C2 {^ zoo(z) { } String name; }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -3157,7 +3262,7 @@ class C1 extends C2 implements C3 {
test_MethodDeclaration_returnType_afterComment() async {
// ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -3170,14 +3275,15 @@ class C1 extends C2 implements C3 {
F2() { }
typedef D2();
class C2 {/* */ ^ zoo(z) { } String name; }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -3187,7 +3293,7 @@ class C1 extends C2 implements C3 {
test_MethodDeclaration_returnType_afterComment2() async {
// MethodDeclaration ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -3200,14 +3306,15 @@ class C1 extends C2 implements C3 {
F2() { }
typedef D2();
class C2 {/** */ ^ zoo(z) { } String name; }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -3217,7 +3324,7 @@ class C1 extends C2 implements C3 {
test_MethodDeclaration_returnType_afterComment3() async {
// MethodDeclaration ClassDeclaration CompilationUnit
- addSource(
+ resolveSource(
'/testA.dart',
'''
int T1;
@@ -3232,14 +3339,15 @@ class C1 extends C2 implements C3 {
class C2 {
/// some dartdoc
^ zoo(z) { } String name; }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('F1');
- assertNotSuggested('D1');
- assertNotSuggested('C1');
+ assertSuggestFunctionTypeAlias('D1', 'dynamic');
+ assertSuggestClass('C1');
assertNotSuggested('T2');
assertNotSuggested('F2');
assertNotSuggested('D2');
@@ -3259,11 +3367,12 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {x.^ m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestGetter('f', 'X');
- assertSuggestGetter('_g', null);
+ assertNotSuggested('f');
+ assertNotSuggested('_g');
assertNotSuggested('b');
assertNotSuggested('_c');
assertNotSuggested('d');
@@ -3281,10 +3390,11 @@ class C1 extends C2 implements C3 {
test_new_instance() async {
addTestSource('import "dart:math"; class A {x() {new Random().^}}');
+
await computeSuggestions();
- assertSuggestMethod('nextBool', 'Random', 'bool');
- assertSuggestMethod('nextDouble', 'Random', 'double');
- assertSuggestMethod('nextInt', 'Random', 'int');
+ assertNotSuggested('nextBool');
+ assertNotSuggested('nextDouble');
+ assertNotSuggested('nextInt');
assertNotSuggested('Random');
assertNotSuggested('Object');
assertNotSuggested('A');
@@ -3318,16 +3428,20 @@ class C1 extends C2 implements C3 {
part of libA;
class B { factory B.bar(int x) => null; }
main() {new ^}''');
+
+ await computeLibrariesContaining();
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
+ // Suggested by ConstructorContributor
assertNotSuggested('B.bar');
- assertNotSuggested('Object');
- assertNotSuggested('X.c');
+ assertSuggestConstructor('Object');
+ assertSuggestConstructor('X.c');
assertNotSuggested('X._d');
+ // Suggested by LocalLibraryContributor
assertNotSuggested('A');
assertNotSuggested('F1');
- assertNotSuggested('T1');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('_d');
assertNotSuggested('z');
assertNotSuggested('m');
@@ -3338,7 +3452,7 @@ class C1 extends C2 implements C3 {
addSource(
'/testB.dart',
'''
- lib B;
+ lib libB;
int T1;
F1() { }
class X {X.c(); X._d(); z() {}}''');
@@ -3354,16 +3468,20 @@ class C1 extends C2 implements C3 {
class A { A({String boo: 'hoo'}) { } }
main() {new ^}
var m;''');
+
+ await computeLibrariesContaining();
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
+ // Suggested by ConstructorContributor
assertNotSuggested('A');
- assertNotSuggested('Object');
- assertNotSuggested('X.c');
+ assertSuggestConstructor('Object');
+ assertSuggestConstructor('X.c');
assertNotSuggested('X._d');
+ // Suggested by LocalLibraryContributor
assertNotSuggested('B');
assertNotSuggested('F1');
- assertNotSuggested('T1');
+ assertSuggestTopLevelVar('T1', 'int');
assertNotSuggested('_d');
assertNotSuggested('z');
assertNotSuggested('m');
@@ -3392,6 +3510,7 @@ class C1 extends C2 implements C3 {
static const String scA = 'foo';
w() { }}
main() {A.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3434,19 +3553,20 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testB.dart";
main() {A a; a.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('sc');
- assertSuggestField('b', null, isDeprecated: true);
+ assertNotSuggested('b');
assertNotSuggested('_c');
- assertSuggestGetter('d', 'X');
+ assertNotSuggested('d');
assertNotSuggested('_e');
- assertSuggestGetter('f', 'X');
+ assertNotSuggested('f');
assertNotSuggested('_g');
- assertSuggestSetter('s1');
+ assertNotSuggested('s1');
assertNotSuggested('_s2');
- assertSuggestMethod('m', 'A', null);
+ assertNotSuggested('m');
assertNotSuggested('_n');
assertNotSuggested('a');
assertNotSuggested('A');
@@ -3467,20 +3587,21 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
assertNotSuggested('sc');
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
- assertSuggestGetter('d', 'X');
- assertSuggestGetter('_e', null);
- assertSuggestGetter('f', 'X');
- assertSuggestGetter('_g', null);
- assertSuggestSetter('s1');
- assertSuggestSetter('_s2');
- assertSuggestMethod('m', 'A', null);
- assertSuggestMethod('_n', 'A', 'I');
+ 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');
@@ -3491,8 +3612,9 @@ class C1 extends C2 implements C3 {
test_PrefixedIdentifier_getter() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('String get g => "one"; f() {g.^}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_library() async {
@@ -3509,6 +3631,7 @@ class C1 extends C2 implements C3 {
var T2;
class A { }
main() {b.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3537,6 +3660,7 @@ class C1 extends C2 implements C3 {
var T2;
class A { }
foo(b.^ f) {}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3565,6 +3689,7 @@ class C1 extends C2 implements C3 {
var T2;
class A { }
foo(b.^) {}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3591,10 +3716,11 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testB.dart";
foo(X x) {x.^}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestField('y', 'M');
+ assertNotSuggested('y');
assertNotSuggested('_z');
assertNotSuggested('==');
}
@@ -3609,10 +3735,11 @@ class C1 extends C2 implements C3 {
addTestSource('''
import "/testA.dart";
class X {foo(){A^.bar}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
- assertNotSuggested('A');
+ assertSuggestClass('A');
assertNotSuggested('X');
assertNotSuggested('foo');
assertNotSuggested('bar');
@@ -3622,114 +3749,121 @@ class C1 extends C2 implements C3 {
test_PrefixedIdentifier_propertyAccess() async {
// PrefixedIdentifier ExpressionStatement Block BlockFunctionBody
addTestSource('class A {String x; int get foo {x.^}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestGetter('isEmpty', 'bool');
- assertSuggestMethod('compareTo', 'Comparable', 'int');
+ assertNotSuggested('isEmpty');
+ assertNotSuggested('compareTo');
}
test_PrefixedIdentifier_propertyAccess_newStmt() async {
// PrefixedIdentifier ExpressionStatement Block BlockFunctionBody
addTestSource('class A {String x; int get foo {x.^ int y = 0;}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestGetter('isEmpty', 'bool');
- assertSuggestMethod('compareTo', 'Comparable', 'int');
+ assertNotSuggested('isEmpty');
+ assertNotSuggested('compareTo');
}
test_PrefixedIdentifier_trailingStmt_const() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('const String g = "hello"; f() {g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_field() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('class A {String g; f() {g.^ int y = 0;}}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_function() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('String g() => "one"; f() {g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_functionTypeAlias() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('typedef String g(); f() {g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_getter() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('String get g => "one"; f() {g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_local_typed() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('f() {String g; g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_local_untyped() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('f() {var g = "hello"; g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_method() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('class A {String g() {}; f() {g.^ int y = 0;}}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_param() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('class A {f(String g) {g.^ int y = 0;}}');
- await computeSuggestions();
- assertSuggestGetter('length', 'int');
- }
- test_localVariableDeclarationName() async {
- addTestSource('main() {String m^}');
await computeSuggestions();
- assertNotSuggested('main');
- assertNotSuggested('min');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_param2() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('f(String g) {g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PrefixedIdentifier_trailingStmt_topLevelVar() async {
// SimpleIdentifier PrefixedIdentifier ExpressionStatement
addTestSource('String g; f() {g.^ int y = 0;}');
+
await computeSuggestions();
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
}
test_PropertyAccess_expression() async {
// SimpleIdentifier MethodInvocation PropertyAccess ExpressionStatement
addTestSource('class A {a() {"hello".to^String().length}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 2);
expect(replacementLength, 8);
- assertSuggestGetter('length', 'int');
+ assertNotSuggested('length');
assertNotSuggested('A');
assertNotSuggested('a');
assertNotSuggested('Object');
@@ -3740,6 +3874,7 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier PropertyAccess ExpressionStatement
addSource('/testAB.dart', 'class Foo { }');
addTestSource('class C {foo(){.^}}');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -3748,6 +3883,7 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier PropertyAccess ExpressionStatement
addSource('/testAB.dart', 'class Foo { }');
addTestSource('main() {.^}');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -3755,10 +3891,11 @@ class C1 extends C2 implements C3 {
test_PropertyAccess_selector() async {
// SimpleIdentifier PropertyAccess ExpressionStatement Block
addTestSource('class A {a() {"hello".length.^}}');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestGetter('isEven', 'bool');
+ assertNotSuggested('isEven');
assertNotSuggested('A');
assertNotSuggested('a');
assertNotSuggested('Object');
@@ -3768,6 +3905,7 @@ class C1 extends C2 implements C3 {
test_SwitchStatement_c() async {
// SwitchStatement Block BlockFunctionBody MethodDeclaration
addTestSource('class A {String g(int x) {switch(x) {c^}}}');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -3775,16 +3913,18 @@ class C1 extends C2 implements C3 {
test_SwitchStatement_case() async {
// SwitchStatement Block BlockFunctionBody MethodDeclaration
addTestSource('class A {String g(int x) {var t; switch(x) {case 0: ^}}}');
+
await computeSuggestions();
assertNotSuggested('A');
assertNotSuggested('g');
assertNotSuggested('t');
- assertNotSuggested('String');
+ assertSuggestClass('String');
}
test_SwitchStatement_empty() async {
// SwitchStatement Block BlockFunctionBody MethodDeclaration
addTestSource('class A {String g(int x) {switch(x) {^}}}');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -3803,19 +3943,20 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {this.^ m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
- assertSuggestGetter('d', 'X');
- assertSuggestGetter('_e', null);
- assertSuggestGetter('f', 'X');
- assertSuggestGetter('_g', null);
- assertSuggestMethod('m', 'A', null);
- assertSuggestMethod('_n', 'A', 'I');
- assertSuggestSetter('s1');
- assertSuggestSetter('_s2');
+ assertNotSuggested('b');
+ assertNotSuggested('_c');
+ assertNotSuggested('d');
+ assertNotSuggested('_e');
+ assertNotSuggested('f');
+ assertNotSuggested('_g');
+ assertNotSuggested('m');
+ assertNotSuggested('_n');
+ assertNotSuggested('s1');
+ assertNotSuggested('_s2');
assertNotSuggested('z');
assertNotSuggested('I');
assertNotSuggested('A');
@@ -3838,19 +3979,20 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertSuggestField('b', null);
- assertSuggestField('_c', 'X');
- assertSuggestGetter('d', 'X');
- assertSuggestGetter('_e', null);
- assertSuggestGetter('f', 'X');
- assertSuggestGetter('_g', null);
- assertSuggestMethod('m', 'A', null);
- assertSuggestMethod('_n', 'A', 'I');
- assertSuggestSetter('s1');
- assertSuggestSetter('_s2');
+ assertNotSuggested('b');
+ assertNotSuggested('_c');
+ assertNotSuggested('d');
+ assertNotSuggested('_e');
+ assertNotSuggested('f');
+ assertNotSuggested('_g');
+ assertNotSuggested('m');
+ assertNotSuggested('_n');
+ assertNotSuggested('s1');
+ assertNotSuggested('_s2');
assertNotSuggested('z');
assertNotSuggested('I');
assertNotSuggested('A');
@@ -3873,6 +4015,7 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -3910,6 +4053,7 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
@@ -3946,6 +4090,7 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 1);
@@ -3982,6 +4127,7 @@ class C1 extends C2 implements C3 {
set s1(I x) {} set _s2(I x) {m(null);}
m(X x) {} I _n(X x) {}}
class X{}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
@@ -4008,6 +4154,7 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier VariableDeclaration VariableDeclarationList
// TopLevelVariableDeclaration
addTestSource('class A {} B ^');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -4016,13 +4163,14 @@ class C1 extends C2 implements C3 {
// SimpleIdentifier VariableDeclaration VariableDeclarationList
// TopLevelVariableDeclaration
addTestSource('class A {} var ^');
+
await computeSuggestions();
assertNoSuggestions();
}
test_TypeArgumentList() async {
// SimpleIdentifier BinaryExpression ExpressionStatement
- addSource(
+ resolveSource(
'/testA.dart',
'''
class C1 {int x;}
@@ -4035,12 +4183,13 @@ class C1 extends C2 implements C3 {
typedef int T2(int blat);
class C<E> {}
main() { C<^> c; }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('Object');
- assertNotSuggested('C1');
- assertNotSuggested('T1');
+ assertSuggestClass('Object');
+ assertSuggestClass('C1');
+ assertSuggestFunctionTypeAlias('T1', 'String');
assertNotSuggested('C2');
assertNotSuggested('T2');
assertNotSuggested('F1');
@@ -4062,10 +4211,11 @@ class C1 extends C2 implements C3 {
typedef int T2(int blat);
class C<E> {}
main() { C<C^> c; }''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset - 1);
expect(replacementLength, 1);
- assertNotSuggested('C1');
+ assertSuggestClass('C1');
assertNotSuggested('C2');
}
@@ -4083,6 +4233,7 @@ class C1 extends C2 implements C3 {
import "/testB.dart";
class Y {Y.c(); Y._d(); z() {}}
main() {var ^}''');
+
await computeSuggestions();
assertNoSuggestions();
}
@@ -4090,8 +4241,9 @@ class C1 extends C2 implements C3 {
test_VariableDeclarationList_final() async {
// VariableDeclarationList VariableDeclarationStatement Block
addTestSource('main() {final ^} class C { }');
+
await computeSuggestions();
- assertNotSuggested('Object');
+ assertSuggestClass('Object');
assertNotSuggested('C');
assertNotSuggested('==');
}
@@ -4110,10 +4262,11 @@ class C1 extends C2 implements C3 {
import "/testB.dart";
class Y {Y.c(); Y._d(); z() {}}
class C {bar(){var f; {var x;} var e = ^}}''');
+
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('X');
+ assertSuggestClass('X');
assertNotSuggested('_B');
assertNotSuggested('Y');
assertNotSuggested('C');
@@ -4125,7 +4278,7 @@ class C1 extends C2 implements C3 {
test_VariableDeclarationStatement_RHS_missing_semicolon() async {
// VariableDeclaration VariableDeclarationList
// VariableDeclarationStatement
- addSource(
+ resolveSource(
'/testB.dart',
'''
lib B;
@@ -4142,8 +4295,8 @@ class C1 extends C2 implements C3 {
await computeSuggestions();
expect(replacementOffset, completionOffset);
expect(replacementLength, 0);
- assertNotSuggested('X');
- assertNotSuggested('foo1');
+ assertSuggestClass('X');
+ assertSuggestFunction('foo1', 'dynamic');
assertNotSuggested('bar1');
assertNotSuggested('foo2');
assertNotSuggested('bar2');
« no previous file with comments | « pkg/analysis_server/test/services/completion/completion_test_util.dart ('k') | pkg/analysis_server/test/services/completion/dart/library_member_contributor_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698