| // Copyright (c) 2023, 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. |
| |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; |
| |
| import '../../../client/completion_driver_test.dart'; |
| |
| // TODO(brianwilkerson): The contents of this file were generated from an older |
| // style of tests. They need to be cleaned up (many contain test code that |
| // isn't used in the test), renamed, and moved into the appropriate 'location' |
| // or 'declaration' test class. |
| void main() { |
| defineReflectiveSuite(() { |
| defineReflectiveTests(ConvertedTest); |
| }); |
| } |
| |
| @reflectiveTest |
| class ConvertedTest extends AbstractCompletionDriverTest |
| with ConvertedTestCases {} |
| |
| mixin ConvertedTestCases on AbstractCompletionDriverTest { |
| Future<void> test_001_1() async { |
| allowedIdentifiers = {'toString', '=='}; |
| await computeSuggestions(''' |
| void r1(var v) { |
| v.^toString().hashCode |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 8 |
| suggestions |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_001_2() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| void r1(var v) { |
| v.toString^().hashCode |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 8 |
| suggestions |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_001_3() async { |
| allowedIdentifiers = {'hashCode', 'toString'}; |
| await computeSuggestions(''' |
| void r1(var v) { |
| v.toString().^hashCode |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 8 |
| suggestions |
| hashCode |
| kind: getter |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_001_4() async { |
| allowedIdentifiers = {'hashCode', 'toString'}; |
| await computeSuggestions(''' |
| void r1(var v) { |
| v.toString().hash^Code |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 4 |
| right: 4 |
| suggestions |
| hashCode |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_002_1() async { |
| allowedIdentifiers = {'vim'}; |
| await computeSuggestions(''' |
| void r2(var vim) { |
| v^.toString() |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| vim |
| kind: parameter |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_003_1() async { |
| allowedIdentifiers = {'a'}; |
| await computeSuggestions(''' |
| class A { |
| int a() => 3; |
| int b() => this.^a(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| a |
| kind: methodInvocation |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_004_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class A { |
| int x; |
| A() : this.^x = 1; |
| A.b() : this(); |
| A.c() : this.b(); |
| g() => new A.c(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| assert |
| kind: keyword |
| x |
| kind: localVariable |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_004_2() async { |
| allowedIdentifiers = {'b'}; |
| await computeSuggestions(''' |
| class A { |
| int x; |
| A() : this.x = 1; |
| A.b() : this(); |
| A.c() : this.^b(); |
| g() => new A.c(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| assert |
| kind: keyword |
| b |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_004_3() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class A { |
| int x; |
| A() : this.x = 1; |
| A.b() : this(); |
| A.c() : this.b(); |
| g() => new A.^c(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| c |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_005_1() async { |
| allowedIdentifiers = { |
| 'vq', |
| 'A', |
| 'vim', |
| 'vf', |
| 'this', |
| 'void', |
| 'null', |
| 'false' |
| }; |
| await computeSuggestions(''' |
| class A {} |
| void rr(var vim) { |
| var ^vq = v.toString(); |
| var vf; |
| v.toString(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_005_2() async { |
| allowedIdentifiers = { |
| 'vim', |
| 'A', |
| 'vf', |
| 'vq', |
| 'this', |
| 'void', |
| 'null', |
| 'false' |
| }; |
| await computeSuggestions(''' |
| class A {} |
| void rr(var vim) { |
| var vq = v^.toString(); |
| var vf; |
| v.toString(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| vim |
| kind: parameter |
| '''); |
| } |
| |
| Future<void> test_005_3() async { |
| allowedIdentifiers = {'vf', 'vq', 'vim', 'A'}; |
| await computeSuggestions(''' |
| class A {} |
| void rr(var vim) { |
| var vq = v.toString(); |
| var vf; |
| v^.toString(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| vf |
| kind: localVariable |
| vq |
| kind: localVariable |
| vim |
| kind: parameter |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_006_1() async { |
| allowedIdentifiers = {'va', 'b'}; |
| await computeSuggestions(''' |
| void r2(var vim, {va: 2, b: 3}) { |
| v^.toString() |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| va |
| kind: parameter |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_007_1() async { |
| allowedIdentifiers = {'va', 'b'}; |
| await computeSuggestions(''' |
| void r2(var vim, [va: 2, b: 3]) { |
| v^.toString() |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| va |
| kind: parameter |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_008_1() async { |
| await computeSuggestions(''' |
| ^class Aclass {} |
| class Bclass extends Aclass {} |
| abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass with Eclass {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| import ''; |
| kind: keyword |
| selection: 8 |
| export ''; |
| kind: keyword |
| selection: 8 |
| abstract |
| kind: keyword |
| base |
| kind: keyword |
| class |
| kind: keyword |
| const |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| enum |
| kind: keyword |
| extension |
| kind: keyword |
| external |
| kind: keyword |
| final |
| kind: keyword |
| interface |
| kind: keyword |
| late |
| kind: keyword |
| library |
| kind: keyword |
| mixin |
| kind: keyword |
| part ''; |
| kind: keyword |
| selection: 6 |
| part of ''; |
| kind: keyword |
| selection: 9 |
| sealed |
| kind: keyword |
| typedef |
| kind: keyword |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_008_2() async { |
| await computeSuggestions(''' |
| class Aclass {} |
| class Bclass ^extends Aclass {} |
| abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass with Eclass {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| extends |
| kind: keyword |
| implements |
| kind: keyword |
| with |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_008_3() async { |
| await computeSuggestions(''' |
| class Aclass {} |
| class Bclass extends^ Aclass {} |
| abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass with Eclass {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 7 |
| suggestions |
| extends |
| kind: keyword |
| '''); |
| } |
| |
| @FailingTest(reason: 'Bclass is being suggested, but it cannot extend itself') |
| Future<void> test_008_4() async { |
| allowedIdentifiers = {'Aclass', 'Bclass'}; |
| await computeSuggestions(''' |
| class Aclass {} |
| class Bclass extends ^Aclass {} |
| abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass with Eclass {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| Aclass |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_008_5() async { |
| await computeSuggestions(''' |
| class Aclass {} |
| class Bclass extends Aclass {} |
| ^abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass with Eclass {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 8 |
| suggestions |
| class |
| kind: keyword |
| const |
| kind: keyword |
| void |
| kind: keyword |
| final |
| kind: keyword |
| enum |
| kind: keyword |
| typedef |
| kind: keyword |
| abstract |
| kind: keyword |
| base |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| extension |
| kind: keyword |
| external |
| kind: keyword |
| interface |
| kind: keyword |
| late |
| kind: keyword |
| mixin |
| kind: keyword |
| sealed |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_008_6() async { |
| await computeSuggestions(''' |
| class Aclass {} |
| class Bclass extends Aclass {} |
| abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass ^with Eclass {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| implements |
| kind: keyword |
| with |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_008_7() async { |
| allowedIdentifiers = {'Eclass', 'Dclass', 'Ctype'}; |
| await computeSuggestions(''' |
| class Aclass {} |
| class Bclass extends Aclass {} |
| abstract class Eclass implements Aclass, Bclass {} |
| class Fclass extends Bclass with ^ Eclass {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Eclass |
| kind: class |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_009_1() async { |
| allowedIdentifiers = {'void', 'TestFn2'}; |
| await computeSuggestions(''' |
| typedef ^dynamic TestFn1(); |
| typedef void TestFn2(); |
| typedef n |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| dynamic |
| kind: keyword |
| TestFn2 |
| kind: typeAlias |
| void |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_009_2() async { |
| allowedIdentifiers = {'dynamic', 'void'}; |
| await computeSuggestions(''' |
| typedef dy^namic TestFn1(); |
| typedef void TestFn2(); |
| typedef n |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 5 |
| suggestions |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_009_3() async { |
| allowedIdentifiers = {'dynamic'}; |
| await computeSuggestions(''' |
| typedef dynamic TestFn1(); |
| typedef ^void TestFn2(); |
| typedef n |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_009_4() async { |
| allowedIdentifiers = {'void', 'dynamic'}; |
| await computeSuggestions(''' |
| typedef dynamic TestFn1(); |
| typedef vo^id TestFn2(); |
| typedef n |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 2 |
| suggestions |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_009_5() async { |
| allowedIdentifiers = {'TestFn2'}; |
| await computeSuggestions(''' |
| typedef dynamic TestFn1(); |
| typedef void TestFn2(); |
| typedef ^n |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| TestFn2 |
| kind: typeAlias |
| '''); |
| } |
| |
| Future<void> test_009_6() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| typedef dynamic TestFn1(); |
| typedef void TestFn2(); |
| typedef n^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| num |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_009_7() async { |
| await computeSuggestions(''' |
| typedef dynamic TestFn1(); |
| typedef void TestFn2(); |
| typ^edef n |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| right: 4 |
| suggestions |
| typedef |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_010_1() async { |
| allowedIdentifiers = {'String', 'List', 'test'}; |
| await computeSuggestions(''' |
| class test <^t extends String, List, > {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_010_2() async { |
| allowedIdentifiers = {'String', 'test'}; |
| await computeSuggestions(''' |
| class test <t ^ extends String, List, > {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_3() async { |
| await computeSuggestions(''' |
| class test <t ^extends String, List, > {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| extends |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_010_4() async { |
| allowedIdentifiers = {'tezetst', 'test'}; |
| await computeSuggestions(''' |
| class test <t extends String,^ List, > {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_5() async { |
| allowedIdentifiers = {'String'}; |
| await computeSuggestions(''' |
| class test <t extends String, List,^ > {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_6() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, ^> {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_7() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, >^ {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_8() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class test ^<t extends String, List, > {} |
| class tezetst <String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_9() async { |
| allowedIdentifiers = {'String'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, > {} |
| class tezetst ^<String, List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_A() async { |
| allowedIdentifiers = {'String'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, > {} |
| class tezetst <String, List>^ {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_B() async { |
| allowedIdentifiers = {'String'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, > {} |
| class tezetst <^String, List> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_C() async { |
| allowedIdentifiers = {'List', 'tezetst'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, > {} |
| class tezetst <String,^ List> {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_010_D() async { |
| allowedIdentifiers = {'List', 'test'}; |
| await computeSuggestions(''' |
| class test <t extends String, List, > {} |
| class tezetst <String, ^List> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_011_1() async { |
| allowedIdentifiers = {'object2'}; |
| await computeSuggestions(''' |
| r2(var object, Object object1, Object ^); |
| '''); |
| assertResponse(r''' |
| suggestions |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| final |
| kind: keyword |
| object2 |
| kind: identifier |
| void |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_012_1() async { |
| allowedIdentifiers = {'var', 'dynamic', 'f'}; |
| await computeSuggestions(''' |
| class X { |
| f() { |
| g(^var z) {true.toString();}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| dynamic |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_012_2() async { |
| allowedIdentifiers = {'var', 'dynamic'}; |
| await computeSuggestions(''' |
| class X { |
| f() { |
| g(var^ z) {true.toString();}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_012_3() async { |
| await computeSuggestions(''' |
| class X { |
| f() { |
| g(var z) {^true.toString();}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_012_4() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| class X { |
| f() { |
| g(var z) {true.^toString();}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 8 |
| suggestions |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_013_0() async { |
| allowedIdentifiers = {'k'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(k) {case 1:{^}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| k |
| kind: field |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| break |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (^x ); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| true |
| kind: keyword |
| x |
| kind: field |
| false |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_2() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(^x ); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| false |
| kind: keyword |
| true |
| kind: keyword |
| x |
| kind: field |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_3() async { |
| allowedIdentifiers = {'zs'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ); |
| for(z in ^zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| zs |
| kind: field |
| await |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_4() async { |
| allowedIdentifiers = {'k'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(^k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| k |
| kind: field |
| const |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_5() async { |
| allowedIdentifiers = {'Q', 'a'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on ^Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| Q |
| kind: class |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_6() async { |
| allowedIdentifiers = {'=='}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ^) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| case |
| kind: keyword |
| is |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_7() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (^x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| x |
| kind: field |
| false |
| kind: keyword |
| true |
| kind: keyword |
| null |
| kind: keyword |
| this |
| kind: keyword |
| const |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_013_8() async { |
| allowedIdentifiers = {'=='}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ); |
| do{} while(x ^); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_013_9() async { |
| allowedIdentifiers = {'=='}; |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (x ^); |
| do{} while(x ); |
| for(z in zs) {} |
| switch(k) {case 1:{}} |
| try { |
| } on Object catch(a){} |
| if (x ) {} else {}; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_014_1() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| ^while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| break |
| kind: keyword |
| continue |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_2() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| ^do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| break |
| kind: keyword |
| continue |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_014_3() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } ^while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_4() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| ^for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| break |
| kind: keyword |
| continue |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_5() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z ^in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| in |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_6() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| ^for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| break |
| kind: keyword |
| continue |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_7() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| ^switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| break |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_8() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {^case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| case |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_9() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} ^default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| case |
| kind: keyword |
| default: |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_A() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| ^try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_B() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } ^on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| on |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_C() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object ^catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| catch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_D() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| ^var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| abstract |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| external |
| kind: keyword |
| late |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_E() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| ^void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_F() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| ^assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_G() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { ^continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 8 |
| suggestions |
| continue |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_H() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ ^break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| break |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_J() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| ^if (x) {} else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_014_K() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} ^else {}; |
| return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| else |
| kind: keyword |
| false |
| kind: keyword |
| final |
| kind: keyword |
| for |
| kind: keyword |
| if |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| return |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| throw |
| kind: keyword |
| true |
| kind: keyword |
| try |
| kind: keyword |
| var |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_014_L() async { |
| await computeSuggestions(''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| void mth() { |
| while (z) { continue; }; |
| do{ break; } while(x); |
| for(z in zs) {} |
| for (int i; i < 3; i++); |
| switch(k) {case 1:{} default:{}} |
| try { |
| } on Object catch(a){} |
| assert true; |
| if (x) {} else {}; |
| ^return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_015_1() async { |
| allowedIdentifiers = {'=='}; |
| await computeSuggestions(''' |
| f(a,b,c) => a + b * c ^; |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_016_1() async { |
| allowedIdentifiers = {'=='}; |
| await computeSuggestions(''' |
| class X {dynamic f(a,b,c) {return a + b * c ^;}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| const |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_1() async { |
| await computeSuggestions(''' |
| ^import 'x' as r; |
| export 'uri' hide Q show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| library |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_2() async { |
| await computeSuggestions(''' |
| ^import 'x' as r; |
| export 'uri' hide Q show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| import |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_3() async { |
| await computeSuggestions(''' |
| import 'x' as r; |
| ^export 'uri' hide Q show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| export |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_4() async { |
| await computeSuggestions(''' |
| import 'x' as r; |
| export 'uri' hide Q show X; |
| ^part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| part |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_5() async { |
| await computeSuggestions(''' |
| import 'x' ^as r; |
| export 'uri' hide Q show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| as |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_6() async { |
| await computeSuggestions(''' |
| import 'x' as r; |
| export 'uri' ^hide Q show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| hide |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_017_7() async { |
| await computeSuggestions(''' |
| import 'x' as r; |
| export 'uri' hide Q ^show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| show |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_017_8() async { |
| await computeSuggestions(''' |
| import 'x' as r; |
| export '^uri' hide Q show X; |
| part 'x'; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| dart: |
| kind: import |
| dart:async |
| kind: import |
| dart:async2 |
| kind: import |
| dart:collection |
| kind: import |
| dart:convert |
| kind: import |
| dart:ffi |
| kind: import |
| dart:html |
| kind: import |
| dart:io |
| kind: import |
| dart:isolate |
| kind: import |
| dart:math |
| kind: import |
| dart:typed_data |
| kind: import |
| package: |
| kind: import |
| package:test/ |
| kind: import |
| package:test/test.dart |
| kind: import |
| dart:core |
| kind: import |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_018_1() async { |
| await computeSuggestions(''' |
| ^part of foo; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| part |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_018_2() async { |
| await computeSuggestions(''' |
| part ^of foo; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| of |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_019_1() async { |
| allowedIdentifiers = {'true', 'truefalse', 'falsetrue'}; |
| await computeSuggestions(''' |
| var truefalse = 0; |
| var falsetrue = 1; |
| void f() { |
| var foo = true^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 4 |
| suggestions |
| falsetrue |
| kind: topLevelVariable |
| truefalse |
| kind: topLevelVariable |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_020_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| var x = null.^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_021_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| var x = .^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_022_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| var x = .^; |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_023_1() async { |
| allowedIdentifiers = {'getKeys'}; |
| await computeSuggestions(''' |
| class Map{getKeys(){}} |
| class X { |
| static x1(Map m) { |
| m.^getKeys; |
| } |
| x2(Map m) { |
| m.getKeys; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| getKeys |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_023_2() async { |
| allowedIdentifiers = {'getKeys'}; |
| await computeSuggestions(''' |
| class Map{getKeys(){}} |
| class X { |
| static x1(Map m) { |
| m.getKeys; |
| } |
| x2(Map m) { |
| m.^getKeys; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| getKeys |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_024_1() async { |
| allowedIdentifiers = {'from'}; |
| await computeSuggestions(''' |
| class List{factory List.from(Iterable other) {}} |
| class F { |
| f() { |
| new List.^ |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| from |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_025_1() async { |
| allowedIdentifiers = {'m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = ^m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| m |
| kind: field |
| const |
| kind: keyword |
| false |
| kind: keyword |
| true |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_025_2() async { |
| allowedIdentifiers = {'_m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _^m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| _m |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_025_3() async { |
| allowedIdentifiers = {'g'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = ^g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| const |
| kind: keyword |
| false |
| kind: keyword |
| g |
| kind: methodInvocation |
| true |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_025_4() async { |
| allowedIdentifiers = {'m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = ^m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| m |
| kind: field |
| const |
| kind: keyword |
| false |
| kind: keyword |
| true |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_025_5() async { |
| allowedIdentifiers = {'_m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _^m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| _m |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_025_6() async { |
| allowedIdentifiers = {'g'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = ^g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| const |
| kind: keyword |
| false |
| kind: keyword |
| g |
| kind: methodInvocation |
| true |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_025_7() async { |
| allowedIdentifiers = {'g'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.^g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_025_8() async { |
| allowedIdentifiers = {'m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.^m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_025_9() async { |
| allowedIdentifiers = {'_m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._^m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_025_A() async { |
| allowedIdentifiers = {'_m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._^m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| _m |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_025_B() async { |
| allowedIdentifiers = {'m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.^m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| m |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_025_C() async { |
| allowedIdentifiers = {'g'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.^g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| g |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_025_D() async { |
| allowedIdentifiers = {'_m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._^m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| _m |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_025_E() async { |
| allowedIdentifiers = {'m'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.^m; |
| var h = R.g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| m |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_025_F() async { |
| allowedIdentifiers = {'g'}; |
| await computeSuggestions(''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| static g() { |
| var a = m; |
| var b = _m; |
| var c = g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.g(); |
| x.m; |
| x._m; |
| } |
| static g() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.g(); |
| } |
| h() { |
| var q = R._m; |
| var g = R.m; |
| var h = R.^g(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| g |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_026_1() async { |
| allowedIdentifiers = {'aBcD'}; |
| await computeSuggestions(''' |
| var aBcD; var x=ab^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| aBcD |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_027_1() async { |
| allowedIdentifiers = {'ssss'}; |
| await computeSuggestions(''' |
| m(){try{}catch(eeee,ssss){s^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| ssss |
| kind: localVariable |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_028_1() async { |
| allowedIdentifiers = {'isX'}; |
| await computeSuggestions(''' |
| m(){var isX=3;if(is^) |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| is |
| kind: keyword |
| isX |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_029_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| m(){[1].forEach((x)=>^x);} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| x |
| kind: parameter |
| null |
| kind: keyword |
| false |
| kind: keyword |
| true |
| kind: keyword |
| const |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_030_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| n(){[1].forEach((x){^});} |
| '''); |
| assertResponse(r''' |
| suggestions |
| x |
| kind: parameter |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_031_1() async { |
| allowedIdentifiers = {'Caster', 'CastBlock'}; |
| await computeSuggestions(''' |
| class Caster {} m() {try {} on Cas^ter catch (CastBlock) {}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| right: 3 |
| suggestions |
| Caster |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_031_2() async { |
| allowedIdentifiers = {'Caster', 'CastBlock'}; |
| await computeSuggestions(''' |
| class Caster {} m() {try {} on Caster catch (CastBlock) {^}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| CastBlock |
| kind: localVariable |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| Caster |
| kind: class |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| Caster |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| rethrow |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_032_1() async { |
| allowedIdentifiers = {'ONE', 'UKSI'}; |
| await computeSuggestions(''' |
| const ONE = 1; |
| const ICHI = 10; |
| const UKSI = 100; |
| const EIN = 1000; |
| m() { |
| int x; |
| switch (x) { |
| case ICHI: |
| case UKSI: |
| case EIN: |
| case ONE^: return; |
| default: return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| ONE |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_032_2() async { |
| allowedIdentifiers = {'EIN', 'ICHI'}; |
| await computeSuggestions(''' |
| const ONE = 1; |
| const ICHI = 10; |
| const UKSI = 100; |
| const EIN = 1000; |
| m() { |
| int x; |
| switch (x) { |
| case ICHI: |
| case UKSI: |
| case EIN^: |
| case ONE: return; |
| default: return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| EIN |
| kind: topLevelVariable |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_032_3() async { |
| allowedIdentifiers = {'ICHI', 'UKSI', 'EIN', 'ONE'}; |
| await computeSuggestions(''' |
| const ONE = 1; |
| const ICHI = 10; |
| const UKSI = 100; |
| const EIN = 1000; |
| m() { |
| int x; |
| switch (x) { |
| case ^ICHI: |
| case UKSI: |
| case EIN: |
| case ONE: return; |
| default: return; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| const |
| kind: keyword |
| EIN |
| kind: topLevelVariable |
| false |
| kind: keyword |
| final |
| kind: keyword |
| ICHI |
| kind: topLevelVariable |
| null |
| kind: keyword |
| ONE |
| kind: topLevelVariable |
| true |
| kind: keyword |
| UKSI |
| kind: topLevelVariable |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_033_1() async { |
| allowedIdentifiers = {'b', 'c'}; |
| await computeSuggestions(''' |
| class A{}class B extends A{b(){}}class C implements A {c(){}}class X{x(){A f;f.^}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_034_1() async { |
| allowedIdentifiers = {'top'}; |
| await computeSuggestions(''' |
| var topvar; |
| class Top {top(){}} |
| class Left extends Top {left(){}} |
| class Right extends Top {right(){}} |
| t1() { |
| topvar = new Left(); |
| } |
| t2() { |
| topvar = new Right(); |
| } |
| class A { |
| var field; |
| a() { |
| field = new Left(); |
| } |
| b() { |
| field = new Right(); |
| } |
| test() { |
| topvar.^top(); |
| field.top(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_034_2() async { |
| allowedIdentifiers = {'top'}; |
| await computeSuggestions(''' |
| var topvar; |
| class Top {top(){}} |
| class Left extends Top {left(){}} |
| class Right extends Top {right(){}} |
| t1() { |
| topvar = new Left(); |
| } |
| t2() { |
| topvar = new Right(); |
| } |
| class A { |
| var field; |
| a() { |
| field = new Left(); |
| } |
| b() { |
| field = new Right(); |
| } |
| test() { |
| topvar.top(); |
| field.^top(); |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_035_1() async { |
| allowedIdentifiers = {'length'}; |
| await computeSuggestions(''' |
| class Y {final x='hi';mth() {x.^length;}} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| length |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_036_1() async { |
| allowedIdentifiers = {'round'}; |
| await computeSuggestions(''' |
| class A1 { |
| var field; |
| A1() : field = 0; |
| q() { |
| A1 a = new A1(); |
| a.field.^ |
| } |
| } |
| void f() { |
| A1 a = new A1(); |
| a.field. |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_036_2() async { |
| allowedIdentifiers = {'round'}; |
| await computeSuggestions(''' |
| class A1 { |
| var field; |
| A1() : field = 0; |
| q() { |
| A1 a = new A1(); |
| a.field. |
| } |
| } |
| void f() { |
| A1 a = new A1(); |
| a.field.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_037_1() async { |
| allowedIdentifiers = {'HttpServer', 'HttpClient'}; |
| await computeSuggestions(''' |
| class HttpServer{} |
| class HttpClient{} |
| void f() { |
| new HtS^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| HttpServer |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_038_1() async { |
| allowedIdentifiers = {'y', 'x'}; |
| await computeSuggestions(''' |
| class X { |
| x(){} |
| } |
| class Y { |
| y(){} |
| } |
| class A<Z extends X> { |
| Y ay; |
| Z az; |
| A(this.ay, this.az) { |
| ay.^y; |
| az.x; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| y |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_038_2() async { |
| allowedIdentifiers = {'x', 'y'}; |
| await computeSuggestions(''' |
| class X { |
| x(){} |
| } |
| class Y { |
| y(){} |
| } |
| class A<Z extends X> { |
| Y ay; |
| Z az; |
| A(this.ay, this.az) { |
| ay.y; |
| az.^x; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| x |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_039_1() async { |
| await computeSuggestions(''' |
| class X{}var x = null as ^X; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| dynamic |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_040_1() async { |
| await computeSuggestions(''' |
| m(){f(a, b, {x1, x2, y}) {};f(1, 2, ^);} |
| '''); |
| assertResponse(r''' |
| suggestions |
| |x1: | |
| kind: namedArgument |
| |x2: | |
| kind: namedArgument |
| |y: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_040_2() async { |
| await computeSuggestions(''' |
| m(){f(a, b, {x1, x2, y}) {};f(1, 2, )^;} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_041_1() async { |
| allowedIdentifiers = {'y'}; |
| await computeSuggestions(''' |
| m(){f(a, b, {x1, x2, y}) {};f(1, 2, ^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| |x1: | |
| kind: namedArgument |
| |x2: | |
| kind: namedArgument |
| |y: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_042_1() async { |
| await computeSuggestions(''' |
| m(){f(a, b, {x1, x2, y}) {};f(1, 2, ^; |
| '''); |
| assertResponse(r''' |
| suggestions |
| |x1: | |
| kind: namedArgument |
| |x2: | |
| kind: namedArgument |
| |y: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_042_2() async { |
| allowedIdentifiers = {'y'}; |
| await computeSuggestions(''' |
| m(){f(a, b, {x1, x2, y}) {};f(1, 2, ;^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_classMembers_inGetter_1() async { |
| allowedIdentifiers = {'fff'}; |
| await computeSuggestions(''' |
| class A { var fff; get z {ff^}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| fff |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets001_1() async { |
| allowedIdentifiers = {'MAX'}; |
| await computeSuggestions(''' |
| class X {static final num MAX = 0;num yc,xc;mth() {xc = yc = MA^X;xc.abs();num f = MAX;}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| MAX |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets001_2() async { |
| allowedIdentifiers = {'xc'}; |
| await computeSuggestions(''' |
| class X {static final num MAX = 0;num yc,xc;mth() {xc = yc = MAX;x^c.abs();num f = MAX;}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| xc |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets001_3() async { |
| allowedIdentifiers = {'MAX'}; |
| await computeSuggestions(''' |
| class X {static final num MAX = 0;num yc,xc;mth() {xc = yc = MAX;xc.abs();num f = M^AX;}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 2 |
| suggestions |
| MAX |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets002_1() async { |
| allowedIdentifiers = {'length'}; |
| await computeSuggestions(''' |
| class Y {String x='hi';mth() {x.l^ength;int n = 0;x.codeUnitAt(n);}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 5 |
| suggestions |
| length |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets002_2() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class Y {String x='hi';mth() {x.length;int n = 0;x^.codeUnitAt(n);}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| x |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets002_3() async { |
| allowedIdentifiers = {'n'}; |
| await computeSuggestions(''' |
| class Y {String x='hi';mth() {x.length;int n = 0;x.codeUnitAt(n^);}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| n |
| kind: localVariable |
| null |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets004_1() async { |
| allowedIdentifiers = {'A'}; |
| await computeSuggestions(''' |
| class A {^int x; mth() {int y = this.x;}}class B{} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| @override |
| // TODO: implement hashCode |
| int get hashCode => super.hashCode; |
| kind: override |
| selection: 62 14 |
| @override |
| // TODO: implement runtimeType |
| Type get runtimeType => super.runtimeType; |
| kind: override |
| selection: 69 17 |
| @override |
| String toString() { |
| // TODO: implement toString |
| return super.toString(); |
| } |
| kind: override |
| selection: 68 24 |
| @override |
| bool operator ==(Object other) { |
| // TODO: implement == |
| return super == other; |
| } |
| kind: override |
| selection: 75 22 |
| @override |
| noSuchMethod(Invocation invocation) { |
| // TODO: implement noSuchMethod |
| return super.noSuchMethod(invocation); |
| } |
| kind: override |
| selection: 90 38 |
| A |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets004_2() async { |
| allowedIdentifiers = {'B'}; |
| await computeSuggestions(''' |
| class A {int x; ^mth() {int y = this.x;}}class B{} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| B |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets004_3() async { |
| allowedIdentifiers = {'x', 'y'}; |
| await computeSuggestions(''' |
| class A {int x; mth() {^int y = this.x;}}class B{} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| return |
| kind: keyword |
| x |
| kind: field |
| if |
| kind: keyword |
| final |
| kind: keyword |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets004_5() async { |
| allowedIdentifiers = {'mth'}; |
| await computeSuggestions(''' |
| class A {int x; mth() {int y = this.^x;}}class B{} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| mth |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets004_6() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class A {int x; mth() {int y = this.x^;}}class B{} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| x |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets005_1() async { |
| allowedIdentifiers = {'Date'}; |
| await computeSuggestions(''' |
| class Date { static Date JUN, JUL;}class X { m() { return Da^te.JUL; }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 2 |
| suggestions |
| Date |
| kind: constructorInvocation |
| Date |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets005_2() async { |
| allowedIdentifiers = {'JUN', 'JUL'}; |
| await computeSuggestions(''' |
| class Date { static Date JUN, JUL;}class X { m() { return Date.JU^L; }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| JUL |
| kind: field |
| JUN |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets007_1() async { |
| allowedIdentifiers = {'bool'}; |
| await computeSuggestions(''' |
| class C {mth(Map x, ^) {}mtf(, Map x) {}m() {for (int i=0; i<5; i++); A x;}}class int{}class Arrays{} |
| '''); |
| assertResponse(r''' |
| suggestions |
| bool |
| kind: class |
| void |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| final |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets007_2() async { |
| allowedIdentifiers = {'bool'}; |
| await computeSuggestions(''' |
| class C {mth(Map x, ) {}mtf(^, Map x) {}m() {for (int i=0; i<5; i++); A x;}}class int{}class Arrays{} |
| '''); |
| assertResponse(r''' |
| suggestions |
| bool |
| kind: class |
| void |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| final |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets007_3() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class C {mth(Map x, ) {}mtf(, Map x) {}m() {for (in^t i=0; i<5; i++); A x;}}class int{}class Arrays{} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| int |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets007_4() async { |
| allowedIdentifiers = {'Arrays'}; |
| await computeSuggestions(''' |
| class C {mth(Map x, ) {}mtf(, Map x) {}m() {for (int i=0; i<5; i++); A^ x;}}class int{}class Arrays{} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| Arrays |
| kind: class |
| Arrays |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets008_1() async { |
| allowedIdentifiers = {'Date'}; |
| await computeSuggestions(''' |
| class Date{}final num M = Dat^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| Date |
| kind: constructorInvocation |
| Date |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets009_1() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class Maps{}class x extends M implements ^ |
| {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Map |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets009_2() async { |
| allowedIdentifiers = {'Maps'}; |
| await computeSuggestions(''' |
| class Maps{}class x extends ^M implements |
| {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| Maps |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets009_3() async { |
| allowedIdentifiers = {'Maps'}; |
| await computeSuggestions(''' |
| class Maps{}class x extends M^ implements |
| {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| Maps |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets009_4() async { |
| allowedIdentifiers = {'Maps'}; |
| await computeSuggestions(''' |
| class Maps{}class x extends M ^implements |
| {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 10 |
| suggestions |
| implements |
| kind: keyword |
| with |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets009_5() async { |
| allowedIdentifiers = {'Maps'}; |
| await computeSuggestions(''' |
| class Maps{}class x extends^ M implements |
| {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 7 |
| suggestions |
| extends |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets009_6() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class Maps{}class x extends M implements^ |
| {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 10 |
| suggestions |
| implements |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets010_1() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class x implements ^{} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Map |
| kind: class |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets011_1() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class x implements M^{} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| Map |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets012_1() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class x implements M^ |
| {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| Map |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets013_1() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| class x {^} |
| '''); |
| assertResponse(r''' |
| suggestions |
| @override |
| // TODO: implement hashCode |
| int get hashCode => super.hashCode; |
| kind: override |
| selection: 62 14 |
| @override |
| // TODO: implement runtimeType |
| Type get runtimeType => super.runtimeType; |
| kind: override |
| selection: 69 17 |
| @override |
| String toString() { |
| // TODO: implement toString |
| return super.toString(); |
| } |
| kind: override |
| selection: 68 24 |
| @override |
| bool operator ==(Object other) { |
| // TODO: implement == |
| return super == other; |
| } |
| kind: override |
| selection: 75 22 |
| @override |
| noSuchMethod(Invocation invocation) { |
| // TODO: implement noSuchMethod |
| return super.noSuchMethod(invocation); |
| } |
| kind: override |
| selection: 90 38 |
| num |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets013_2() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| class x ^{} |
| '''); |
| assertResponse(r''' |
| suggestions |
| extends |
| kind: keyword |
| implements |
| kind: keyword |
| with |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets013_3() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| class x {}^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| abstract |
| kind: keyword |
| base |
| kind: keyword |
| class |
| kind: keyword |
| const |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| enum |
| kind: keyword |
| extension |
| kind: keyword |
| external |
| kind: keyword |
| final |
| kind: keyword |
| interface |
| kind: keyword |
| late |
| kind: keyword |
| mixin |
| kind: keyword |
| num |
| kind: class |
| sealed |
| kind: keyword |
| typedef |
| kind: keyword |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets014_1() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| typedef n^ ; |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| num |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets015_1() async { |
| allowedIdentifiers = {'f'}; |
| await computeSuggestions(''' |
| class D {f(){} g(){f^(f);}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| final |
| kind: keyword |
| f |
| kind: methodInvocation |
| for |
| kind: keyword |
| false |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets015_2() async { |
| allowedIdentifiers = {'f'}; |
| await computeSuggestions(''' |
| class D {f(p){} g(){f(f^);}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| f |
| kind: methodInvocation |
| false |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets016_1() async { |
| allowedIdentifiers = {'m'}; |
| await computeSuggestions(''' |
| class F {m() { m(); ^}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| m |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets017_1() async { |
| await computeSuggestions(''' |
| class F {var x = ^false;} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| const |
| kind: keyword |
| false |
| kind: keyword |
| true |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets018_1() async { |
| allowedIdentifiers = {'Map', 'dynamic', 'void', 'null'}; |
| await computeSuggestions(''' |
| class Map{}class Arrays{}class C{ m(^){} n( x, q) |
| '''); |
| assertResponse(r''' |
| suggestions |
| Map |
| kind: class |
| void |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| final |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets018_2() async { |
| allowedIdentifiers = {'Arrays', 'void', 'null'}; |
| await computeSuggestions(''' |
| class Map{}class Arrays{}class C{ m(){} n(^ x, q) |
| '''); |
| assertResponse(r''' |
| suggestions |
| Arrays |
| kind: class |
| void |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| final |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets019_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| class A{m(){Object x;x.^/**/clear() |
| '''); |
| assertResponse(r''' |
| suggestions |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets020_1() async { |
| allowedIdentifiers = {'newt', 'newf', 'newz', 'Map'}; |
| await computeSuggestions(''' |
| classMap{}class tst {var newt;void newf(){}test() {var newz;new^/**/;}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| newz |
| kind: localVariable |
| newt |
| kind: field |
| newf |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets021_1() async { |
| allowedIdentifiers = {'Map', 'newt'}; |
| await computeSuggestions(''' |
| class Map{}class tst {var newt;void newf(){}test() {var newz;new ^/**/;}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Map |
| kind: constructorInvocation |
| Map.from |
| kind: constructorInvocation |
| Map.fromEntries |
| kind: constructorInvocation |
| Map.fromIterable |
| kind: constructorInvocation |
| Map.fromIterables |
| kind: constructorInvocation |
| Map.identity |
| kind: constructorInvocation |
| Map.unmodifiable |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets022_1() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class Map{}class F{m(){new ^;}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Map |
| kind: constructorInvocation |
| Map.from |
| kind: constructorInvocation |
| Map.fromEntries |
| kind: constructorInvocation |
| Map.fromIterable |
| kind: constructorInvocation |
| Map.fromIterables |
| kind: constructorInvocation |
| Map.identity |
| kind: constructorInvocation |
| Map.unmodifiable |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets022a_1() async { |
| allowedIdentifiers = {'Map'}; |
| await computeSuggestions(''' |
| class Map{}class F{m(){new ^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| Map |
| kind: constructorInvocation |
| Map.from |
| kind: constructorInvocation |
| Map.fromEntries |
| kind: constructorInvocation |
| Map.fromIterable |
| kind: constructorInvocation |
| Map.fromIterables |
| kind: constructorInvocation |
| Map.identity |
| kind: constructorInvocation |
| Map.unmodifiable |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets022b_1() async { |
| allowedIdentifiers = {'qq'}; |
| await computeSuggestions(''' |
| class Map{factory Map.qq(){return null;}}class F{m(){new Map.^qq();}} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| qq |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets023_1() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class X {X c; X(this.^c) : super() {c.}} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets023_2() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class X {X c; X(this.c) : super() {c.^}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets023_3() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class X {X c; X(this.c^) : super() {c.}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets024_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class q {m(Map q){var x;m(^)}n(){var x;n()}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| x |
| kind: localVariable |
| true |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| this |
| kind: keyword |
| const |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets024_2() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class q {m(Map q){var x;m()}n(){var x;n(^)}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_commentSnippets025_1() async { |
| allowedIdentifiers = {'q'}; |
| await computeSuggestions(''' |
| class C {num m() {var q; num x=^ q + /**/;}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| q |
| kind: localVariable |
| false |
| kind: keyword |
| true |
| kind: keyword |
| const |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets025_2() async { |
| allowedIdentifiers = {'q'}; |
| await computeSuggestions(''' |
| class C {num m() {var q; num x= q + ^/**/;}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| q |
| kind: localVariable |
| const |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| this |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets025_3() async { |
| allowedIdentifiers = {'q'}; |
| await computeSuggestions(''' |
| class C {num m() {var q; num x= q^ + /**/;}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| q |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_commentSnippets026_1() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class List{}class a implements ^{} |
| '''); |
| assertResponse(r''' |
| suggestions |
| List |
| kind: class |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets027_1() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class String{}class List{}class test <X extends ^String> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| List |
| kind: class |
| dynamic |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets027_2() async { |
| allowedIdentifiers = {'String', 'List'}; |
| await computeSuggestions(''' |
| class String{}class List{}class test <X extends String^> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 6 |
| suggestions |
| String |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets028_1() async { |
| allowedIdentifiers = {'DateTime', 'String'}; |
| await computeSuggestions(''' |
| class String{}class List{}class DateTime{}typedef T Y<T extends ^>(List input); |
| '''); |
| assertResponse(r''' |
| suggestions |
| DateTime |
| kind: class |
| String |
| kind: class |
| dynamic |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets029_2() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| interface A<X> default B<X extends List^> {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 4 |
| suggestions |
| List |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets030_1() async { |
| allowedIdentifiers = {'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {const Bar(^T k);T m(T a, T b){}final T f = null;} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| this |
| kind: keyword |
| void |
| kind: keyword |
| T |
| kind: typeParameter |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| final |
| kind: keyword |
| super |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets030_2() async { |
| allowedIdentifiers = {'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {const Bar(T^ k);T m(T a, T b){}final T f = null;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| this |
| kind: keyword |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets030_3() async { |
| allowedIdentifiers = {'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {const Bar(T k);T^ m(T a, T b){}final T f = null;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets030_4() async { |
| allowedIdentifiers = {'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {const Bar(T k);T m(T^ a, T b){}final T f = null;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets030_5() async { |
| allowedIdentifiers = {'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {const Bar(T k);T m(T a, T^ b){}final T f = null;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets030_6() async { |
| allowedIdentifiers = {'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {const Bar(T k);T m(T a, T b){}final T^ f = null;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets031_1() async { |
| allowedIdentifiers = {'Bar', 'T'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {m(x){if (x is ^) return;if (x is!)}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Bar |
| kind: class |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets031_2() async { |
| allowedIdentifiers = {'T', 'Bar'}; |
| await computeSuggestions(''' |
| class Bar<T extends Foo> {m(x){if (x is ) return;if (x is!^)}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| Bar |
| kind: class |
| T |
| kind: typeParameter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets032_1() async { |
| allowedIdentifiers = {'Fit', 'Fara', 'Bar'}; |
| await computeSuggestions(''' |
| class Fit{}class Bar<T extends Fooa> {const F^ara();} |
| '''); |
| assertResponse(''' |
| replacement |
| left: 1 |
| right: 3 |
| suggestions |
| Fit |
| kind: class |
| final |
| kind: keyword |
| factory |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets032_2() async { |
| allowedIdentifiers = {'Fit'}; |
| await computeSuggestions(''' |
| class Fit{}class Bar<T extends Fooa> {const ^Fara();} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 4 |
| suggestions |
| Fit |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets033_1() async { |
| allowedIdentifiers = {'add', 'length'}; |
| await computeSuggestions(''' |
| class List{add(){}length(){}}t1() {var x;if (x is List) {x.^add(3);}} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| add |
| kind: methodInvocation |
| length |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets035_1() async { |
| allowedIdentifiers = {'length'}; |
| await computeSuggestions(''' |
| class List{clear(){}length(){}}t3() {var x=[], y=x.^length();x.clear();} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| length |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets035_2() async { |
| allowedIdentifiers = {'clear'}; |
| await computeSuggestions(''' |
| class List{clear(){}length(){}}t3() {var x=[], y=x.length();x.^clear();} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| clear |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets036_1() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class List{}t3() {var x=new List^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 4 |
| suggestions |
| List |
| kind: constructorInvocation |
| List.empty |
| kind: constructorInvocation |
| List.generate |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets037_1() async { |
| allowedIdentifiers = {'from'}; |
| await computeSuggestions(''' |
| class List{factory List.from(){}}t3() {var x=new List.^} |
| '''); |
| assertResponse(r''' |
| suggestions |
| from |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets038_1() async { |
| allowedIdentifiers = {'xa'}; |
| await computeSuggestions(''' |
| f(){int xa; String s = '\$x^';} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| xa |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_commentSnippets038a_1() async { |
| allowedIdentifiers = {'xa'}; |
| await computeSuggestions(''' |
| int xa; String s = '\$x^' |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| xa |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_commentSnippets039_1() async { |
| allowedIdentifiers = {'xa'}; |
| await computeSuggestions(''' |
| f(){int xa; String s = '\$^';} |
| '''); |
| assertResponse(r''' |
| suggestions |
| xa |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_commentSnippets039a_1() async { |
| allowedIdentifiers = {'xa'}; |
| await computeSuggestions(''' |
| int xa; String s = '\$^' |
| '''); |
| assertResponse(r''' |
| suggestions |
| xa |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_commentSnippets040_1() async { |
| allowedIdentifiers = {'add'}; |
| await computeSuggestions(''' |
| class List{add(){}}class Map{}class X{m(){List list; list.^ Map map;}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| add |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets041_1() async { |
| allowedIdentifiers = {'add'}; |
| await computeSuggestions(''' |
| class List{add(){}length(){}}class X{m(){List list; list.^ zox();}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| add |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets042_1() async { |
| allowedIdentifiers = {'day'}; |
| await computeSuggestions(''' |
| class DateTime{static const int WED=3;int get day;}fd(){DateTime d=new DateTime.now();d.^WED;} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| day |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets042_2() async { |
| allowedIdentifiers = {'WED'}; |
| await computeSuggestions(''' |
| class DateTime{static const int WED=3;int get day;}fd(){DateTime d=new DateTime.now();d.WED^;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_commentSnippets043_1() async { |
| allowedIdentifiers = {'k'}; |
| await computeSuggestions(''' |
| class L{var k;void.^} |
| '''); |
| assertResponse(r''' |
| suggestions |
| abstract |
| kind: keyword |
| covariant |
| kind: keyword |
| external |
| kind: keyword |
| late |
| kind: keyword |
| static |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets044_1() async { |
| allowedIdentifiers = {'List', 'XXX', 'fisk'}; |
| await computeSuggestions(''' |
| class List{}class XXX {XXX.fisk();}void f() {f(); new ^}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| List |
| kind: constructorInvocation |
| List.empty |
| kind: constructorInvocation |
| List.filled |
| kind: constructorInvocation |
| List.from |
| kind: constructorInvocation |
| List.generate |
| kind: constructorInvocation |
| List.of |
| kind: constructorInvocation |
| List.unmodifiable |
| kind: constructorInvocation |
| XXX.fisk |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets045_1() async { |
| allowedIdentifiers = {'List', 'XXX', 'fisk'}; |
| await computeSuggestions(''' |
| class List{}class XXX {XXX.fisk();}void f() {f(); ^}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| List |
| kind: class |
| XXX |
| kind: class |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| List |
| kind: constructorInvocation |
| XXX.fisk |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets047_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| f(){int x;int y=^;} |
| '''); |
| assertResponse(r''' |
| suggestions |
| x |
| kind: localVariable |
| false |
| kind: keyword |
| true |
| kind: keyword |
| const |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets048_1() async { |
| allowedIdentifiers = {'json', 'JsonCodec', 'JsonDecoder'}; |
| await computeSuggestions(''' |
| import 'dart:convert' as json;f() {var x=new js^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| json |
| kind: library |
| json.JsonCodec |
| kind: constructorInvocation |
| json.JsonDecoder |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets049_1() async { |
| allowedIdentifiers = {'json', 'jxx', 'JsonCodec', 'JsonDecoder'}; |
| await computeSuggestions(''' |
| import 'dart:convert' as json; |
| import 'dart:convert' as jxx; |
| class JsonDecoderX{} |
| f1() {var x=new j^s} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| json |
| kind: library |
| json.JsonCodec |
| kind: constructorInvocation |
| json.JsonDecoder |
| kind: constructorInvocation |
| jxx |
| kind: library |
| jxx.JsonCodec |
| kind: constructorInvocation |
| jxx.JsonDecoder |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets049_2() async { |
| allowedIdentifiers = {'json', 'jxx', 'JsonDecoder'}; |
| await computeSuggestions(''' |
| import 'dart:convert' as json; |
| import 'dart:convert' as jxx; |
| class JsonDecoderX{} |
| f1() {var x=new ^js} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 2 |
| suggestions |
| json |
| kind: library |
| json.JsonCodec |
| kind: constructorInvocation |
| json.JsonDecoder |
| kind: constructorInvocation |
| jxx |
| kind: library |
| jxx.JsonCodec |
| kind: constructorInvocation |
| jxx.JsonDecoder |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets049_3() async { |
| allowedIdentifiers = {'json', 'jxx', 'JsonCodec', 'JsonDecoder'}; |
| await computeSuggestions(''' |
| import 'dart:convert' as json; |
| import 'dart:convert' as jxx; |
| class JsonDecoderX{} |
| f1() {var x=new js^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| json |
| kind: library |
| json.JsonCodec |
| kind: constructorInvocation |
| json.JsonDecoder |
| kind: constructorInvocation |
| jxx.JsonCodec |
| kind: constructorInvocation |
| jxx.JsonDecoder |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets050_1() async { |
| allowedIdentifiers = {'xdr', 'xa', 'a', 'b'}; |
| await computeSuggestions(''' |
| class xdr { |
| xdr(); |
| const xdr.a(a,b,c); |
| xdr.b(); |
| f() => 3; |
| } |
| class xa{} |
| k() { |
| new x^dr().f(); |
| const xdr.a(1, 2, 3); |
| } |
| '''); |
| // TODO(brianwilkerson): We ought to be suggesting 'xdr.a' and 'xdr.b'. |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 2 |
| suggestions |
| xa |
| kind: constructorInvocation |
| xdr |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets050_2() async { |
| allowedIdentifiers = {'xa', 'xdr', 'a', 'b'}; |
| await computeSuggestions(''' |
| class xdr { |
| xdr(); |
| const xdr.a(a,b,c); |
| xdr.b(); |
| f() => 3; |
| } |
| class xa{} |
| k() { |
| new xdr().f(); |
| const x^dr.a(1, 2, 3); |
| } |
| '''); |
| // TODO(brianwilkerson): We ought to be suggesting 'xdr.a' and 'xdr.b'. |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 2 |
| suggestions |
| xa |
| kind: constructorInvocation |
| xdr |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets050_3() async { |
| allowedIdentifiers = {'b', 'a'}; |
| await computeSuggestions(''' |
| class xdr { |
| xdr(); |
| const xdr.a(a,b,c); |
| xdr.b(); |
| f() => 3; |
| } |
| class xa{} |
| k() { |
| new xdr().f(); |
| const xdr.^a(1, 2, 3); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| a |
| kind: constructorInvocation |
| b |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets051_1() async { |
| allowedIdentifiers = {'length'}; |
| await computeSuggestions(''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| var v; |
| if (v is String) { |
| v.^length; |
| v.getKeys; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| length |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets051_2() async { |
| allowedIdentifiers = {'getKeys'}; |
| await computeSuggestions(''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| var v; |
| if (v is String) { |
| v.length; |
| v.^getKeys; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_commentSnippets052_1() async { |
| allowedIdentifiers = {'toUpperCase'}; |
| await computeSuggestions(''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| List<String> values = ['a','b','c']; |
| for (var v in values) { |
| v.^toUpperCase; |
| v.getKeys; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 11 |
| suggestions |
| toUpperCase |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets052_2() async { |
| allowedIdentifiers = {'getKeys'}; |
| await computeSuggestions(''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| List<String> values = ['a','b','c']; |
| for (var v in values) { |
| v.toUpperCase; |
| v.^getKeys; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 7 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_commentSnippets055_1() async { |
| allowedIdentifiers = {'toUpperCase'}; |
| await computeSuggestions(''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| String v; |
| if (v is Object) { |
| v.^toUpperCase; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 11 |
| suggestions |
| toUpperCase |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets058_1() async { |
| allowedIdentifiers = {'v'}; |
| await computeSuggestions(''' |
| typedef void callback(int k); |
| void x(callback q){} |
| void r() { |
| callback v; |
| x(^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| v |
| kind: localVariable |
| true |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| const |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_commentSnippets058_2() async { |
| await computeSuggestions(''' |
| typedef vo^id callback(int k); |
| void x(callback q){} |
| void r() { |
| callback v; |
| x(); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 2 |
| suggestions |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets060_1() async { |
| allowedIdentifiers = {'x'}; |
| await computeSuggestions(''' |
| class Map{} |
| abstract class MM extends Map{factory MM() => new Map();} |
| class Z { |
| MM x; |
| f() { |
| x^ |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| x |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets061_1() async { |
| allowedIdentifiers = {'f', 'n'}; |
| await computeSuggestions(''' |
| class A{m(){^f(3);}}n(){f(3);}f(x)=>x*3; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| f |
| kind: functionInvocation |
| n |
| kind: functionInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets061_2() async { |
| allowedIdentifiers = {'f', 'n'}; |
| await computeSuggestions(''' |
| class A{m(){f(3);^}}n(){f(3);}f(x)=>x*3; |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| f |
| kind: functionInvocation |
| n |
| kind: functionInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets061_3() async { |
| allowedIdentifiers = {'f', 'n'}; |
| await computeSuggestions(''' |
| class A{m(){f(3);}}n(){^f(3);}f(x)=>x*3; |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| f |
| kind: functionInvocation |
| n |
| kind: functionInvocation |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets061_4() async { |
| allowedIdentifiers = {'f', 'n'}; |
| await computeSuggestions(''' |
| class A{m(){f(3);}}n(){f(3);^}f(x)=>x*3; |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| f |
| kind: functionInvocation |
| n |
| kind: functionInvocation |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_1() async { |
| allowedIdentifiers = {'a', 'g'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..^a()..b().g(); |
| x.j..b()..c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| a |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_2() async { |
| allowedIdentifiers = {'b', 'h'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..^b().g(); |
| x.j..b()..c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| b |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_3() async { |
| allowedIdentifiers = {'b'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..b().g(); |
| x.j..^b()..c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| b |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_4() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..b().g(); |
| x.j..b()..^c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_5() async { |
| allowedIdentifiers = {'a'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..b().g(); |
| x.j..b()..c..c..^a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| a |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_6() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..b().g(); |
| x.j..b()..c..^c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_7() async { |
| allowedIdentifiers = {'g'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..b().^g(); |
| x.j..b()..c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| g |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_8() async { |
| allowedIdentifiers = {'j'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..b().g(); |
| x.^j..b()..c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| j |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets064_9() async { |
| allowedIdentifiers = {'h'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.^h()..a()..b().g(); |
| x.j..b()..c..c..a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| h |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets065_1() async { |
| allowedIdentifiers = {'a'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..^; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| a |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets066_1() async { |
| allowedIdentifiers = {'b'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..^; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| b |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets067_1() async { |
| allowedIdentifiers = {'b'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..c..^; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| b |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets068_1() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.j..b()..c..^; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets069_1() async { |
| allowedIdentifiers = {'c'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.j..b()..^; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| c |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_commentSnippets070_1() async { |
| allowedIdentifiers = {'b'}; |
| await computeSuggestions(''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.j..^; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| b |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets072_1() async { |
| allowedIdentifiers = {'p'}; |
| await computeSuggestions(''' |
| class X { |
| int _p; |
| set p(int x) => _p = x; |
| } |
| f() { |
| X x = new X(); |
| x.^p = 3; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| p |
| kind: setter |
| '''); |
| } |
| |
| Future<void> test_commentSnippets073_1() async { |
| allowedIdentifiers = {'stringify'}; |
| await computeSuggestions(''' |
| class X { |
| m() { |
| JSON.stri^; |
| X f = null; |
| } |
| } |
| class JSON { |
| static stringify() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 4 |
| suggestions |
| stringify |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets074_1() async { |
| allowedIdentifiers = {'_x1'}; |
| await computeSuggestions(''' |
| class X { |
| m() { |
| _x^ |
| } |
| _x1(){} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| _x1 |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets075_1() async { |
| allowedIdentifiers = {'p'}; |
| await computeSuggestions(''' |
| p(x)=>0;var E;f(q)=>^p(E); |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| p |
| kind: functionInvocation |
| null |
| kind: keyword |
| false |
| kind: keyword |
| const |
| kind: keyword |
| switch |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets075_2() async { |
| allowedIdentifiers = {'E'}; |
| await computeSuggestions(''' |
| p(x)=>0;var E;f(q)=>p(^E); |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| E |
| kind: topLevelVariable |
| const |
| kind: keyword |
| true |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets076_1() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class Map<K,V>{}class List<E>{}class int{}void f() {var m=new Map<Lis^t<Map<int,int>>,List<int>>();} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| right: 1 |
| suggestions |
| List |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets076_2() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class Map<K,V>{}class List<E>{}class int{}void f() {var m=new Map<List<Map<int,in^t>>,List<int>>();} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| int |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets076_3() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class Map<K,V>{}class List<E>{}class int{}void f() {var m=new Map<List<Map<int,int>>,List<^int>>();} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| int |
| kind: class |
| void |
| kind: keyword |
| dynamic |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets076a_1() async { |
| allowedIdentifiers = {'List'}; |
| await computeSuggestions(''' |
| class Map<K,V>{}class List<E>{}class int{}void f() {var m=new Map<Lis^t<Map<int,int>>,List<>>();} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| right: 1 |
| suggestions |
| List |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets076a_2() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class Map<K,V>{}class List<E>{}class int{}void f() {var m=new Map<List<Map<int,in^t>>,List<>>();} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| int |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets076a_3() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class Map<K,V>{}class List<E>{}class int{}void f() {var m=new Map<List<Map<int,int>>,List<^>>();} |
| '''); |
| assertResponse(r''' |
| suggestions |
| int |
| kind: class |
| void |
| kind: keyword |
| dynamic |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets077_1() async { |
| allowedIdentifiers = { |
| 'File', |
| 'fromPath', |
| 'FileMode', |
| '_internal1', |
| '_internal' |
| }; |
| await computeSuggestions(''' |
| class FileMode { |
| static const READ = const FileMode._internal(0); |
| static const WRITE = const FileMode._internal(1); |
| static const APPEND = const FileMode._internal(2); |
| const FileMode._internal(int this._mode); |
| factory FileMode._internal1(int this._mode); |
| factory FileMode(_mode); |
| final int _mode; |
| } |
| class File { |
| File(String path); |
| File.fromPath(Path path); |
| } |
| f() => new Fil^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| File |
| kind: constructorInvocation |
| FileMode |
| kind: constructorInvocation |
| FileMode._internal |
| kind: constructorInvocation |
| FileMode._internal1 |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets078_1() async { |
| allowedIdentifiers = {'from', 'clear'}; |
| await computeSuggestions(''' |
| class Map{static from()=>null;clear(){}}void f() { Map.^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| from |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets079_1() async { |
| allowedIdentifiers = {'clear', 'from'}; |
| await computeSuggestions(''' |
| class Map{static from()=>null;clear(){}}void f() { Map s; s.^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| clear |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets080_1() async { |
| allowedIdentifiers = {'message'}; |
| await computeSuggestions(''' |
| class RuntimeError{var message;}void f() { RuntimeError.^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_commentSnippets081_1() async { |
| allowedIdentifiers = {'Object'}; |
| await computeSuggestions(''' |
| class Foo {this.^} |
| '''); |
| assertResponse(r''' |
| suggestions |
| const |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| factory |
| kind: keyword |
| final |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| set |
| kind: keyword |
| static |
| kind: keyword |
| var |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_commentSnippets082_1() async { |
| allowedIdentifiers = {'HttpResponse'}; |
| await computeSuggestions(''' |
| class HttpRequest {} |
| class HttpResponse {} |
| void f() { |
| var v = (HttpRequest req, HttpResp^) |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 8 |
| suggestions |
| HttpResponse |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets083_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| void f() {(.^)} |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_commentSnippets083a_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| void f() { .^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_commentSnippets083b_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| void f() { null.^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| toString |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets085_1() async { |
| allowedIdentifiers = {'List', 'Map'}; |
| await computeSuggestions(''' |
| class List{}class Map{}class Z extends List with ^Map {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| List |
| kind: class |
| Map |
| kind: class |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets085_2() async { |
| allowedIdentifiers = {'Map', 'List'}; |
| await computeSuggestions(''' |
| class List{}class Map{}class Z extends List with Ma^p {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| Map |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_commentSnippets086_1() async { |
| allowedIdentifiers = {'xy'}; |
| await computeSuggestions(''' |
| class Q{f(){xy() {};x^y();}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| xy |
| kind: functionInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets086_2() async { |
| allowedIdentifiers = {'f', 'xy'}; |
| await computeSuggestions(''' |
| class Q{f(){xy() {^};xy();}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| xy |
| kind: functionInvocation |
| f |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets087_1() async { |
| allowedIdentifiers = {'Map', 'HashMap'}; |
| await computeSuggestions(''' |
| class Map{}class Q extends Object with ^Map {} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| Map |
| kind: class |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets088_1() async { |
| allowedIdentifiers = {'f', 'm'}; |
| await computeSuggestions(''' |
| class A { |
| int f; |
| B m(){} |
| } |
| class B extends A { |
| num f; |
| A m(){} |
| } |
| class Z { |
| B q; |
| f() {q.^} |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| f |
| kind: field |
| m |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_commentSnippets089_1() async { |
| allowedIdentifiers = {'fqe', 'fqi', 'Q', 'xya', 'xyb', 'xza'}; |
| await computeSuggestions(''' |
| class Q { |
| fqe() { |
| xya() { |
| xyb() { |
| ^ |
| } |
| xyb(); |
| }; |
| xza() { |
| |
| } |
| xya(); |
| xza(); |
| } |
| fqi() { |
| |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| Q |
| kind: class |
| xya |
| kind: functionInvocation |
| xyb |
| kind: functionInvocation |
| fqe |
| kind: methodInvocation |
| fqi |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| Q |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets089_2() async { |
| allowedIdentifiers = {'fqe', 'fqi', 'Q', 'xya', 'xyb', 'xza'}; |
| await computeSuggestions(''' |
| class Q { |
| fqe() { |
| xya() { |
| xyb() { |
| |
| } |
| xyb(); |
| }; |
| xza() { |
| ^ |
| } |
| xya(); |
| xza(); |
| } |
| fqi() { |
| |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| Q |
| kind: class |
| xya |
| kind: functionInvocation |
| xza |
| kind: functionInvocation |
| fqe |
| kind: methodInvocation |
| fqi |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| Q |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets089_3() async { |
| allowedIdentifiers = {'fqe', 'fqi', 'Q', 'xyb', 'xya', 'xza'}; |
| await computeSuggestions(''' |
| class Q { |
| fqe() { |
| xya() { |
| xyb() { |
| |
| } |
| ^ xyb(); |
| }; |
| xza() { |
| |
| } |
| xya(); |
| xza(); |
| } |
| fqi() { |
| |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| Q |
| kind: class |
| xya |
| kind: functionInvocation |
| xyb |
| kind: functionInvocation |
| fqe |
| kind: methodInvocation |
| fqi |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| Q |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets089_4() async { |
| allowedIdentifiers = {'fqe', 'fqi', 'Q', 'xya', 'xza', 'xyb'}; |
| await computeSuggestions(''' |
| class Q { |
| fqe() { |
| xya() { |
| xyb() { |
| |
| } |
| xyb(); |
| }; |
| xza() { |
| |
| } |
| xya(); |
| ^ xza(); |
| } |
| fqi() { |
| |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| Q |
| kind: class |
| xya |
| kind: functionInvocation |
| xza |
| kind: functionInvocation |
| fqe |
| kind: methodInvocation |
| fqi |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| Q |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets089_5() async { |
| allowedIdentifiers = {'fqe', 'fqi', 'Q', 'xya', 'xyb', 'xza'}; |
| await computeSuggestions(''' |
| class Q { |
| fqe() { |
| xya() { |
| xyb() { |
| |
| } |
| xyb(); |
| }; |
| xza() { |
| |
| } |
| xya(); |
| xza(); |
| } |
| fqi() { |
| ^ |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| Q |
| kind: class |
| fqe |
| kind: methodInvocation |
| fqi |
| kind: methodInvocation |
| var |
| kind: keyword |
| super |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| this |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| Q |
| kind: constructorInvocation |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_commentSnippets090_1() async { |
| allowedIdentifiers = {'length'}; |
| await computeSuggestions(''' |
| class X { f() { var a = 'x'; a.^ }} |
| '''); |
| assertResponse(r''' |
| suggestions |
| length |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_completion_alias_field_1() async { |
| allowedIdentifiers = {'fnint'}; |
| await computeSuggestions(''' |
| typedef int fnint(int k); fn^int x; |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 3 |
| suggestions |
| final |
| kind: keyword |
| fnint |
| kind: typeAlias |
| '''); |
| } |
| |
| @FailingTest(reason: 'The constructor for AAA is not being suggested') |
| Future<void> test_completion_annotation_argumentList_1() async { |
| allowedIdentifiers = {'AAA', 'aaa', 'bbb'}; |
| await computeSuggestions(''' |
| class AAA { |
| const AAA({int aaa, int bbb}); |
| } |
| |
| @AAA(^) |
| void f() { |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| AAA |
| kind: constructorInvocation |
| |aaa: | |
| kind: namedArgument |
| |bbb: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_completion_annotation_topLevelVar_1() async { |
| allowedIdentifiers = {'fooConst', 'fooNotConst', 'bar'}; |
| await computeSuggestions(''' |
| const fooConst = null; |
| final fooNotConst = null; |
| const bar = null; |
| |
| @foo^ |
| void f() { |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| fooConst |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_completion_annotation_type_1() async { |
| allowedIdentifiers = {'AAA', 'nnn'}; |
| await computeSuggestions(''' |
| class AAA { |
| const AAA({int a, int b}); |
| const AAA.nnn(int c, int d); |
| } |
| @AAA^ |
| void f() { |
| } |
| '''); |
| // TODO(brianwilkerson): We should be suggesting the named constructor here. |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| AAA |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_annotation_type_inClass_withoutMember_1() async { |
| allowedIdentifiers = {'AAA'}; |
| await computeSuggestions(''' |
| class AAA { |
| const AAA(); |
| } |
| |
| class C { |
| @A^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| AAA |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_argument_typeName_1() async { |
| allowedIdentifiers = {'Enum'}; |
| await computeSuggestions(''' |
| class Enum { |
| static Enum FOO = new Enum(); |
| } |
| f(Enum e) {} |
| void f() { |
| f(En^); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| Enum |
| kind: constructorInvocation |
| Enum |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_arguments_ignoreEmpty_1() async { |
| allowedIdentifiers = {'test'}; |
| await computeSuggestions(''' |
| class A { |
| test() {} |
| } |
| void f(A a) { |
| a.test(^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_as_asIdentifierPrefix_1() async { |
| allowedIdentifiers = {'asVisible'}; |
| await computeSuggestions(''' |
| void f(p) { |
| var asVisible; |
| var v = as^; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| asVisible |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_as_asPrefixedIdentifierStart_1() async { |
| allowedIdentifiers = {'asVisible'}; |
| await computeSuggestions(''' |
| class A { |
| var asVisible; |
| } |
| |
| void f(A p) { |
| var v = p.as^; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| asVisible |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_as_incompleteStatement_1() async { |
| allowedIdentifiers = {'MyClass', 'justSomeVar'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var justSomeVar; |
| var v = p as ^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| MyClass |
| kind: class |
| dynamic |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_cascade_1() async { |
| allowedIdentifiers = {'aaa', 'f'}; |
| await computeSuggestions(''' |
| class A { |
| aaa() {} |
| } |
| |
| |
| void f(A a) { |
| a..^ aaa(); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| aaa |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_combinator_afterComma_1() async { |
| allowedIdentifiers = {'pi', 'sin', 'Random', 'String'}; |
| await computeSuggestions(''' |
| import 'dart:math' show cos, ^; |
| '''); |
| assertResponse(r''' |
| suggestions |
| Random |
| kind: class |
| pi |
| kind: topLevelVariable |
| sin |
| kind: function |
| '''); |
| } |
| |
| Future<void> test_completion_combinator_ended_1() async { |
| allowedIdentifiers = {'pi', 'sin', 'Random', 'String'}; |
| await computeSuggestions(''' |
| import 'dart:math' show ^;" |
| '''); |
| assertResponse(r''' |
| suggestions |
| Random |
| kind: class |
| pi |
| kind: topLevelVariable |
| sin |
| kind: function |
| '''); |
| } |
| |
| Future<void> test_completion_combinator_export_1() async { |
| allowedIdentifiers = {'pi', 'sin', 'Random', 'String'}; |
| await computeSuggestions(''' |
| export 'dart:math' show ^;" |
| '''); |
| assertResponse(r''' |
| suggestions |
| Random |
| kind: class |
| pi |
| kind: topLevelVariable |
| sin |
| kind: function |
| '''); |
| } |
| |
| Future<void> test_completion_combinator_hide_1() async { |
| allowedIdentifiers = {'pi', 'sin', 'Random', 'String'}; |
| await computeSuggestions(''' |
| import 'dart:math' hide ^;" |
| '''); |
| assertResponse(r''' |
| suggestions |
| Random |
| kind: class |
| pi |
| kind: topLevelVariable |
| sin |
| kind: function |
| '''); |
| } |
| |
| Future<void> test_completion_combinator_notEnded_1() async { |
| allowedIdentifiers = {'pi', 'sin', 'Random', 'String'}; |
| await computeSuggestions(''' |
| import 'dart:math' show ^" |
| '''); |
| assertResponse(r''' |
| suggestions |
| Random |
| kind: class |
| pi |
| kind: topLevelVariable |
| sin |
| kind: function |
| '''); |
| } |
| |
| Future<void> test_completion_combinator_usePrefix_1() async { |
| allowedIdentifiers = {'sin', 'sqrt', 'cos', 'String'}; |
| await computeSuggestions(''' |
| import 'dart:math' show s^" |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| sin |
| kind: function |
| sqrt |
| kind: function |
| '''); |
| } |
| |
| Future<void> test_completion_constructor_field_1() async { |
| allowedIdentifiers = {'field'}; |
| await computeSuggestions(''' |
| class X { X(this.field); int f^ield;} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 4 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_constructorArguments_showOnlyCurrent_1() async { |
| allowedIdentifiers = {'A', 'first', 'second'}; |
| await computeSuggestions(''' |
| class A { |
| A.first(int p); |
| A.second(double p); |
| } |
| void f() { |
| new A.first(^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| A |
| kind: class |
| A.first |
| kind: constructorInvocation |
| A.second |
| kind: constructorInvocation |
| null |
| kind: keyword |
| false |
| kind: keyword |
| true |
| kind: keyword |
| const |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_constructorArguments_whenPrefixedType_1() async { |
| allowedIdentifiers = {'Random', 'm'}; |
| await computeSuggestions(''' |
| import 'dart:math' as m; |
| void f() { |
| new m.Random(^); |
| } |
| '''); |
| // TODO(brianwilkerson): The suggestions here are correct, except for the |
| // last line, which needs to be removed. |
| assertResponse(r''' |
| suggestions |
| m |
| kind: library |
| m.Point |
| kind: class |
| m.Point |
| kind: constructorInvocation |
| m.Random |
| kind: class |
| m.Random |
| kind: constructorInvocation |
| m.cos |
| kind: functionInvocation |
| m.max |
| kind: functionInvocation |
| m.min |
| kind: functionInvocation |
| m.sin |
| kind: functionInvocation |
| m.sqrt |
| kind: functionInvocation |
| m.tan |
| kind: functionInvocation |
| forced fail |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forClass_1() async { |
| allowedIdentifiers = {'int', 'method'}; |
| await computeSuggestions(''' |
| /** |
| * [int^] |
| * [method] |
| */ |
| class AAA { |
| methodA() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forClass_2() async { |
| allowedIdentifiers = {'methodA', 'int'}; |
| await computeSuggestions(''' |
| /** |
| * [int] |
| * [method^] |
| */ |
| class AAA { |
| methodA() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 6 |
| suggestions |
| methodA |
| kind: method |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forConstructor_1() async { |
| allowedIdentifiers = {'aaa', 'bbb'}; |
| await computeSuggestions(''' |
| class A { |
| /** |
| * [aa^] |
| * [int] |
| * [method] |
| */ |
| A.named(aaa, bbb) {} |
| methodA() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| aaa |
| kind: parameter |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forConstructor_2() async { |
| allowedIdentifiers = {'int', 'double'}; |
| await computeSuggestions(''' |
| class A { |
| /** |
| * [aa] |
| * [int^] |
| * [method] |
| */ |
| A.named(aaa, bbb) {} |
| methodA() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forConstructor_3() async { |
| allowedIdentifiers = {'methodA'}; |
| await computeSuggestions(''' |
| class A { |
| /** |
| * [aa] |
| * [int] |
| * [method^] |
| */ |
| A.named(aaa, bbb) {} |
| methodA() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 6 |
| suggestions |
| methodA |
| kind: method |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forFunction_1() async { |
| allowedIdentifiers = {'aaa', 'bbb'}; |
| await computeSuggestions(''' |
| /** |
| * [aa^] |
| * [int] |
| * [function] |
| */ |
| functionA(aaa, bbb) {} |
| functionB() {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| aaa |
| kind: parameter |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forFunction_2() async { |
| allowedIdentifiers = {'int', 'double'}; |
| await computeSuggestions(''' |
| /** |
| * [aa] |
| * [int^] |
| * [function] |
| */ |
| functionA(aaa, bbb) {} |
| functionB() {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forFunction_3() async { |
| allowedIdentifiers = {'functionA', 'functionB', 'int'}; |
| await computeSuggestions(''' |
| /** |
| * [aa] |
| * [int] |
| * [function^] |
| */ |
| functionA(aaa, bbb) {} |
| functionB() {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 8 |
| suggestions |
| functionA |
| kind: function |
| functionB |
| kind: function |
| '''); |
| } |
| |
| @failingTest |
| Future<void> |
| test_completion_dartDoc_reference_forFunctionTypeAlias_1() async { |
| allowedIdentifiers = {'aaa', 'bbb'}; |
| await computeSuggestions(''' |
| /** |
| * [aa^] |
| * [int] |
| * [Function] |
| */ |
| typedef FunctionA(aaa, bbb) {} |
| typedef FunctionB() {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| aaa |
| kind: parameter |
| bbb |
| kind: parameter |
| '''); |
| } |
| |
| Future<void> |
| test_completion_dartDoc_reference_forFunctionTypeAlias_2() async { |
| allowedIdentifiers = {'int', 'double'}; |
| await computeSuggestions(''' |
| /** |
| * [aa] |
| * [int^] |
| * [Function] |
| */ |
| typedef FunctionA(aaa, bbb) {} |
| typedef FunctionB() {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> |
| test_completion_dartDoc_reference_forFunctionTypeAlias_3() async { |
| allowedIdentifiers = {'FunctionA', 'FunctionB', 'int'}; |
| await computeSuggestions(''' |
| /** |
| * [aa] |
| * [int] |
| * [Function^] |
| */ |
| typedef FunctionA(aaa, bbb) {} |
| typedef FunctionB() {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 8 |
| suggestions |
| FunctionA |
| kind: typeAlias |
| FunctionB |
| kind: typeAlias |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forMethod_1() async { |
| allowedIdentifiers = {'aaa', 'bbb'}; |
| await computeSuggestions(''' |
| class A { |
| /** |
| * [aa^] |
| * [int] |
| * [method] |
| */ |
| methodA(aaa, bbb) {} |
| methodB() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| aaa |
| kind: parameter |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forMethod_2() async { |
| allowedIdentifiers = {'int', 'double'}; |
| await computeSuggestions(''' |
| class A { |
| /** |
| * [aa] |
| * [int^] |
| * [method] |
| */ |
| methodA(aaa, bbb) {} |
| methodB() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_forMethod_3() async { |
| allowedIdentifiers = {'methodA', 'methodB', 'int'}; |
| await computeSuggestions(''' |
| class A { |
| /** |
| * [aa] |
| * [int] |
| * [method^] |
| */ |
| methodA(aaa, bbb) {} |
| methodB() {} |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 6 |
| suggestions |
| methodA |
| kind: method |
| methodB |
| kind: method |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_incomplete_1() async { |
| allowedIdentifiers = {'double', 'int'}; |
| await computeSuggestions(''' |
| /** |
| * [doubl^ some text |
| * other text |
| */ |
| class A {} |
| /** |
| * [ some text |
| * other text |
| */ |
| class B {} |
| /** |
| * [] some text |
| */ |
| class C {} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 5 |
| suggestions |
| double |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_incomplete_2() async { |
| allowedIdentifiers = {'int', 'String'}; |
| await computeSuggestions(''' |
| /** |
| * [doubl some text |
| * other text |
| */ |
| class A {} |
| /** |
| * [^ some text |
| * other text |
| */ |
| class B {} |
| /** |
| * [] some text |
| */ |
| class C {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| String |
| kind: class |
| int |
| kind: class |
| String.fromCharCode |
| kind: constructor |
| String.fromCharCodes |
| kind: constructor |
| String.fromEnvironment |
| kind: constructor |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> test_completion_dartDoc_reference_incomplete_3() async { |
| allowedIdentifiers = {'int', 'String'}; |
| await computeSuggestions(''' |
| /** |
| * [doubl some text |
| * other text |
| */ |
| class A {} |
| /** |
| * [ some text |
| * other text |
| */ |
| class B {} |
| /** |
| * [^] some text |
| */ |
| class C {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| String |
| kind: class |
| int |
| kind: class |
| String.fromCharCode |
| kind: constructor |
| String.fromCharCodes |
| kind: constructor |
| String.fromEnvironment |
| kind: constructor |
| int.fromEnvironment |
| kind: constructor |
| '''); |
| } |
| |
| Future<void> test_completion_double_inFractionPart_1() async { |
| allowedIdentifiers = {'abs', 'f'}; |
| await computeSuggestions(''' |
| void f() { |
| 1.0^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_enum_1() async { |
| allowedIdentifiers = {'values', 'A', 'B', 'C'}; |
| await computeSuggestions(''' |
| enum MyEnum {A, B, C} |
| void f() { |
| MyEnum.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| values |
| kind: field |
| A |
| kind: enumConstant |
| B |
| kind: enumConstant |
| C |
| kind: enumConstant |
| '''); |
| } |
| |
| Future<void> test_completion_exactPrefix_hasHigherRelevance_1() async { |
| allowedIdentifiers = {'str', 'STR'}; |
| await computeSuggestions(''' |
| var STR; |
| void f(p) { |
| var str; |
| str^; |
| STR; |
| Str; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| str |
| kind: localVariable |
| STR |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_completion_exactPrefix_hasHigherRelevance_2() async { |
| allowedIdentifiers = {'STR', 'str'}; |
| await computeSuggestions(''' |
| var STR; |
| void f(p) { |
| var str; |
| str; |
| STR^; |
| Str; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| str |
| kind: localVariable |
| STR |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_completion_exactPrefix_hasHigherRelevance_3() async { |
| allowedIdentifiers = {'String', 'STR', 'str'}; |
| await computeSuggestions(''' |
| var STR; |
| void f(p) { |
| var str; |
| str; |
| STR; |
| Str^; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| str |
| kind: localVariable |
| String |
| kind: class |
| STR |
| kind: topLevelVariable |
| String.fromCharCode |
| kind: constructorInvocation |
| String.fromCharCodes |
| kind: constructorInvocation |
| String.fromEnvironment |
| kind: constructorInvocation |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_export_dart_1() async { |
| allowedIdentifiers = {'dart:core', 'dart:math', 'dart:_collection.dev'}; |
| await computeSuggestions(''' |
| import 'dart:math |
| import 'dart:_collection.dev |
| export 'dart:^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 5 |
| suggestions |
| |dart:core| |
| |dart:math| |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_export_noStringLiteral_noSemicolon_1() async { |
| allowedIdentifiers = {'dart:', 'package:'}; |
| await computeSuggestions(''' |
| import ^ |
| |
| class A {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| |dart:| |
| |package:| |
| '''); |
| } |
| |
| Future<void> test_completion_forStmt_vars_1() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class int{}class Foo { mth() { for (in^t i = 0; i < 5; i++); }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| int |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_forStmt_vars_2() async { |
| allowedIdentifiers = {'i'}; |
| await computeSuggestions(''' |
| class int{}class Foo { mth() { for (int i = 0; i^ < 5; i++); }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| i |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_forStmt_vars_3() async { |
| allowedIdentifiers = {'i'}; |
| await computeSuggestions(''' |
| class int{}class Foo { mth() { for (int i = 0; i < 5; i^++); }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| i |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_function_1() async { |
| allowedIdentifiers = {'String'}; |
| await computeSuggestions(''' |
| class Foo { int boo = 7; mth() { PNGS.sort((String a, Str^) => a.compareTo(b)); }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| String |
| kind: class |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_function_partial_1() async { |
| allowedIdentifiers = {'String'}; |
| await computeSuggestions(''' |
| class Foo { int boo = 7; mth() { PNGS.sort((String a, Str^)); }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| String |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_functionTypeParameter_namedArgument_1() async { |
| await computeSuggestions(''' |
| typedef FFF(a, b, {x1, x2, y}); |
| void f(FFF fff) { |
| fff(1, 2, ^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| |x1: | |
| kind: namedArgument |
| |x2: | |
| kind: namedArgument |
| |y: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_completion_functionTypeParameter_namedArgument_2() async { |
| await computeSuggestions(''' |
| typedef FFF(a, b, {x1, x2, y}); |
| void f(FFF fff) { |
| fff(1, 2, )^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_field1_1() async { |
| allowedIdentifiers = {'myField'}; |
| await computeSuggestions(''' |
| class Foo { int myField = 7; mth() { if (^) {}}} |
| '''); |
| assertResponse(r''' |
| suggestions |
| myField |
| kind: field |
| false |
| kind: keyword |
| true |
| kind: keyword |
| null |
| kind: keyword |
| this |
| kind: keyword |
| const |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_field1a_1() async { |
| allowedIdentifiers = {'myField'}; |
| await computeSuggestions(''' |
| class Foo { int myField = 7; mth() { if (^) }} |
| '''); |
| assertResponse(r''' |
| suggestions |
| myField |
| kind: field |
| false |
| kind: keyword |
| true |
| kind: keyword |
| null |
| kind: keyword |
| this |
| kind: keyword |
| const |
| kind: keyword |
| super |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_field2_1() async { |
| allowedIdentifiers = {'myField'}; |
| await computeSuggestions(''' |
| class Foo { int myField = 7; mth() { if (m^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| myField |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_field2a_1() async { |
| allowedIdentifiers = {'myField'}; |
| await computeSuggestions(''' |
| class Foo { int myField = 7; mth() { if (m^) }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| myField |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_field2b_1() async { |
| allowedIdentifiers = {'myField'}; |
| await computeSuggestions(''' |
| class Foo { myField = 7; mth() { if (m^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| myField |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_localVar_1() async { |
| allowedIdentifiers = {'value'}; |
| await computeSuggestions(''' |
| class Foo { mth() { int value = 7; if (v^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| value |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_localVara_1() async { |
| allowedIdentifiers = {'value'}; |
| await computeSuggestions(''' |
| class Foo { mth() { value = 7; if (v^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_topLevelVar_1() async { |
| allowedIdentifiers = {'topValue'}; |
| await computeSuggestions(''' |
| int topValue = 7; class Foo { mth() { if (t^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| true |
| kind: keyword |
| topValue |
| kind: topLevelVariable |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_topLevelVara_1() async { |
| allowedIdentifiers = {'topValue'}; |
| await computeSuggestions(''' |
| topValue = 7; class Foo { mth() { if (t^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| true |
| kind: keyword |
| topValue |
| kind: topLevelVariable |
| this |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_unionType_nonStrict_1() async { |
| allowedIdentifiers = {'a', 'x', 'y'}; |
| await computeSuggestions(''' |
| class A { a() => null; x() => null} |
| class B { a() => null; y() => null} |
| void f() { |
| var x; |
| var c; |
| if(c) { |
| x = new A(); |
| } else { |
| x = new B(); |
| } |
| x.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_ifStmt_unionType_strict_1() async { |
| allowedIdentifiers = {'a', 'x', 'y'}; |
| await computeSuggestions(''' |
| class A { a() => null; x() => null} |
| class B { a() => null; y() => null} |
| void f() { |
| var x; |
| var c; |
| if(c) { |
| x = new A(); |
| } else { |
| x = new B(); |
| } |
| x.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_import_1() async { |
| allowedIdentifiers = {'dart:', 'package:'}; |
| await computeSuggestions(''' |
| import '^'; |
| '''); |
| assertResponse(r''' |
| suggestions |
| dart: |
| kind: import |
| dart:async |
| kind: import |
| dart:async2 |
| kind: import |
| dart:collection |
| kind: import |
| dart:convert |
| kind: import |
| dart:ffi |
| kind: import |
| dart:html |
| kind: import |
| dart:io |
| kind: import |
| dart:isolate |
| kind: import |
| dart:math |
| kind: import |
| dart:typed_data |
| kind: import |
| package: |
| kind: import |
| package:test/ |
| kind: import |
| package:test/test.dart |
| kind: import |
| dart:core |
| kind: import |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_import_dart_1() async { |
| allowedIdentifiers = {'dart:'}; |
| await computeSuggestions(''' |
| import 'dart:math |
| import 'dart:_collection.dev |
| import 'dart:^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 5 |
| suggestions |
| dart:core |
| kind: import |
| dart:math |
| kind: import |
| dart:typed_data |
| kind: import |
| '''); |
| } |
| |
| Future<void> test_completion_import_hasStringLiteral_noSemicolon_1() async { |
| allowedIdentifiers = {'dart:', 'package:'}; |
| await computeSuggestions(''' |
| import '^' |
| |
| class A {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| dart: |
| kind: import |
| dart:async |
| kind: import |
| dart:async2 |
| kind: import |
| dart:collection |
| kind: import |
| dart:convert |
| kind: import |
| dart:ffi |
| kind: import |
| dart:html |
| kind: import |
| dart:io |
| kind: import |
| dart:isolate |
| kind: import |
| dart:math |
| kind: import |
| dart:typed_data |
| kind: import |
| package: |
| kind: import |
| package:test/ |
| kind: import |
| package:test/test.dart |
| kind: import |
| dart:core |
| kind: import |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_import_lib_1() async { |
| allowedIdentifiers = {'my_lib.dart'}; |
| newFile('$testPackageLibPath/my_lib.dart', ''' |
| |
| '''); |
| await computeSuggestions(''' |
| import '^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| dart: |
| kind: import |
| dart:async |
| kind: import |
| dart:async2 |
| kind: import |
| dart:collection |
| kind: import |
| dart:convert |
| kind: import |
| dart:core |
| kind: import |
| dart:ffi |
| kind: import |
| dart:html |
| kind: import |
| dart:io |
| kind: import |
| dart:isolate |
| kind: import |
| dart:math |
| kind: import |
| my_lib.dart |
| kind: import |
| package: |
| kind: import |
| package:test/ |
| kind: import |
| package:test/test.dart |
| kind: import |
| '''); |
| } |
| |
| Future<void> test_completion_import_noSpace_1() async { |
| allowedIdentifiers = {'dart:', 'package:'}; |
| await computeSuggestions(''' |
| import^ |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 6 |
| suggestions |
| '''); |
| } |
| |
| @FailingTest(reason: 'We only suggest URIs inside a string literal') |
| Future<void> test_completion_import_noStringLiteral_1() async { |
| allowedIdentifiers = {'dart:', 'package:'}; |
| await computeSuggestions(''' |
| import ^; |
| '''); |
| assertResponse(r''' |
| suggestions |
| dart: |
| kind: import |
| package: |
| kind: import |
| '''); |
| } |
| |
| @FailingTest(reason: 'We only suggest URIs inside a string literal') |
| Future<void> test_completion_import_noStringLiteral_noSemicolon_1() async { |
| allowedIdentifiers = {'dart:', 'package:'}; |
| await computeSuggestions(''' |
| import ^ |
| |
| class A {} |
| '''); |
| assertResponse(r''' |
| suggestions |
| dart: |
| kind: import |
| package: |
| kind: import |
| '''); |
| } |
| |
| Future<void> test_completion_incompleteClassMember_1() async { |
| allowedIdentifiers = {'String', 'bool'}; |
| await computeSuggestions(''' |
| class A { |
| Str^ |
| final f = null; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| @override |
| String toString() { |
| // TODO: implement toString |
| return super.toString(); |
| } |
| kind: override |
| selection: 68 24 |
| String |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_incompleteClosure_parameterType_1() async { |
| allowedIdentifiers = {'String', 'bool'}; |
| await computeSuggestions(''' |
| f1(cb(String s)) {} |
| f2(String s) {} |
| void f() { |
| f1((Str^)); |
| f2((Str)); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| String |
| kind: class |
| String.fromCharCode |
| kind: constructorInvocation |
| String.fromCharCodes |
| kind: constructorInvocation |
| String.fromEnvironment |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_incompleteClosure_parameterType_2() async { |
| allowedIdentifiers = {'String', 'bool'}; |
| await computeSuggestions(''' |
| f1(cb(String s)) {} |
| f2(String s) {} |
| void f() { |
| f1((Str)); |
| f2((Str^)); |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| suggestions |
| String |
| kind: class |
| String.fromCharCode |
| kind: constructorInvocation |
| String.fromCharCodes |
| kind: constructorInvocation |
| String.fromEnvironment |
| kind: constructorInvocation |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_inPeriodPeriod_1() async { |
| allowedIdentifiers = {'codeUnits'}; |
| await computeSuggestions(''' |
| void f(String str) { |
| 1 < str.^.length; |
| 1 + str..length; |
| 1 + 2 * str..length; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| codeUnits |
| kind: methodInvocation |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_inPeriodPeriod_2() async { |
| allowedIdentifiers = {'codeUnits'}; |
| await computeSuggestions(''' |
| void f(String str) { |
| 1 < str..length; |
| 1 + str.^.length; |
| 1 + 2 * str..length; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| codeUnits |
| kind: methodInvocation |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_inPeriodPeriod_3() async { |
| allowedIdentifiers = {'codeUnits'}; |
| await computeSuggestions(''' |
| void f(String str) { |
| 1 < str..length; |
| 1 + str..length; |
| 1 + 2 * str.^.length; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| codeUnits |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_instanceCreation_unresolved_1() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class A { |
| } |
| void f() { |
| new NoSuchClass(^); |
| new A.noSuchConstructor(); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructorInvocation |
| const |
| kind: keyword |
| null |
| kind: keyword |
| false |
| kind: keyword |
| switch |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_instanceCreation_unresolved_2() async { |
| allowedIdentifiers = {'int'}; |
| await computeSuggestions(''' |
| class A { |
| } |
| void f() { |
| new NoSuchClass(); |
| new A.noSuchConstructor(^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| int |
| kind: class |
| int.fromEnvironment |
| kind: constructorInvocation |
| const |
| kind: keyword |
| null |
| kind: keyword |
| false |
| kind: keyword |
| switch |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_is_1() async { |
| allowedIdentifiers = {'MyClass'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var isVariable; |
| if (p is MyCla^) {} |
| var v1 = p is MyCla; |
| var v2 = p is ; |
| var v2 = p is; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 5 |
| suggestions |
| MyClass |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_is_2() async { |
| allowedIdentifiers = {'MyClass'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var isVariable; |
| if (p is MyCla) {} |
| var v1 = p is MyCla^; |
| var v2 = p is ; |
| var v2 = p is; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 5 |
| suggestions |
| MyClass |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_is_3() async { |
| allowedIdentifiers = {'MyClass', 'v1'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var isVariable; |
| if (p is MyCla) {} |
| var v1 = p is MyCla; |
| var v2 = p is ^; |
| var v2 = p is; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| MyClass |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_is_4() async { |
| allowedIdentifiers = {'is', 'isVariable'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var isVariable; |
| if (p is MyCla) {} |
| var v1 = p is MyCla; |
| var v2 = p is ; |
| var v2 = p is^; |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| is |
| kind: keyword |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_is_asIdentifierStart_1() async { |
| allowedIdentifiers = {'isVisible'}; |
| await computeSuggestions(''' |
| void f(p) { |
| var isVisible; |
| var v1 = is^; |
| var v2 = is |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| is |
| kind: keyword |
| isVisible |
| kind: localVariable |
| '''); |
| } |
| |
| @failingTest |
| Future<void> test_completion_is_asIdentifierStart_2() async { |
| allowedIdentifiers = {'isVisible'}; |
| await computeSuggestions(''' |
| void f(p) { |
| var isVisible; |
| var v1 = is; |
| var v2 = is^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| is |
| kind: keyword |
| isVisible |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_is_asPrefixedIdentifierStart_1() async { |
| allowedIdentifiers = {'isVisible'}; |
| await computeSuggestions(''' |
| class A { |
| var isVisible; |
| } |
| |
| void f(A p) { |
| var v1 = p.is^; |
| var v2 = p.is |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| isVisible |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_is_asPrefixedIdentifierStart_2() async { |
| allowedIdentifiers = {'isVisible'}; |
| await computeSuggestions(''' |
| class A { |
| var isVisible; |
| } |
| |
| void f(A p) { |
| var v1 = p.is; |
| var v2 = p.is^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| isVisible |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_is_incompleteStatement1_1() async { |
| allowedIdentifiers = {'MyClass', 'justSomeVar'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var justSomeVar; |
| var v = p is ^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| MyClass |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_is_incompleteStatement2_1() async { |
| allowedIdentifiers = {'is', 'isVariable'}; |
| await computeSuggestions(''' |
| class MyClass {} |
| void f(p) { |
| var isVariable; |
| var v = p is^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| is |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_keyword_in_1() async { |
| allowedIdentifiers = {'input'}; |
| await computeSuggestions(''' |
| class Foo { int input = 7; mth() { if (in^) {}}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| input |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_keyword_syntheticIdentifier_1() async { |
| allowedIdentifiers = {'caseVar', 'otherVar'}; |
| await computeSuggestions(''' |
| void f() { |
| var caseVar; |
| var otherVar; |
| var v = case^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 4 |
| suggestions |
| caseVar |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_libraryIdentifier_atEOF_1() async { |
| allowedIdentifiers = {'parse', 'bool'}; |
| await computeSuggestions(''' |
| library int.^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_libraryIdentifier_notEOF_1() async { |
| allowedIdentifiers = {'parse', 'bool'}; |
| // TODO(brianwilkerson): This is the same as |
| // test_completion_libraryIdentifier_atEOF_1, probably this one needs |
| // something following the directive. |
| await computeSuggestions(''' |
| library int.^ |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> |
| test_completion_methodRef_asArg_incompatibleFunctionType_1() async { |
| allowedIdentifiers = {'myFuncInt', 'myFuncDouble'}; |
| await computeSuggestions(''' |
| foo( f(int p) ) {} |
| class Functions { |
| static myFuncInt(int p) {} |
| static myFuncDouble(double p) {} |
| } |
| bar(p) {} |
| void f(p) { |
| foo( Functions.^; ); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| myFuncDouble |
| kind: method |
| myFuncInt |
| kind: method |
| '''); |
| } |
| |
| Future<void> test_completion_methodRef_asArg_notFunctionType_1() async { |
| allowedIdentifiers = {'myFunc'}; |
| await computeSuggestions(''' |
| foo( f(int p) ) {} |
| class Functions { |
| static myFunc(int p) {} |
| } |
| bar(p) {} |
| void f(p) { |
| foo( (int p) => Functions.^; ); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| myFunc |
| kind: method |
| '''); |
| } |
| |
| Future<void> test_completion_methodRef_asArg_ofFunctionType_1() async { |
| allowedIdentifiers = {'myFunc'}; |
| await computeSuggestions(''' |
| foo( f(int p) ) {} |
| class Functions { |
| static int myFunc(int p) {} |
| } |
| void f(p) { |
| foo(Functions.^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| myFunc |
| kind: method |
| '''); |
| } |
| |
| Future<void> test_completion_namedArgument_alreadyUsed_1() async { |
| allowedIdentifiers = {'foo'}; |
| await computeSuggestions(''' |
| func({foo}) {} void f() { func(foo: 0, fo^); } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_namedArgument_constructor_1() async { |
| allowedIdentifiers = {'foo', 'bar'}; |
| await computeSuggestions(''' |
| class A {A({foo, bar}) {}} void f() { new A(fo^); } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| |foo: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_completion_namedArgument_empty_1() async { |
| allowedIdentifiers = {'foo'}; |
| await computeSuggestions(''' |
| func({foo, bar}) {} void f() { func(^); } |
| '''); |
| assertResponse(r''' |
| suggestions |
| |bar: | |
| kind: namedArgument |
| |foo: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_completion_namedArgument_function_1() async { |
| allowedIdentifiers = {'foo', 'bar'}; |
| await computeSuggestions(''' |
| func({foo, bar}) {} void f() { func(fo^); } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| |foo: | |
| kind: namedArgument |
| '''); |
| } |
| |
| Future<void> test_completion_namedArgument_notNamed_1() async { |
| allowedIdentifiers = {'foo'}; |
| await computeSuggestions(''' |
| func([foo]) {} void f() { func(fo^); } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_namedArgument_unresolvedFunction_1() async { |
| allowedIdentifiers = {'foo'}; |
| await computeSuggestions(''' |
| void f() { func(fo^); } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_newMemberType1_1() async { |
| allowedIdentifiers = {'Collection', 'List'}; |
| await computeSuggestions(''' |
| class Collection{}class List extends Collection{}class Foo { ^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| @override |
| // TODO: implement hashCode |
| int get hashCode => super.hashCode; |
| kind: override |
| selection: 62 14 |
| @override |
| // TODO: implement runtimeType |
| Type get runtimeType => super.runtimeType; |
| kind: override |
| selection: 69 17 |
| @override |
| String toString() { |
| // TODO: implement toString |
| return super.toString(); |
| } |
| kind: override |
| selection: 68 24 |
| @override |
| bool operator ==(Object other) { |
| // TODO: implement == |
| return super == other; |
| } |
| kind: override |
| selection: 75 22 |
| @override |
| noSuchMethod(Invocation invocation) { |
| // TODO: implement noSuchMethod |
| return super.noSuchMethod(invocation); |
| } |
| kind: override |
| selection: 90 38 |
| Collection |
| kind: class |
| List |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_newMemberType2_1() async { |
| allowedIdentifiers = {'Collection', 'List'}; |
| await computeSuggestions(''' |
| class Collection{}class List extends Collection{}class Foo {^} |
| '''); |
| assertResponse(r''' |
| suggestions |
| @override |
| // TODO: implement hashCode |
| int get hashCode => super.hashCode; |
| kind: override |
| selection: 62 14 |
| @override |
| // TODO: implement runtimeType |
| Type get runtimeType => super.runtimeType; |
| kind: override |
| selection: 69 17 |
| @override |
| String toString() { |
| // TODO: implement toString |
| return super.toString(); |
| } |
| kind: override |
| selection: 68 24 |
| @override |
| bool operator ==(Object other) { |
| // TODO: implement == |
| return super == other; |
| } |
| kind: override |
| selection: 75 22 |
| @override |
| noSuchMethod(Invocation invocation) { |
| // TODO: implement noSuchMethod |
| return super.noSuchMethod(invocation); |
| } |
| kind: override |
| selection: 90 38 |
| Collection |
| kind: class |
| List |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_newMemberType3_1() async { |
| allowedIdentifiers = {'List', 'Collection'}; |
| await computeSuggestions(''' |
| class Collection{}class List extends Collection{}class Foo {L^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| List |
| kind: class |
| late |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_newMemberType4_1() async { |
| allowedIdentifiers = {'Collection', 'List'}; |
| await computeSuggestions(''' |
| class Collection{}class List extends Collection{}class Foo {C^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| Collection |
| kind: class |
| const |
| kind: keyword |
| covariant |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_positionalArgument_constructor_1() async { |
| allowedIdentifiers = {'foo', 'bar'}; |
| await computeSuggestions(''' |
| class A { |
| A([foo, bar]); |
| } |
| void f() { |
| new A(^); |
| new A(0, ); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| const |
| kind: keyword |
| null |
| kind: keyword |
| false |
| kind: keyword |
| switch |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_positionalArgument_constructor_2() async { |
| allowedIdentifiers = {'bar', 'foo'}; |
| await computeSuggestions(''' |
| class A { |
| A([foo, bar]); |
| } |
| void f() { |
| new A(); |
| new A(0, ^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| const |
| kind: keyword |
| null |
| kind: keyword |
| false |
| kind: keyword |
| switch |
| kind: keyword |
| true |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_positionalArgument_function_1() async { |
| allowedIdentifiers = {'foo', 'bar'}; |
| await computeSuggestions(''' |
| func([foo, bar]) {} |
| void f() { |
| func(^); |
| func(0, ); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| const |
| kind: keyword |
| true |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_positionalArgument_function_2() async { |
| allowedIdentifiers = {'bar', 'foo'}; |
| await computeSuggestions(''' |
| func([foo, bar]) {} |
| void f() { |
| func(); |
| func(0, ^); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| const |
| kind: keyword |
| true |
| kind: keyword |
| false |
| kind: keyword |
| null |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_preferStaticType_1() async { |
| allowedIdentifiers = {'foo', 'bar'}; |
| await computeSuggestions(''' |
| class A { |
| foo() {} |
| } |
| class B extends A { |
| bar() {} |
| } |
| void f() { |
| A v = new B(); |
| v.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| foo |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> |
| test_completion_privateElement_sameLibrary_constructor_1() async { |
| allowedIdentifiers = {'_c', 'c'}; |
| await computeSuggestions(''' |
| class A { |
| A._c(); |
| A.c(); |
| } |
| void f() { |
| new A.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| _c |
| kind: constructorInvocation |
| c |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_privateElement_sameLibrary_member_1() async { |
| allowedIdentifiers = {'_m', 'm'}; |
| await computeSuggestions(''' |
| class A { |
| _m() {} |
| m() {} |
| } |
| void f(A a) { |
| a.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| _m |
| kind: methodInvocation |
| m |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_propertyAccess_whenClassTarget_1() async { |
| allowedIdentifiers = {'FIELD', 'field'}; |
| await computeSuggestions(''' |
| class A { |
| static int FIELD; |
| int field; |
| } |
| void f() { |
| A.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| FIELD |
| kind: field |
| '''); |
| } |
| |
| Future<void> |
| test_completion_propertyAccess_whenClassTarget_excludeSuper_1() async { |
| allowedIdentifiers = {'FIELD_B', 'methodB', 'FIELD_A', 'methodA'}; |
| await computeSuggestions(''' |
| class A { |
| static int FIELD_A; |
| static int methodA() {} |
| } |
| class B extends A { |
| static int FIELD_B; |
| static int methodB() {} |
| } |
| void f() { |
| B.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| FIELD_B |
| kind: field |
| methodB |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_propertyAccess_whenInstanceTarget_1() async { |
| allowedIdentifiers = {'fieldA', 'FIELD'}; |
| await computeSuggestions(''' |
| class A { |
| static int FIELD; |
| int fieldA; |
| } |
| class B { |
| A a; |
| } |
| class C extends A { |
| int fieldC; |
| } |
| void f(B b, C c) { |
| b.a.^; |
| c.; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| fieldA |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_propertyAccess_whenInstanceTarget_2() async { |
| allowedIdentifiers = {'fieldC', 'fieldA'}; |
| await computeSuggestions(''' |
| class A { |
| static int FIELD; |
| int fieldA; |
| } |
| class B { |
| A a; |
| } |
| class C extends A { |
| int fieldC; |
| } |
| void f(B b, C c) { |
| b.a.; |
| c.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| fieldC |
| kind: field |
| fieldA |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_return_withIdentifierPrefix_1() async { |
| allowedIdentifiers = {'vvv'}; |
| await computeSuggestions(''' |
| f() { var vvv = 42; return v^ } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| vvv |
| kind: localVariable |
| '''); |
| } |
| |
| Future<void> test_completion_return_withoutExpression_1() async { |
| allowedIdentifiers = {'vvv'}; |
| await computeSuggestions(''' |
| f() { var vvv = 42; return ^ } |
| '''); |
| assertResponse(r''' |
| suggestions |
| vvv |
| kind: localVariable |
| true |
| kind: keyword |
| null |
| kind: keyword |
| false |
| kind: keyword |
| const |
| kind: keyword |
| switch |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_completion_staticField1_1() async { |
| allowedIdentifiers = {'MAX_D'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static final num MAX_D = 300;num xc, yc;Sunflower() {xc = yc = MA^ }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| suggestions |
| MAX_D |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_staticField1_2() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static final n^um MAX_D = 300;num xc, yc;Sunflower() {xc = yc = MA }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 2 |
| suggestions |
| num |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_staticField1_3() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static final num MAX_D = 300;nu^m xc, yc;Sunflower() {xc = yc = MA }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 2 |
| right: 1 |
| suggestions |
| num |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_staticField1_4() async { |
| allowedIdentifiers = {'Sunflower'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static final num MAX_D = 300;num xc, yc;Sun^flower() {xc = yc = MA }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| right: 6 |
| suggestions |
| Sunflower |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_staticField1_X() async { |
| allowedIdentifiers = {'xc'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static final num MAX_D = 300;num xc, yc;Sunflower() {x^c = yc = MA }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| xc |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_staticField1_Y() async { |
| allowedIdentifiers = {'yc'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static final num MAX_D = 300;num xc, yc;Sunflower() {xc = y^c = MA }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| right: 1 |
| suggestions |
| yc |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_completion_staticField_withoutVarOrFinal_1() async { |
| allowedIdentifiers = {'num'}; |
| await computeSuggestions(''' |
| class num{}class Sunflower {static n^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| num |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_super_superType_1() async { |
| allowedIdentifiers = {'fa', 'ma', 'fb', 'mb'}; |
| await computeSuggestions(''' |
| class A { |
| var fa; |
| ma() {} |
| } |
| class B extends A { |
| var fb; |
| mb() {} |
| void f() { |
| super.^ |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| fa |
| kind: field |
| ma |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> |
| test_completion_superConstructorInvocation_noNamePrefix_1() async { |
| allowedIdentifiers = {'fooA', 'fooB', 'bar'}; |
| await computeSuggestions(''' |
| class A { |
| A.fooA(); |
| A.fooB(); |
| A.bar(); |
| } |
| class B extends A { |
| B() : super.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| bar |
| kind: constructorInvocation |
| fooA |
| kind: constructorInvocation |
| fooB |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> |
| test_completion_superConstructorInvocation_withNamePrefix_1() async { |
| allowedIdentifiers = {'fooA', 'fooB', 'bar'}; |
| await computeSuggestions(''' |
| class A { |
| A.fooA(); |
| A.fooB(); |
| A.bar(); |
| } |
| class B extends A { |
| B() : super.f^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| fooA |
| kind: constructorInvocation |
| fooB |
| kind: constructorInvocation |
| '''); |
| } |
| |
| @FailingTest(reason: 'instance members should not be suggested') |
| Future<void> test_completion_this_bad_inConstructorInitializer_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| class A { |
| var f; |
| A() : f = this.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| @FailingTest(reason: 'instance members should not be suggested') |
| Future<void> test_completion_this_bad_inFieldDeclaration_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| class A { |
| var f = this.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| @FailingTest(reason: 'instance members should not be suggested') |
| Future<void> test_completion_this_bad_inStaticMethod_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| class A { |
| static m() { |
| this.^; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| @FailingTest(reason: 'instance members should not be suggested') |
| Future<void> test_completion_this_bad_inTopLevelFunction_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| void f() { |
| this.^; |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| @FailingTest(reason: 'instance members should not be suggested') |
| Future<void> |
| test_completion_this_bad_inTopLevelVariableDeclaration_1() async { |
| allowedIdentifiers = {'toString'}; |
| await computeSuggestions(''' |
| var v = this.^; |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_completion_this_OK_inConstructorBody_1() async { |
| allowedIdentifiers = {'f', 'm'}; |
| await computeSuggestions(''' |
| class A { |
| var f; |
| m() {} |
| A() { |
| this.^; |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| f |
| kind: field |
| m |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_this_OK_localAndSuper_1() async { |
| allowedIdentifiers = {'fa', 'fb', 'ma', 'mb'}; |
| await computeSuggestions(''' |
| class A { |
| var fa; |
| ma() {} |
| } |
| class B extends A { |
| var fb; |
| mb() {} |
| void m() { |
| this.^ |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| fb |
| kind: field |
| fa |
| kind: field |
| ma |
| kind: methodInvocation |
| mb |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_completion_topLevelField_init2_1() async { |
| allowedIdentifiers = {'DateTime', 'void'}; |
| await computeSuggestions(''' |
| class DateTime{static var JUN;}final num M = Dat^eTime.JUN; |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 3 |
| right: 5 |
| suggestions |
| DateTime |
| kind: constructorInvocation |
| DateTime |
| kind: class |
| '''); |
| } |
| |
| Future<void> test_completion_while_1() async { |
| allowedIdentifiers = {'boo'}; |
| await computeSuggestions(''' |
| class Foo { int boo = 7; mth() { while (b^) {} }} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| boo |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_export_ignoreIfThisLibraryExports_1() async { |
| allowedIdentifiers = {'libFunction', 'cos'}; |
| await computeSuggestions(''' |
| export 'dart:math'; |
| libFunction() {}; |
| void f() { |
| ^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| libFunction |
| kind: functionInvocation |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| cos |
| kind: functionInvocation |
| cos |
| kind: functionInvocation |
| '''); |
| } |
| |
| Future<void> test_export_showIfImportLibraryWithExport_1() async { |
| allowedIdentifiers = {'cos', 'libFunction', 'sin'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| export 'dart:math' hide sin; |
| libFunction() {} |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart' as p; |
| void f() { |
| p.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| cos |
| kind: functionInvocation |
| libFunction |
| kind: functionInvocation |
| '''); |
| } |
| |
| Future<void> test_importPrefix_hideCombinator_1() async { |
| allowedIdentifiers = {'ln10', 'pi'}; |
| await computeSuggestions(''' |
| import 'dart:math' as math hide pi; |
| void f() { |
| math.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| ln10 |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_importPrefix_showCombinator_1() async { |
| allowedIdentifiers = {'pi', 'ln10'}; |
| await computeSuggestions(''' |
| import 'dart:math' as math show pi; |
| void f() { |
| math.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| pi |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_library001_1() async { |
| allowedIdentifiers = {'SerializationException'}; |
| newFile('$testPackageLibPath/firth.dart', ''' |
| library firth; |
| class SerializationException { |
| const SerializationException(); |
| } |
| '''); |
| await computeSuggestions(''' |
| import 'firth.dart'; |
| void f() { |
| throw new Seria^lizationException();} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 5 |
| right: 17 |
| suggestions |
| SerializationException |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_library002_1() async { |
| allowedIdentifiers = {'length', 'isEmpty'}; |
| await computeSuggestions(''' |
| t2() {var q=[0],z=q.^length;q.clear();} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 6 |
| suggestions |
| isEmpty |
| kind: getter |
| length |
| kind: getter |
| '''); |
| } |
| |
| Future<void> test_library002_2() async { |
| allowedIdentifiers = {'clear'}; |
| await computeSuggestions(''' |
| t2() {var q=[0],z=q.length;q.^clear();} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 5 |
| suggestions |
| clear |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_library003_1() async { |
| allowedIdentifiers = {'end'}; |
| await computeSuggestions(''' |
| class X{var q; f() {q.^a}} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_library003_2() async { |
| allowedIdentifiers = {'abs', 'end'}; |
| await computeSuggestions(''' |
| class X{var q; f() {q.a^}} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_library004_1() async { |
| allowedIdentifiers = {'JsonDecoder', 'JsonDecoderX'}; |
| await computeSuggestions(''' |
| library foo; |
| import 'dart:convert' as json; |
| class JsonDecoderX{} |
| f1() {var x=new json.^} |
| f2() {var x=new json.JsonDe} |
| f3() {var x=new json.JsonDecoder} |
| '''); |
| assertResponse(r''' |
| suggestions |
| JsonDecoder |
| kind: constructorInvocation |
| dynamic |
| kind: keyword |
| void |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_library004_2() async { |
| allowedIdentifiers = {'JsonDecoder', 'JsonDecoderX'}; |
| await computeSuggestions(''' |
| library foo; |
| import 'dart:convert' as json; |
| class JsonDecoderX{} |
| f1() {var x=new json.} |
| f2() {var x=new json.JsonDe^} |
| f3() {var x=new json.JsonDecoder} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 6 |
| suggestions |
| JsonDecoder |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_library004_3() async { |
| allowedIdentifiers = {'JsonDecoder', 'JsonDecoderX'}; |
| await computeSuggestions(''' |
| library foo; |
| import 'dart:convert' as json; |
| class JsonDecoderX{} |
| f1() {var x=new json.} |
| f2() {var x=new json.JsonDe} |
| f3() {var x=new json.JsonDecoder^} |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 11 |
| suggestions |
| JsonDecoder |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_library005_1() async { |
| allowedIdentifiers = {'abs'}; |
| await computeSuggestions(''' |
| var PHI = 0;void f(){PHI=5.3;PHI.abs().^ Object x;} |
| '''); |
| assertResponse(r''' |
| suggestions |
| abs |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_library006_1() async { |
| allowedIdentifiers = {'i1', 'i2', 'e1a', 'e2a', 'e1b'}; |
| newFile('$testPackageLibPath/imp1.dart', ''' |
| library imp1; |
| export 'exp1a.dart'; |
| i1() {} |
| '''); |
| newFile('$testPackageLibPath/imp2.dart', ''' |
| library imp2; |
| export 'exp2a.dart'; |
| i2() {} |
| '''); |
| newFile('$testPackageLibPath/exp1a.dart', ''' |
| library exp1a; |
| export 'exp1b.dart'; |
| e1a() {} |
| '''); |
| newFile('$testPackageLibPath/exp1b.dart', ''' |
| library exp1b; |
| e1b() {} |
| '''); |
| newFile('$testPackageLibPath/exp2a.dart', ''' |
| library exp2a; |
| e2a() {} |
| '''); |
| await computeSuggestions(''' |
| import 'imp1.dart'; |
| import 'imp2.dart'; |
| void f() {^ |
| i1(); |
| i2(); |
| e1a(); |
| e1b(); |
| e2a(); |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| return |
| kind: keyword |
| if |
| kind: keyword |
| final |
| kind: keyword |
| e1a |
| kind: functionInvocation |
| e1b |
| kind: functionInvocation |
| e2a |
| kind: functionInvocation |
| i1 |
| kind: functionInvocation |
| i2 |
| kind: functionInvocation |
| var |
| kind: keyword |
| throw |
| kind: keyword |
| for |
| kind: keyword |
| switch |
| kind: keyword |
| try |
| kind: keyword |
| assert |
| kind: keyword |
| const |
| kind: keyword |
| do |
| kind: keyword |
| dynamic |
| kind: keyword |
| false |
| kind: keyword |
| late |
| kind: keyword |
| null |
| kind: keyword |
| true |
| kind: keyword |
| void |
| kind: keyword |
| while |
| kind: keyword |
| '''); |
| } |
| |
| Future<void> test_library007_1() async { |
| allowedIdentifiers = {'l1t', '_l1t'}; |
| newFile('$testPackageLibPath/l1.dart', ''' |
| library l1; |
| var _l1t; var l1t = _l1t; |
| '''); |
| await computeSuggestions(''' |
| import 'l1.dart'; |
| void f() { |
| var x = l^ |
| var y = _ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| l1t |
| kind: topLevelVariable |
| '''); |
| } |
| |
| Future<void> test_library007_2() async { |
| allowedIdentifiers = {'_l1t'}; |
| newFile('$testPackageLibPath/l1.dart', ''' |
| library l1; |
| var _l1t; var l1t = _l1t; |
| '''); |
| await computeSuggestions(''' |
| import 'l1.dart'; |
| void f() { |
| var x = l |
| var y = _^ |
| } |
| '''); |
| assertResponse(r''' |
| replacement |
| left: 1 |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_library008_1() async { |
| allowedIdentifiers = {'publicMethod', 'privateMethod'}; |
| newFile('$testPackageLibPath/public.dart', ''' |
| library public; |
| class NonPrivate { |
| void publicMethod() { |
| } |
| } |
| '''); |
| newFile('$testPackageLibPath/private.dart', ''' |
| library _private; |
| import 'public.dart'; |
| class Private extends NonPrivate { |
| void privateMethod() { |
| } |
| } |
| '''); |
| await computeSuggestions(''' |
| import 'private.dart'; |
| import 'public.dart'; |
| class Test { |
| void test() { |
| NonPrivate x = new NonPrivate(); |
| x.^ //publicMethod but not privateMethod should appear |
| } |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| publicMethod |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> test_library009_1() async { |
| allowedIdentifiers = {'X', 'm', 'Y'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| int X = 1; |
| void m(){} |
| class Y {} |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart' as Q; |
| void a() { |
| var x = Q.^ |
| } |
| void b() { |
| var x = [Q.] |
| } |
| void c() { |
| var x = new List.filled([Q.], null) |
| } |
| void d() { |
| new Q. |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| X |
| kind: topLevelVariable |
| Y |
| kind: class |
| Y |
| kind: constructorInvocation |
| m |
| kind: functionInvocation |
| '''); |
| } |
| |
| Future<void> test_library009_2() async { |
| allowedIdentifiers = {'X', 'm', 'Y'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| int X = 1; |
| void m(){} |
| class Y {} |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart' as Q; |
| void a() { |
| var x = Q. |
| } |
| void b() { |
| var x = [Q.^] |
| } |
| void c() { |
| var x = new List.filled([Q.], null) |
| } |
| void d() { |
| new Q. |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| X |
| kind: topLevelVariable |
| Y |
| kind: class |
| Y |
| kind: constructorInvocation |
| m |
| kind: functionInvocation |
| '''); |
| } |
| |
| Future<void> test_library009_3() async { |
| allowedIdentifiers = {'X', 'm', 'Y'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| int X = 1; |
| void m(){} |
| class Y {} |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart' as Q; |
| void a() { |
| var x = Q. |
| } |
| void b() { |
| var x = [Q.] |
| } |
| void c() { |
| var x = new List.filled([Q.^], null) |
| } |
| void d() { |
| new Q. |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| X |
| kind: topLevelVariable |
| Y |
| kind: class |
| Y |
| kind: constructorInvocation |
| m |
| kind: functionInvocation |
| '''); |
| } |
| |
| @FailingTest(reason: 'We suggest also the variable') |
| Future<void> test_library009_4() async { |
| allowedIdentifiers = {'Y', 'm', 'X'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| int X = 1; |
| void m(){} |
| class Y {} |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart' as Q; |
| void a() { |
| var x = Q. |
| } |
| void b() { |
| var x = [Q.] |
| } |
| void c() { |
| var x = new List.filled([Q.], null) |
| } |
| void d() { |
| new Q.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| Y |
| kind: constructorInvocation |
| '''); |
| } |
| |
| Future<void> test_memberOfPrivateClass_otherLibrary_1() async { |
| allowedIdentifiers = {'foo'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| class _A { |
| foo() {} |
| } |
| class A extends _A {} |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart'; |
| void f(A a) { |
| a.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| foo |
| kind: methodInvocation |
| '''); |
| } |
| |
| Future<void> |
| test_noPrivateElement_otherLibrary_constructor_1_withImport() async { |
| allowedIdentifiers = {'f', '_f'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| class A { |
| var f; |
| var _f; |
| void m() {_f;} |
| } |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart'; |
| void f() { |
| new A.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> |
| test_noPrivateElement_otherLibrary_constructor_1_withoutImport() async { |
| allowedIdentifiers = {'f', '_f'}; |
| await computeSuggestions(''' |
| import 'lib.dart'; |
| void f() { |
| new A.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| '''); |
| } |
| |
| Future<void> test_noPrivateElement_otherLibrary_member_1() async { |
| allowedIdentifiers = {'f', '_f'}; |
| newFile('$testPackageLibPath/lib.dart', ''' |
| library lib; |
| class A { |
| var f; |
| var _f; |
| void m() {_f;} |
| } |
| '''); |
| await computeSuggestions(''' |
| import 'lib.dart'; |
| void f(A a) { |
| a.^ |
| } |
| '''); |
| assertResponse(r''' |
| suggestions |
| f |
| kind: field |
| '''); |
| } |
| |
| Future<void> test_single_2() async { |
| allowedIdentifiers = {'B'}; |
| await computeSuggestions(''' |
| class A {int x; ^mth() {int y = this.x;}}class B{} |
| '''); |
| assertResponse(r''' |
| replacement |
| right: 3 |
| suggestions |
| B |
| kind: class |
| final |
| kind: keyword |
| static |
| kind: keyword |
| void |
| kind: keyword |
| const |
| kind: keyword |
| set |
| kind: keyword |
| factory |
| kind: keyword |
| covariant |
| kind: keyword |
| dynamic |
| kind: keyword |
| get |
| kind: keyword |
| late |
| kind: keyword |
| operator |
| kind: keyword |
| var |
| kind: keyword |
| '''); |
| } |
| } |