Progress

Author: jakebailey

src/compiler/checker.ts

@@ -4337,6 +4337,8 @@ namespace ts {
             if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) {
                 return undefined;
             }
+            // TODO(jakebailey): do something different with caching here rather than clearing node.id?
+            // Maybe, include in the key the length of the original chain?
             const links = getSymbolLinks(symbol);
             const cache = (links.accessibleChainCache ||= new Map());
             // Go from enclosingDeclaration to the first scope we check, so the cache is keyed off the scope and thus shared more
@@ -5090,7 +5092,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);
@@ -5880,6 +5882,31 @@ 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.
+                //
+                // 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 can't use the declaration directly; it may be in another file and so we may lose access to symbols
+                // accessible to the current enclosing declaration, or gain access to symbols not accessible to the current
+                // enclosing declaration. To keep this chain accurate, clone the function as a non-synthesized node (so that
+                // it can be used as an enclosing declaration) and make its parent the current enclosing declaration.
+                //
+                // If the declaration is in a JS file, then we don't need to do this at all, as there are no annotations besides
+                // JSDoc, which are always outside the function declaration, so are not in the parameter scope.
+                const saveEnclosingDeclaration = context.enclosingDeclaration;
+                const originalDeclaration = signature.declaration;
+                if (saveEnclosingDeclaration && originalDeclaration && originalDeclaration !== saveEnclosingDeclaration && !isInJSFile(originalDeclaration)) {
+                    // Debug.assert(!isJSDocSignature(originalDeclaration));
+                    const clone = parseNodeFactory.cloneNode(originalDeclaration);
+                    // setTextRange(clone, originalDeclaration); // TODO(jakebailey): Is this needed?
+                    setParent(clone, saveEnclosingDeclaration); // TODO(jakebailey): we can chain these if we want.
+                    context.enclosingDeclaration = clone;
+                }
+
                 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));
@@ -5936,6 +5963,7 @@ namespace ts {
                     node.typeArguments = factory.createNodeArray(typeArguments);
                 }
 
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
 
@@ -6420,7 +6448,29 @@ namespace ts {
                 return false;
             }
 
+            // TODO(jakebailey): Is this change still needed?
+            // 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;
+                }
                 if (context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams && context.typeParameterNames) {
                     const cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
@@ -6601,9 +6651,22 @@ namespace ts {
                 return initial;
             }
 
+            function isChildOfEnclosingDeclaration(enclosingDeclaration: Node | undefined, node: Node): boolean {
+                return !!findAncestor(node, n => isEnclosingDeclarationOrOriginal(n));
+                // If our enclosing declaration was created via cloning, then the enclosing declaration won't be
+                // an ancestor of say, a parameter declaration, but an original node may be.
+                function isEnclosingDeclarationOrOriginal(n: Node): boolean {
+                    for (let e = enclosingDeclaration; e; e = e.original) {
+                        if (e === n) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            }
 
             function getDeclarationWithTypeAnnotation(symbol: Symbol, enclosingDeclaration: Node | undefined) {
-                return symbol.declarations && find(symbol.declarations, s => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, n => n === enclosingDeclaration)));
+                return symbol.declarations && find(symbol.declarations, s => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || isChildOfEnclosingDeclaration(enclosingDeclaration, s)));
             }
 
             function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing: TypeNode, type: Type) {
@@ -6652,7 +6715,7 @@ namespace ts {
             function serializeReturnTypeForSignature(context: NodeBuilderContext, type: Type, signature: Signature, includePrivateSymbol?: (s: Symbol) => void, bundled?: boolean) {
                 if (!isErrorType(type) && context.enclosingDeclaration) {
                     const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
-                    if (!!findAncestor(annotation, n => n === context.enclosingDeclaration) && annotation) {
+                    if (annotation && isChildOfEnclosingDeclaration(context.enclosingDeclaration, annotation)) { // TODO(jakebailey): this also needs to check original; move to helper
                         const annotated = getTypeFromTypeNode(annotation);
                         const thisInstantiated = annotated.flags & TypeFlags.TypeParameter && (annotated as TypeParameter).isThisType ? instantiateType(annotated, signature.mapper) : annotated;
                         if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
@@ -6684,7 +6747,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) };
                     }
@@ -7116,7 +7179,7 @@ namespace ts {
                     visitedSymbols.add(getSymbolId(visitedSym));
                     // Only actually serialize symbols within the correct enclosing declaration, otherwise do nothing with the out-of-context symbol
                     const skipMembershipCheck = !isPrivate; // We only call this on exported symbols when we know they're in the correct scope
-                    if (skipMembershipCheck || (!!length(symbol.declarations) && some(symbol.declarations, d => !!findAncestor(d, n => n === enclosingDeclaration)))) {
+                    if (skipMembershipCheck || (!!length(symbol.declarations) && some(symbol.declarations, d => isChildOfEnclosingDeclaration(enclosingDeclaration, d)))) {
                         const oldContext = context;
                         context = cloneNodeBuilderContext(context);
                         serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);

src/compiler/factory/nodeFactory.ts

@@ -5576,6 +5576,7 @@ namespace ts {
                 clone[key] = node[key];
             }
 
+            clone.id = undefined; // New node, new ID.
             return clone;
         }