Provide member completions after dot in type locations using typeof (#54486)

Author: Andarist

src/compiler/checker.ts

@@ -564,6 +564,7 @@ import {
     isInternalModuleImportEqualsDeclaration,
     isInTopLevelContext,
     isIntrinsicJsxName,
+    isInTypeQuery,
     isIterationStatement,
     isJSDocAllType,
     isJSDocAugmentsTag,
@@ -25372,15 +25373,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return links.resolvedSymbol;
     }
 
-    function isInTypeQuery(node: Node): boolean {
-        // TypeScript 1.0 spec (April 2014): 3.6.3
-        // A type query consists of the keyword typeof followed by an expression.
-        // The expression is restricted to a single identifier or a sequence of identifiers separated by periods
-        return !!findAncestor(
-            node,
-            n => n.kind === SyntaxKind.TypeQuery ? true : n.kind === SyntaxKind.Identifier || n.kind === SyntaxKind.QualifiedName ? false : "quit");
-    }
-
     function isInAmbientOrTypeNode(node: Node): boolean {
         return !!(node.flags & NodeFlags.Ambient || findAncestor(node, n => isInterfaceDeclaration(n) || isTypeAliasDeclaration(n) || isTypeLiteralNode(n)));
     }

src/compiler/utilities.ts

@@ -6428,6 +6428,16 @@ export function isThisIdentifier(node: Node | undefined): boolean {
     return !!node && node.kind === SyntaxKind.Identifier && identifierIsThisKeyword(node as Identifier);
 }
 
+/** @internal */
+export function isInTypeQuery(node: Node): boolean {
+    // TypeScript 1.0 spec (April 2014): 3.6.3
+    // A type query consists of the keyword typeof followed by an expression.
+    // The expression is restricted to a single identifier or a sequence of identifiers separated by periods
+    return !!findAncestor(
+        node,
+        n => n.kind === SyntaxKind.TypeQuery ? true : n.kind === SyntaxKind.Identifier || n.kind === SyntaxKind.QualifiedName ? false : "quit");
+}
+
 /** @internal */
 export function isThisInTypeQuery(node: Node): boolean {
     if (!isThisIdentifier(node)) {

src/services/completions.ts

@@ -181,6 +181,7 @@ import {
     isInString,
     isInterfaceDeclaration,
     isIntersectionTypeNode,
+    isInTypeQuery,
     isJSDoc,
     isJSDocAugmentsTag,
     isJSDocImplementsTag,
@@ -3515,28 +3516,33 @@ function getCompletionData(
             }
         }
 
-        if (!isTypeLocation) {
+        if (!isTypeLocation || isInTypeQuery(node)) {
             // GH#39946. Pulling on the type of a node inside of a function with a contextual `this` parameter can result in a circularity
             // if the `node` is part of the exprssion of a `yield` or `return`. This circularity doesn't exist at compile time because
             // we will check (and cache) the type of `this` *before* checking the type of the node.
             typeChecker.tryGetThisTypeAt(node, /*includeGlobalThis*/ false);
-
             let type = typeChecker.getTypeAtLocation(node).getNonOptionalType();
-            let insertQuestionDot = false;
-            if (type.isNullableType()) {
-                const canCorrectToQuestionDot =
-                    isRightOfDot &&
-                    !isRightOfQuestionDot &&
-                    preferences.includeAutomaticOptionalChainCompletions !== false;
-
-                if (canCorrectToQuestionDot || isRightOfQuestionDot) {
-                    type = type.getNonNullableType();
-                    if (canCorrectToQuestionDot) {
-                        insertQuestionDot = true;
+
+            if (!isTypeLocation) {
+                let insertQuestionDot = false;
+                if (type.isNullableType()) {
+                    const canCorrectToQuestionDot =
+                        isRightOfDot &&
+                        !isRightOfQuestionDot &&
+                        preferences.includeAutomaticOptionalChainCompletions !== false;
+
+                    if (canCorrectToQuestionDot || isRightOfQuestionDot) {
+                        type = type.getNonNullableType();
+                        if (canCorrectToQuestionDot) {
+                            insertQuestionDot = true;
+                        }
                     }
                 }
+                addTypeProperties(type, !!(node.flags & NodeFlags.AwaitContext), insertQuestionDot);
+            }
+            else {
+                addTypeProperties(type.getNonNullableType(), /*insertAwait*/ false, /*insertQuestionDot*/ false);
             }
-            addTypeProperties(type, !!(node.flags & NodeFlags.AwaitContext), insertQuestionDot);
         }
     }
 

tests/cases/fourslash/completionListObjectMembersInTypeLocationWithTypeof.ts

@@ -0,0 +1,20 @@
+/// <reference path="fourslash.ts" />
+
+// @strict: true
+
+// repro from https://github.com/microsoft/TypeScript/issues/54480
+
+//// const languageService = { getCompletions() {} }
+//// type A = Parameters<typeof languageService./*1*/>
+//// 
+//// declare const obj: { dance: () => {} } | undefined
+//// type B = Parameters<typeof obj./*2*/>
+
+verify.completions({
+    marker: "1",
+    includes: [{ name: "getCompletions", text: "(method) getCompletions(): void" }],
+});
+verify.completions({
+    marker: "2",
+    includes: [{ name: "dance", text: "(property) dance: () => {}" }],
+});