@typescript-deploys/pr-build 4.8.0-pr-49619-2 → 4.8.0-pr-49627-10

package/lib/lib.es5.d.ts

@@ -933,12 +933,24 @@ interface DateConstructor {
 declare var Date: DateConstructor;
 
 interface RegExpMatchArray extends Array<string> {
+    /**
+     * The index of the search at which the result was found.
+     */
     index?: number;
+    /**
+     * A copy of the search string.
+     */
     input?: string;
 }
 
 interface RegExpExecArray extends Array<string> {
+    /**
+     * The index of the search at which the result was found.
+     */
     index: number;
+    /**
+     * A copy of the search string.
+     */
     input: string;
 }
 

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220621";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220622";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -43590,7 +43590,7 @@ var ts;
                     }
                     if (context.flags & 4 &&
                         type.flags & 262144 &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         var name_2 = typeParameterToName(type, context);
                         context.approximateLength += ts.idText(name_2).length;
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), undefined);
@@ -44235,6 +44235,10 @@ var ts;
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return typeParameterToDeclaration(parameter, context); });
                 }
+                var saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && !ts.isInJSFile(signature.declaration) && saveEnclosingDeclaration && ts.findAncestor(signature.declaration, function (n) { return n === saveEnclosingDeclaration; })) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
                 var expandedParams = getExpandedParameters(signature, true)[0];
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
                 var thisParameter = tryGetThisParameterDeclaration(signature, context);
@@ -44285,6 +44289,7 @@ var ts;
                 if (typeArguments) {
                     node.typeArguments = ts.factory.createNodeArray(typeArguments);
                 }
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
             function tryGetThisParameterDeclaration(signature, context) {
@@ -44678,14 +44683,24 @@ var ts;
                 }
                 return false;
             }
-            function typeParameterToName(type, context) {
-                var _a, _b;
+            function typeParameterIsCachedOrNotAccessible(type, context) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+            function getCachedTypeParameterName(type, context) {
                 if (context.flags & 4 && context.typeParameterNames) {
                     var cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+            function typeParameterToName(type, context) {
+                var _a, _b;
+                var cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 var result = symbolToName(type.symbol, context, 788968, true);
                 if (!(result.kind & 79)) {
                     return ts.factory.createIdentifier("(Missing type parameter)");
@@ -44898,7 +44913,7 @@ var ts;
                     }
                     if (ts.isIdentifier(node)) {
                         var type = getDeclaredTypeOfSymbol(sym);
-                        var name = sym.flags & 262144 && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
+                        var name = sym.flags & 262144 && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym;
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216) };
                     }
@@ -53831,7 +53846,7 @@ var ts;
             });
         }
         function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068)
+            if (target.flags & (131068 | 131072))
                 return false;
             if (isTupleLikeType(source)) {
                 return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -53896,7 +53911,7 @@ var ts;
             });
         }
         function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068)
+            if (target.flags & (131068 | 131072))
                 return false;
             return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
         }
@@ -58335,7 +58350,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551, true);
-                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8)))
+                if (!symbol || !isConstVariable(symbol))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -64072,6 +64087,8 @@ var ts;
             if (result) {
                 return result;
             }
+            result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            getNodeLinks(node).resolvedSignature = result;
             if (reportErrors) {
                 if (candidatesForArgumentError) {
                     if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) {
@@ -64157,7 +64174,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            return result;
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;

package/lib/tsserver.js

@@ -109,7 +109,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220621";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220622";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -52939,7 +52939,7 @@ var ts;
                     }
                     if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ &&
                         type.flags & 262144 /* TypeParameter */ &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         var name_2 = typeParameterToName(type, context);
                         context.approximateLength += ts.idText(name_2).length;
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), /*typeArguments*/ undefined);
@@ -53644,6 +53644,23 @@ var ts;
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return 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. The declaration should also not be in a JS file; those can
+                // only be typed via JSDoc, but JSDoc annotations appear outside of the function and therefore are not in
+                // the function's scope, unlike true type annotations.
+                var saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && !ts.isInJSFile(signature.declaration) && saveEnclosingDeclaration && ts.findAncestor(signature.declaration, function (n) { return n === saveEnclosingDeclaration; })) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
@@ -53695,6 +53712,7 @@ var ts;
                 if (typeArguments) {
                     node.typeArguments = ts.factory.createNodeArray(typeArguments);
                 }
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
             function tryGetThisParameterDeclaration(signature, context) {
@@ -54124,14 +54142,27 @@ var ts;
                 }
                 return false;
             }
