Skip to content

Commit 703f3be

Browse files
a-tarasyuka-tarasyuk
committed
fix(26141): show completions for string parenthesized types
1 parent 191f4f6 commit 703f3be

File tree

3 files changed

+174
-28
lines changed

3 files changed

+174
-28
lines changed

‎src/services/stringCompletions.ts‎

Lines changed: 51 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -107,33 +107,12 @@ namespace ts.Completions.StringCompletions {
107107
readonly isNewIdentifier: boolean;
108108
}
109109
type StringLiteralCompletion = { readonly kind: StringLiteralCompletionKind.Paths, readonly paths: readonly PathCompletion[] } | StringLiteralCompletionsFromProperties | StringLiteralCompletionsFromTypes;
110-
function getStringLiteralCompletionEntries(sourceFile: SourceFile, node: StringLiteralLike, position: number, typeChecker: TypeChecker, compilerOptions: CompilerOptions, host: LanguageServiceHost): StringLiteralCompletion | undefined {
110+
function getStringLiteralCompletionEntries(sourceFile: SourceFile, node: StringLiteralLike | ParenthesizedExpression, position: number, typeChecker: TypeChecker, compilerOptions: CompilerOptions, host: LanguageServiceHost): StringLiteralCompletion | undefined {
111111
const { parent } = node;
112112
switch (parent.kind) {
113-
case SyntaxKind.LiteralType:
114-
switch (parent.parent.kind) {
115-
case SyntaxKind.TypeReference:
116-
return { kind: StringLiteralCompletionKind.Types, types: getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(parent as LiteralTypeNode)), isNewIdentifier: false };
117-
case SyntaxKind.IndexedAccessType:
118-
// Get all apparent property names
119-
// i.e. interface Foo {
120-
// foo: string;
121-
// bar: string;
122-
// }
123-
// let x: Foo["/*completion position*/"]
124-
return stringLiteralCompletionsFromProperties(typeChecker.getTypeFromTypeNode((parent.parent as IndexedAccessTypeNode).objectType));
125-
case SyntaxKind.ImportType:
126-
return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker) };
127-
case SyntaxKind.UnionType: {
128-
if (!isTypeReferenceNode(parent.parent.parent)) return undefined;
129-
const alreadyUsedTypes = getAlreadyUsedTypesInStringLiteralUnion(parent.parent as UnionTypeNode, parent as LiteralTypeNode);
130-
const types = getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(parent.parent as UnionTypeNode)).filter(t => !contains(alreadyUsedTypes, t.value));
131-
return { kind: StringLiteralCompletionKind.Types, types, isNewIdentifier: false };
132-
}
133-
default:
134-
return undefined;
135-
}
136-
113+
case SyntaxKind.LiteralType: {
114+
return isStringLiteralLike(node) ? getCompletionEntriesFromStringLiteral(sourceFile, node, typeChecker, compilerOptions, host) : undefined;
115+
}
137116
case SyntaxKind.PropertyAssignment:
138117
if (isObjectLiteralExpression(parent.parent) && (<PropertyAssignment>parent).name === node) {
139118
// Get quoted name of properties of the object literal expression
@@ -179,15 +158,20 @@ namespace ts.Completions.StringCompletions {
179158

180159
case SyntaxKind.ImportDeclaration:
181160
case SyntaxKind.ExportDeclaration:
182-
case SyntaxKind.ExternalModuleReference:
161+
case SyntaxKind.ExternalModuleReference: {
183162
// Get all known external module names or complete a path to a module
184163
// i.e. import * as ns from "/*completion position*/";
185164
// var y = import("/*completion position*/");
186165
// import x = require("/*completion position*/");
187166
// var y = require("/*completion position*/");
188167
// export * from "/*completion position*/";
189-
return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker) };
190-
168+
if (isStringLiteralLike(node)) {
169+
return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker) };
170+
}
171+
return undefined;
172+
}
173+
case SyntaxKind.ParenthesizedExpression:
174+
return getStringLiteralCompletionEntries(sourceFile, parent as ParenthesizedExpression, position, typeChecker, compilerOptions, host);
191175
default:
192176
return fromContextualType();
193177
}
@@ -199,6 +183,45 @@ namespace ts.Completions.StringCompletions {
199183
}
200184
}
201185

