Ensure parameters are in scope when converting parameter/return types into type nodes

Author: jakebailey

src/compiler/checker.ts

@@ -5042,7 +5042,7 @@ namespace ts {
                     }
                     if (context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams &&
                         type.flags & TypeFlags.TypeParameter &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         const name = typeParameterToName(type, context);
                         context.approximateLength += idText(name).length;
                         return factory.createTypeReferenceNode(factory.createIdentifier(idText(name)), /*typeArguments*/ undefined);
@@ -5826,6 +5826,22 @@ namespace ts {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(parameter => typeParameterToDeclaration(parameter, context));
                 }
 
+                // For regular function/method declarations, the enclosing declaration will already be signature.declaration,
+                // so this is a no-op, but for arrow functions and function expressions, the enclosing declaration will be
+                // the declaration that the arrow function / function expression is assigned to, which is not the right scope.
+                //
+                // If the parameters or return type include "typeof globalThis.paramName", using the wrong scope will lead
+                // us to believe that we can emit "typeof paramName" instead, even though that would refer to the parameter,
+                // not the global. Make sure we are in the right scope by changing the enclosingDeclaration to the function.
+                //
+                // We check that this signature's declaration is within the existing enclosing declaration so we don't pull
+                // in types from other files; if it is outside of the enclosing declaration, then we shouldn't be able to
+                // access those parameter types via typeof anyway.
+                const saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && saveEnclosingDeclaration && findAncestor(signature.declaration, (n) => n === saveEnclosingDeclaration)) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
+
                 const expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 const parameters = (some(expandedParams, p => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & CheckFlags.RestParameter)) ? signature.parameters : expandedParams).map(parameter => symbolToParameterDeclaration(parameter, context, kind === SyntaxKind.Constructor, options?.privateSymbolVisitor, options?.bundledImports));
@@ -5882,6 +5898,7 @@ namespace ts {
                     node.typeArguments = factory.createNodeArray(typeArguments);
                 }
 
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
 
@@ -6366,13 +6383,28 @@ namespace ts {
                 return false;
             }
 
-            function typeParameterToName(type: TypeParameter, context: NodeBuilderContext) {
+            // Returns true if this type parameter should be converted to a name via typeParameterToName,
+            // either because it is not accessible, or because it's a use of a type variable that has
+            // already been rewritten by typeParameterToName and so needs that rewritten name.
+            function typeParameterIsCachedOrNotAccessible(type: TypeParameter, context: NodeBuilderContext) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+
+            function getCachedTypeParameterName(type: TypeParameter, context: NodeBuilderContext) {
                 if (context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams && context.typeParameterNames) {
                     const cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+
+            function typeParameterToName(type: TypeParameter, context: NodeBuilderContext) {
+                const cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 let result = symbolToName(type.symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ true);
                 if (!(result.kind & SyntaxKind.Identifier)) {
                     return factory.createIdentifier("(Missing type parameter)");
@@ -6630,7 +6662,7 @@ namespace ts {
                     }
                     if (isIdentifier(node)) {
                         const type = getDeclaredTypeOfSymbol(sym);
-                        const name = sym.flags & SymbolFlags.TypeParameter && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : factory.cloneNode(node);
+                        const name = sym.flags & SymbolFlags.TypeParameter && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError, node: setEmitFlags(setOriginalNode(name, node), EmitFlags.NoAsciiEscaping) };
                     }