-            function typeParameterToName(type, context) {
-                var _a, _b;
+            // 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, context) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+            function getCachedTypeParameterName(type, context) {
                 if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
                     var cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+            function typeParameterToName(type, context) {
+                var _a, _b;
+                var cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 var result = symbolToName(type.symbol, context, 788968 /* Type */, /*expectsIdentifier*/ true);
                 if (!(result.kind & 79 /* Identifier */)) {
                     return ts.factory.createIdentifier("(Missing type parameter)");
@@ -54364,7 +54395,7 @@ var ts;
                     }
                     if (ts.isIdentifier(node)) {
                         var type = getDeclaredTypeOfSymbol(sym);
-                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
+                        var name = sym.flags & 262144 /* TypeParameter */ && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -64630,7 +64661,7 @@ var ts;
             });
         }
         function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             if (isTupleLikeType(source)) {
                 return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -64697,7 +64728,7 @@ var ts;
             });
         }
         function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
         }
@@ -69893,7 +69924,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
-                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* EnumMember */)))
+                if (!symbol || !isConstVariable(symbol))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -76643,6 +76674,15 @@ var ts;
             if (result) {
                 return result;
             }
+            result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            // Preemptively cache the result; getResolvedSignature will do this after we return, but
+            // we need to ensure that the result is present for the error checks below so that if
+            // this signature is encountered again, we handle the circularity (rather than producing a
+            // different result which may produce no errors and assert). Callers of getResolvedSignature
+            // don't hit this issue because they only observe this result after it's had a chance to
+            // be cached, but the error reporting code below executes before getResolvedSignature sets
+            // resolvedSignature.
+            getNodeLinks(node).resolvedSignature = result;
             // No signatures were applicable. Now report errors based on the last applicable signature with
             // no arguments excluded from assignability checks.
             // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
@@ -76734,7 +76774,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            return result;
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;

package/lib/tsserverlibrary.js

@@ -303,7 +303,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220621";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220622";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -53133,7 +53133,7 @@ var ts;
                     }
                     if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ &&
                         type.flags & 262144 /* TypeParameter */ &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         var name_2 = typeParameterToName(type, context);
                         context.approximateLength += ts.idText(name_2).length;
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), /*typeArguments*/ undefined);
@@ -53838,6 +53838,23 @@ var ts;
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return 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. The declaration should also not be in a JS file; those can
+                // only be typed via JSDoc, but JSDoc annotations appear outside of the function and therefore are not in
+                // the function's scope, unlike true type annotations.
+                var saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && !ts.isInJSFile(signature.declaration) && saveEnclosingDeclaration && ts.findAncestor(signature.declaration, function (n) { return n === saveEnclosingDeclaration; })) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
@@ -53889,6 +53906,7 @@ var ts;
                 if (typeArguments) {
                     node.typeArguments = ts.factory.createNodeArray(typeArguments);
                 }
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
             function tryGetThisParameterDeclaration(signature, context) {
@@ -54318,14 +54336,27 @@ var ts;
                 }
                 return false;
             }
-            function typeParameterToName(type, context) {
-                var _a, _b;
+            // 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, context) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+            function getCachedTypeParameterName(type, context) {
                 if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
                     var cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+            function typeParameterToName(type, context) {
+                var _a, _b;
+                var cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 var result = symbolToName(type.symbol, context, 788968 /* Type */, /*expectsIdentifier*/ true);
                 if (!(result.kind & 79 /* Identifier */)) {
                     return ts.factory.createIdentifier("(Missing type parameter)");
@@ -54558,7 +54589,7 @@ var ts;
                     }
                     if (ts.isIdentifier(node)) {
                         var type = getDeclaredTypeOfSymbol(sym);
-                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
+                        var name = sym.flags & 262144 /* TypeParameter */ && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -64824,7 +64855,7 @@ var ts;
             });
         }
         function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             if (isTupleLikeType(source)) {
                 return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -64891,7 +64922,7 @@ var ts;
             });
         }
         function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
         }
@@ -70087,7 +70118,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
-                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* EnumMember */)))
+                if (!symbol || !isConstVariable(symbol))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -76837,6 +76868,15 @@ var ts;
             if (result) {
                 return result;
             }
+            result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            // Preemptively cache the result; getResolvedSignature will do this after we return, but
+            // we need to ensure that the result is present for the error checks below so that if
+            // this signature is encountered again, we handle the circularity (rather than producing a
+            // different result which may produce no errors and assert). Callers of getResolvedSignature
+            // don't hit this issue because they only observe this result after it's had a chance to
+            // be cached, but the error reporting code below executes before getResolvedSignature sets
+            // resolvedSignature.
+            getNodeLinks(node).resolvedSignature = result;
             // No signatures were applicable. Now report errors based on the last applicable signature with
             // no arguments excluded from assignability checks.
             // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
@@ -76928,7 +76968,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            return result;
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;