186+
function getCompletionEntriesFromStringLiteral(sourceFile: SourceFile, node: StringLiteralLike | ParenthesizedTypeNode, typeChecker: TypeChecker, compilerOptions: CompilerOptions, host: LanguageServiceHost): StringLiteralCompletion | undefined {
187+
const parent = node.parent;
188+
switch (parent.parent.kind) {
189+
case SyntaxKind.TypeReference: {
190+
if (isLiteralTypeNode(parent) || isParenthesizedTypeNode(parent)){
191+
return { kind: StringLiteralCompletionKind.Types, types: getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(parent)), isNewIdentifier: false };
192+
}
193+
return undefined;
194+
}
195+
case SyntaxKind.IndexedAccessType:
196+
// Get all apparent property names
197+
// i.e. interface Foo {
198+
// foo: string;
199+
// bar: string;
200+
// }
201+
// let x: Foo["/*completion position*/"]
202+
return stringLiteralCompletionsFromProperties(typeChecker.getTypeFromTypeNode((parent.parent as IndexedAccessTypeNode).objectType));
203+
case SyntaxKind.ImportType: {
204+
if (isStringLiteralLike(node)) {
205+
return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker) };
206+
}
207+
return undefined;
208+
}
209+
case SyntaxKind.UnionType: {
210+
if (!isTypeReferenceNode(parent.parent.parent)) {
211+
return undefined;
212+
}
213+
const unionType = parent.parent as UnionTypeNode;
214+
const alreadyUsedTypes = isLiteralTypeNode(parent) ? getAlreadyUsedTypesInStringLiteralUnion(unionType, parent) : [];
215+
const types = getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(unionType)).filter(t => !contains(alreadyUsedTypes, t.value));
216+
return { kind: StringLiteralCompletionKind.Types, types, isNewIdentifier: false };
217+
}
218+
case SyntaxKind.ParenthesizedType:
219+
return getCompletionEntriesFromStringLiteral(sourceFile, parent as ParenthesizedTypeNode, typeChecker, compilerOptions, host);
220+
default:
221+
return undefined;
222+
}
223+
}
224+
202225
function getAlreadyUsedTypesInStringLiteralUnion(union: UnionTypeNode, current: LiteralTypeNode): readonly string[] {
203226
return mapDefined(union.types, type =>
204227
type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : undefined);

‎tests/cases/fourslash/completionListStringParenthesizedExpression.ts‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
/// <reference path='fourslash.ts'/>
2+
3+
////const foo = {
4+
//// a: 1,
5+
//// b: 1,
6+
//// c: 1
7+
////}
8+
////const a = foo["[|/*1*/|]"];
9+
////const b = foo[("[|/*2*/|]")];
10+
////const c = foo[(("[|/*3*/|]"))];
11+
12+
const [r1, r2, r3] = test.ranges();
13+
verify.completions(
14+
{
15+
marker: "1",
16+
exact: [
17+
{ name: "a", replacementSpan: r1 },
18+
{ name: "b", replacementSpan: r1 },
19+
{ name: "c", replacementSpan: r1 }
20+
]
21+
},
22+
{
23+
marker: "2",
24+
exact: [
25+
{ name: "a", replacementSpan: r2 },
26+
{ name: "b", replacementSpan: r2 },
27+
{ name: "c", replacementSpan: r2 }
28+
]
29+
},
30+
{
31+
marker: "3",
32+
exact: [
33+
{ name: "a", replacementSpan: r3 },
34+
{ name: "b", replacementSpan: r3 },
35+
{ name: "c", replacementSpan: r3 }
36+
]
37+
}
38+
);

‎tests/cases/fourslash/completionListStringParenthesizedType.ts‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
/// <reference path='fourslash.ts'/>
2+
3+
////type T1 = "a" | "b" | "c";
4+
////type T2<T extends T1> = {};
5+
////
6+
////type T3 = T2<"[|/*1*/|]">;
7+
////type T4 = T2<("[|/*2*/|]")>;
8+
////type T5 = T2<(("[|/*3*/|]"))>;
9+
////type T6 = T2<((("[|/*4*/|]")))>;
10+
////
11+
////type T7<P extends T1, K extends T1> = {};
12+
////type T8 = T7<"a", ((("[|/*5*/|]")))>;
13+
////
14+
////interface Foo {
15+
//// a: number;
16+
//// b: number;
17+
////}
18+
////const a: Foo["[|/*6*/|]"];
19+
////const b: Foo[("[|/*7*/|]")];
20+
////const b: Foo[(("[|/*8*/|]"))];
21+
22+
const [r1, r2, r3, r4, r5, r6, r7, r8] = test.ranges();
23+
verify.completions(
24+
{
25+
marker: "1",
26+
exact: [
27+
{ name: "a", replacementSpan: r1 },
28+
{ name: "b", replacementSpan: r1 },
29+
{ name: "c", replacementSpan: r1 }
30+
]
31+
},
32+
{
33+
marker: "2",
34+
exact: [
35+
{ name: "a", replacementSpan: r2 },
36+
{ name: "b", replacementSpan: r2 },
37+
{ name: "c", replacementSpan: r2 }
38+
]
39+
},
40+
{
41+
marker: "3",
42+
exact: [
43+
{ name: "a", replacementSpan: r3 },
44+
{ name: "b", replacementSpan: r3 },
45+
{ name: "c", replacementSpan: r3 }
46+
]
47+
},
48+
{
49+
marker: "4",
50+
exact: [
51+
{ name: "a", replacementSpan: r4 },
52+
{ name: "b", replacementSpan: r4 },
53+
{ name: "c", replacementSpan: r4 }
54+
]
55+
},
56+
{
57+
marker: "5",
58+
exact: [
59+
{ name: "a", replacementSpan: r5 },
60+
{ name: "b", replacementSpan: r5 },
61+
{ name: "c", replacementSpan: r5 }
62+
]
63+
},
64+
{
65+
marker: "6",
66+
exact: [
67+
{ name: "a", replacementSpan: r6 },
68+
{ name: "b", replacementSpan: r6 }
69+
]
70+
},
71+
{
72+
marker: "7",
73+
exact: [
74+
{ name: "a", replacementSpan: r7 },
75+
{ name: "b", replacementSpan: r7 }
76+
]
77+
},
78+
{
79+
marker: "8",
80+
exact: [
81+
{ name: "a", replacementSpan: r8 },
82+
{ name: "b", replacementSpan: r8 }
83+
]
84+
}
85+
);

0 commit comments

Comments
 (0)