Retry querying string completions from the inferred type if the original completions request doesn't return anything (#52875)

Author: Andarist

src/services/stringCompletions.ts

@@ -392,7 +392,7 @@ function getStringLiteralCompletionEntries(sourceFile: SourceFile, node: StringL
                 //      });
                 return stringLiteralCompletionsForObjectLiteral(typeChecker, parent.parent);
             }
-            return fromContextualType();
+            return fromContextualType() || fromContextualType(ContextFlags.None);
 
         case SyntaxKind.ElementAccessExpression: {
             const { expression, argumentExpression } = parent as ElementAccessExpression;
@@ -432,16 +432,24 @@ function getStringLiteralCompletionEntries(sourceFile: SourceFile, node: StringL
             return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };
         case SyntaxKind.CaseClause:
             const tracker = newCaseClauseTracker(typeChecker, (parent as CaseClause).parent.clauses);
-            const literals = fromContextualType().types.filter(literal => !tracker.hasValue(literal.value));
+            const contextualTypes = fromContextualType();
+            if (!contextualTypes) {
+                return;
+            }
+            const literals = contextualTypes.types.filter(literal => !tracker.hasValue(literal.value));
             return { kind: StringLiteralCompletionKind.Types, types: literals, isNewIdentifier: false };
         default:
             return fromContextualType();
     }
 
-    function fromContextualType(): StringLiteralCompletionsFromTypes {
+    function fromContextualType(contextFlags: ContextFlags = ContextFlags.Completions): StringLiteralCompletionsFromTypes | undefined {
         // Get completion for string literal from string literal type
         // i.e. var x: "hi" | "hello" = "/*completion position*/"
-        return { kind: StringLiteralCompletionKind.Types, types: getStringLiteralTypes(getContextualTypeFromParent(node, typeChecker, ContextFlags.Completions)), isNewIdentifier: false };
+        const types = getStringLiteralTypes(getContextualTypeFromParent(node, typeChecker, contextFlags));
+        if (!types.length) {
+            return;
+        }
+        return { kind: StringLiteralCompletionKind.Types, types, isNewIdentifier: false };
     }
 }
 

tests/cases/fourslash/completionPreferredSuggestions1.ts

@@ -16,5 +16,5 @@
 verify.completions({ marker: "1", includes: ["a", "b", "c"] });
 verify.completions({ marker: "2", includes: ["0", "1", "2"], isNewIdentifierLocation: true });
 verify.completions({ marker: "3", includes: ["a", "b", "c"] });
-verify.completions({ marker: "4", excludes: ["a", "b", "c"] });
+verify.completions({ marker: "4", exact: [] });
 verify.completions({ marker: "5", includes: ["a", "b", "c"] });

tests/cases/fourslash/completionsLiteralFromInferenceWithinInferredType1.ts

@@ -0,0 +1,17 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.tsx
+//// declare function test<T>(a: {
+////   [K in keyof T]: {
+////     b?: keyof T;
+////   };
+//// }): void;
+////
+//// test({
+////   foo: {},
+////   bar: {
+////     b: "/*ts*/",
+////   },
+//// });
+
+verify.completions({ marker: ["ts"], exact: ["foo", "bar"] });

tests/cases/fourslash/completionsLiteralFromInferenceWithinInferredType2.ts

@@ -0,0 +1,52 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.tsx
+//// type Values<T> = T[keyof T];
+////
+//// type GetStates<T> = T extends { states: object } ? T["states"] : never;
+////
+//// type IsNever<T> = [T] extends [never] ? 1 : 0;
+////
+//// type GetIds<T, Gathered extends string = never> = IsNever<T> extends 1
+////   ? Gathered
+////   : "id" extends keyof T
+////   ? GetIds<Values<GetStates<T>>, Gathered | `#${T["id"] & string}`>
+////   : GetIds<Values<GetStates<T>>, Gathered>;
+////
+//// type StateConfig<
+////   TStates extends Record<string, StateConfig> = Record<
+////     string,
+////     StateConfig<any>
+////   >,
+////   TIds extends string = string
+//// > = {
+////   id?: string;
+////   initial?: keyof TStates & string;
+////   states?: {
+////     [K in keyof TStates]: StateConfig<GetStates<TStates[K]>, TIds>;
+////   };
+////   on?: Record<string, TIds | `.${keyof TStates & string}`>;
+//// };
+////
+//// declare function createMachine<const T extends StateConfig<GetStates<T>, GetIds<T>>>(
+////   config: T
+//// ): void;
+////
+//// createMachine({
+////   initial: "child",
+////   states: {
+////     child: {
+////       initial: "foo",
+////       states: {
+////         foo: {
+////           id: "wow_deep_id",
+////         },
+////       },
+////     },
+////   },
+////   on: {
+////     EV: "/*ts*/",
+////   },
+//// });
+
+verify.completions({ marker: ["ts"], exact: ["#wow_deep_id", ".child"] });