package/lib/typescript.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220621";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220622";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -53124,7 +53124,7 @@ var ts;
                     }
                     if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ &&
                         type.flags & 262144 /* TypeParameter */ &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         var name_2 = typeParameterToName(type, context);
                         context.approximateLength += ts.idText(name_2).length;
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), /*typeArguments*/ undefined);
@@ -53829,6 +53829,23 @@ var ts;
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return 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. The declaration should also not be in a JS file; those can
+                // only be typed via JSDoc, but JSDoc annotations appear outside of the function and therefore are not in
+                // the function's scope, unlike true type annotations.
+                var saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && !ts.isInJSFile(signature.declaration) && saveEnclosingDeclaration && ts.findAncestor(signature.declaration, function (n) { return n === saveEnclosingDeclaration; })) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
@@ -53880,6 +53897,7 @@ var ts;
                 if (typeArguments) {
                     node.typeArguments = ts.factory.createNodeArray(typeArguments);
                 }
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
             function tryGetThisParameterDeclaration(signature, context) {
@@ -54309,14 +54327,27 @@ var ts;
                 }
                 return false;
             }
-            function typeParameterToName(type, context) {
-                var _a, _b;
+            // 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, context) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+            function getCachedTypeParameterName(type, context) {
                 if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
                     var cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+            function typeParameterToName(type, context) {
+                var _a, _b;
+                var cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 var result = symbolToName(type.symbol, context, 788968 /* Type */, /*expectsIdentifier*/ true);
                 if (!(result.kind & 79 /* Identifier */)) {
                     return ts.factory.createIdentifier("(Missing type parameter)");
@@ -54549,7 +54580,7 @@ var ts;
                     }
                     if (ts.isIdentifier(node)) {
                         var type = getDeclaredTypeOfSymbol(sym);
-                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
+                        var name = sym.flags & 262144 /* TypeParameter */ && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -64815,7 +64846,7 @@ var ts;
             });
         }
         function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             if (isTupleLikeType(source)) {
                 return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -64882,7 +64913,7 @@ var ts;
             });
         }
         function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
         }
@@ -70078,7 +70109,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
-                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* EnumMember */)))
+                if (!symbol || !isConstVariable(symbol))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -76828,6 +76859,15 @@ var ts;
             if (result) {
                 return result;
             }
+            result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            // Preemptively cache the result; getResolvedSignature will do this after we return, but
+            // we need to ensure that the result is present for the error checks below so that if
+            // this signature is encountered again, we handle the circularity (rather than producing a
+            // different result which may produce no errors and assert). Callers of getResolvedSignature
+            // don't hit this issue because they only observe this result after it's had a chance to
+            // be cached, but the error reporting code below executes before getResolvedSignature sets
+            // resolvedSignature.
+            getNodeLinks(node).resolvedSignature = result;
             // No signatures were applicable. Now report errors based on the last applicable signature with
             // no arguments excluded from assignability checks.
             // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
@@ -76919,7 +76959,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            return result;
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220621";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220622";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -53124,7 +53124,7 @@ var ts;
                     }
                     if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ &&
                         type.flags & 262144 /* TypeParameter */ &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         var name_2 = typeParameterToName(type, context);
                         context.approximateLength += ts.idText(name_2).length;
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), /*typeArguments*/ undefined);
@@ -53829,6 +53829,23 @@ var ts;
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return 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. The declaration should also not be in a JS file; those can
+                // only be typed via JSDoc, but JSDoc annotations appear outside of the function and therefore are not in
+                // the function's scope, unlike true type annotations.
+                var saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && !ts.isInJSFile(signature.declaration) && saveEnclosingDeclaration && ts.findAncestor(signature.declaration, function (n) { return n === saveEnclosingDeclaration; })) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
@@ -53880,6 +53897,7 @@ var ts;
                 if (typeArguments) {
                     node.typeArguments = ts.factory.createNodeArray(typeArguments);
                 }
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
             function tryGetThisParameterDeclaration(signature, context) {
@@ -54309,14 +54327,27 @@ var ts;
                 }
                 return false;
             }
-            function typeParameterToName(type, context) {
-                var _a, _b;
+            // 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, context) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+            function getCachedTypeParameterName(type, context) {
                 if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
                     var cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+            function typeParameterToName(type, context) {
+                var _a, _b;
+                var cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 var result = symbolToName(type.symbol, context, 788968 /* Type */, /*expectsIdentifier*/ true);
                 if (!(result.kind & 79 /* Identifier */)) {
                     return ts.factory.createIdentifier("(Missing type parameter)");
@@ -54549,7 +54580,7 @@ var ts;
                     }
                     if (ts.isIdentifier(node)) {
                         var type = getDeclaredTypeOfSymbol(sym);
-                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
+                        var name = sym.flags & 262144 /* TypeParameter */ && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -64815,7 +64846,7 @@ var ts;
             });
         }
         function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             if (isTupleLikeType(source)) {
                 return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -64882,7 +64913,7 @@ var ts;
             });
         }
         function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
         }
