Fix typeof parameter resolution inconsistency in JSDoc comments

Author: sw1tch3roo

src/compiler/checker.ts

@@ -49630,6 +49630,27 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
+    function getParameterSymbolFromJSDocHost(node: Identifier): Symbol | undefined {
+        if (!isIdentifier(node)) {
+            return undefined;
+        }
+        const name = node.escapedText;
+        const decl = getHostSignatureFromJSDoc(node);
+        if (!decl) {
+            return undefined;
+        }
+        const parameter = find(decl.parameters, p => p.name.kind === SyntaxKind.Identifier && p.name.escapedText === name);
+        if (parameter && parameter.symbol) {
+            return parameter.symbol;
+        }
+        // If parameter.symbol is not available, try to get it from the function's locals
+        if (parameter && decl.locals) {
+            return decl.locals.get(name);
+        }
+        return undefined;
+    }
+
+
     function getSymbolOfNameOrPropertyAccessExpression(name: EntityName | PrivateIdentifier | PropertyAccessExpression | JSDocMemberName): Symbol | undefined {
         if (isDeclarationName(name)) {
             return getSymbolOfNode(name.parent);
@@ -49716,20 +49737,28 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
 
             const isJSDoc = findAncestor(name, or(isJSDocLinkLike, isJSDocNameReference, isJSDocMemberName));
-            const meaning = isJSDoc ? SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Value : SymbolFlags.Value;
+            const isJSDocContext = !!(name.flags & NodeFlags.JSDoc) || isJSDoc;
+            const meaning = isJSDocContext ? SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Value : SymbolFlags.Value;
             if (name.kind === SyntaxKind.Identifier) {
                 if (isJSXTagName(name) && isJsxIntrinsicTagName(name)) {
                     const symbol = getIntrinsicTagSymbol(name.parent as JsxOpeningLikeElement);
                     return symbol === unknownSymbol ? undefined : symbol;
                 }
+                // Check for parameter symbol in JSDoc typeof context
+                if (isJSDocContext && isInTypeQuery(name)) {
+                    const parameterSymbol = getParameterSymbolFromJSDocHost(name);
+                    if (parameterSymbol) {
+                        return parameterSymbol;
+                    }
+                }
                 const result = resolveEntityName(name, meaning, /*ignoreErrors*/ true, /*dontResolveAlias*/ true, getHostSignatureFromJSDoc(name));
-                if (!result && isJSDoc) {
+                if (!result && isJSDocContext) {
                     const container = findAncestor(name, or(isClassLike, isInterfaceDeclaration));
                     if (container) {
                         return resolveJSDocMemberName(name, /*ignoreErrors*/ true, getSymbolOfDeclaration(container));
                     }
                 }
-                if (result && isJSDoc) {
+                if (result && isJSDocContext) {
                     const container = getJSDocHost(name);
                     if (container && isEnumMember(container) && container === result.valueDeclaration) {
                         return resolveEntityName(name, meaning, /*ignoreErrors*/ true, /*dontResolveAlias*/ true, getSourceFileOfNode(container)) || result;

src/compiler/utilities.ts

@@ -11829,6 +11829,13 @@ export function createNameResolver({
                 return undefined;
             }
             if (!result) {
+                // Check for parameter symbol in JSDoc typeof context before failing
+                if (originalLocation && !isString(nameArg) && (originalLocation.flags & NodeFlags.JSDoc) && isInTypeQuery(originalLocation)) {
+                    const parameterSymbol = getParameterSymbolFromJSDocHost(originalLocation, (nameArg as Identifier).escapedText);
+                    if (parameterSymbol) {
+                        return parameterSymbol;
+                    }
+                }
                 onFailedToResolveSymbol(originalLocation, nameArg, meaning, nameNotFoundMessage);
             }
             else {
@@ -11839,6 +11846,25 @@ export function createNameResolver({
         return result;
     }
 
+    function getParameterSymbolFromJSDocHost(node: Node, name: __String): Symbol | undefined {
+        const decl = getHostSignatureFromJSDoc(node);
+        if (!decl) {
+            return undefined;
+        }
+        const parameter = find(decl.parameters, p => p.name && p.name.kind === SyntaxKind.Identifier && p.name.escapedText === name);
+        if (parameter && parameter.symbol) {
+            return parameter.symbol;
+        }
+        // If parameter.symbol is not available, try to get it from the function's locals
+        if (parameter && decl.locals) {
+            const localSymbol = decl.locals.get(name);
+            if (localSymbol) {
+                return localSymbol;
+            }
+        }
+        return undefined;
+    }
+
     function useOuterVariableScopeInParameter(result: Symbol, location: Node, lastLocation: Node) {
         const target = getEmitScriptTarget(compilerOptions);
         const functionLocation = location as FunctionLikeDeclaration;

tests/baselines/reference/jsdocTypeofParameterConsistency.symbols

@@ -0,0 +1,28 @@
+//// [tests/cases/compiler/jsdocTypeofParameterConsistency.ts] ////
+
+=== jsdocTypeofParameterConsistency.js ===
+/**
+ * @template T  
+ * @param {T} a
+ * @return {typeof a}
+ */
+function f(a) {
+>f : Symbol(f, Decl(jsdocTypeofParameterConsistency.js, 0, 0))
+>a : Symbol(a, Decl(jsdocTypeofParameterConsistency.js, 5, 11))
+
+    return a;
+>a : Symbol(a, Decl(jsdocTypeofParameterConsistency.js, 5, 11))
+}
+
+/**
+ * @template T
+ * @param {T} b  
+ * @return {typeof b}
+ */
+function g(b) {
+>g : Symbol(g, Decl(jsdocTypeofParameterConsistency.js, 7, 1))
+>b : Symbol(b, Decl(jsdocTypeofParameterConsistency.js, 14, 11))
+
+    return b;
+>b : Symbol(b, Decl(jsdocTypeofParameterConsistency.js, 14, 11))
+}

tests/baselines/reference/jsdocTypeofParameterConsistency.types

@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/jsdocTypeofParameterConsistency.ts] ////
+
+=== jsdocTypeofParameterConsistency.js ===
+/**
+ * @template T  
+ * @param {T} a
+ * @return {typeof a}
+ */
+function f(a) {
+>f : <T>(a: T) => typeof a
+>  : ^ ^^ ^^ ^^^^^        
+>a : T
+>  : ^
+
+    return a;
+>a : T
+>  : ^
+}
+
+/**
+ * @template T
+ * @param {T} b  
+ * @return {typeof b}
+ */
+function g(b) {
+>g : <T>(b: T) => typeof b
+>  : ^ ^^ ^^ ^^^^^        
+>b : T
+>  : ^
+
+    return b;
+>b : T
+>  : ^
+}