@@ -70078,7 +70109,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
-                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* EnumMember */)))
+                if (!symbol || !isConstVariable(symbol))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -76828,6 +76859,15 @@ var ts;
             if (result) {
                 return result;
             }
+            result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            // Preemptively cache the result; getResolvedSignature will do this after we return, but
+            // we need to ensure that the result is present for the error checks below so that if
+            // this signature is encountered again, we handle the circularity (rather than producing a
+            // different result which may produce no errors and assert). Callers of getResolvedSignature
+            // don't hit this issue because they only observe this result after it's had a chance to
+            // be cached, but the error reporting code below executes before getResolvedSignature sets
+            // resolvedSignature.
+            getNodeLinks(node).resolvedSignature = result;
             // No signatures were applicable. Now report errors based on the last applicable signature with
             // no arguments excluded from assignability checks.
             // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
@@ -76919,7 +76959,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            return result;
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220621";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220622";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -52919,7 +52919,7 @@ var ts;
                     }
                     if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ &&
                         type.flags & 262144 /* TypeParameter */ &&
-                        !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+                        typeParameterIsCachedOrNotAccessible(type, context)) {
                         var name_2 = typeParameterToName(type, context);
                         context.approximateLength += ts.idText(name_2).length;
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), /*typeArguments*/ undefined);
@@ -53624,6 +53624,23 @@ var ts;
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return 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. The declaration should also not be in a JS file; those can
+                // only be typed via JSDoc, but JSDoc annotations appear outside of the function and therefore are not in
+                // the function's scope, unlike true type annotations.
+                var saveEnclosingDeclaration = context.enclosingDeclaration;
+                if (signature.declaration && !ts.isInJSFile(signature.declaration) && saveEnclosingDeclaration && ts.findAncestor(signature.declaration, function (n) { return n === saveEnclosingDeclaration; })) {
+                    context.enclosingDeclaration = signature.declaration;
+                }
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
@@ -53675,6 +53692,7 @@ var ts;
                 if (typeArguments) {
                     node.typeArguments = ts.factory.createNodeArray(typeArguments);
                 }
+                context.enclosingDeclaration = saveEnclosingDeclaration;
                 return node;
             }
             function tryGetThisParameterDeclaration(signature, context) {
@@ -54104,14 +54122,27 @@ var ts;
                 }
                 return false;
             }
-            function typeParameterToName(type, context) {
-                var _a, _b;
+            // 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, context) {
+                return !!getCachedTypeParameterName(type, context) || !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration);
+            }
+            function getCachedTypeParameterName(type, context) {
                 if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
                     var cached = context.typeParameterNames.get(getTypeId(type));
                     if (cached) {
                         return cached;
                     }
                 }
+                return undefined;
+            }
+            function typeParameterToName(type, context) {
+                var _a, _b;
+                var cached = getCachedTypeParameterName(type, context);
+                if (cached) {
+                    return cached;
+                }
                 var result = symbolToName(type.symbol, context, 788968 /* Type */, /*expectsIdentifier*/ true);
                 if (!(result.kind & 79 /* Identifier */)) {
                     return ts.factory.createIdentifier("(Missing type parameter)");
@@ -54344,7 +54375,7 @@ var ts;
                     }
                     if (ts.isIdentifier(node)) {
                         var type = getDeclaredTypeOfSymbol(sym);
-                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
+                        var name = sym.flags & 262144 /* TypeParameter */ && typeParameterIsCachedOrNotAccessible(type, context) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -64610,7 +64641,7 @@ var ts;
             });
         }
         function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             if (isTupleLikeType(source)) {
                 return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -64677,7 +64708,7 @@ var ts;
             });
         }
         function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-            if (target.flags & 131068 /* Primitive */)
+            if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
                 return false;
             return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
         }
@@ -69873,7 +69904,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
-                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* EnumMember */)))
+                if (!symbol || !isConstVariable(symbol))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -76623,6 +76654,15 @@ var ts;
             if (result) {
                 return result;
             }
+            result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            // Preemptively cache the result; getResolvedSignature will do this after we return, but
+            // we need to ensure that the result is present for the error checks below so that if
+            // this signature is encountered again, we handle the circularity (rather than producing a
+            // different result which may produce no errors and assert). Callers of getResolvedSignature
+            // don't hit this issue because they only observe this result after it's had a chance to
+            // be cached, but the error reporting code below executes before getResolvedSignature sets
+            // resolvedSignature.
+            getNodeLinks(node).resolvedSignature = result;
             // No signatures were applicable. Now report errors based on the last applicable signature with
             // no arguments excluded from assignability checks.
             // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
@@ -76714,7 +76754,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
+            return result;
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "4.8.0-pr-49619-2",
+  "version": "4.8.0-pr-49627-10",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [