typescript 5.6.0-dev.20240808 → 5.6.0-dev.20240809

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240808`;
+var version = `${versionMajorMinor}.0-dev.20240809`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -21271,7 +21271,11 @@ function createNodeFactory(flags, baseFactory2) {
     node.modifiers = asNodeArray(modifiers);
     node.parameters = createNodeArray(parameters);
     node.body = body;
-    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | 1024 /* ContainsES2015 */;
+    if (!node.body) {
+      node.transformFlags = 1 /* ContainsTypeScript */;
+    } else {
+      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | 1024 /* ContainsES2015 */;
+    }
     node.typeParameters = void 0;
     node.type = void 0;
     node.typeArguments = void 0;
@@ -25405,7 +25409,7 @@ var asyncGeneratorHelper = {
         var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
             if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
             var g = generator.apply(thisArg, _arguments || []), i, q = [];
-            return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+            return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
             function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
             function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
             function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
@@ -25587,8 +25591,8 @@ var generatorHelper = {
   priority: 6,
   text: `
             var __generator = (this && this.__generator) || function (thisArg, body) {
-                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-                return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+                return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
                 function verb(n) { return function (v) { return step([n, v]); }; }
                 function step(op) {
                     if (f) throw new TypeError("Generator is already executing.");
@@ -49357,6 +49361,7 @@ function createTypeChecker(host) {
   }
   function symbolToString(symbol, enclosingDeclaration, meaning, flags = 4 /* AllowAnyNodeKind */, writer) {
     let nodeFlags = 70221824 /* IgnoreErrors */;
+    let internalNodeFlags = 0 /* None */;
     if (flags & 2 /* UseOnlyExternalAliasing */) {
       nodeFlags |= 128 /* UseOnlyExternalAliasing */;
     }
@@ -49367,15 +49372,15 @@ function createTypeChecker(host) {
       nodeFlags |= 16384 /* UseAliasDefinedOutsideCurrentScope */;
     }
     if (flags & 32 /* DoNotIncludeSymbolChain */) {
-      nodeFlags |= 134217728 /* DoNotIncludeSymbolChain */;
+      internalNodeFlags |= 4 /* DoNotIncludeSymbolChain */;
     }
     if (flags & 16 /* WriteComputedProps */) {
-      nodeFlags |= 1073741824 /* WriteComputedProps */;
+      internalNodeFlags |= 1 /* WriteComputedProps */;
     }
     const builder = flags & 4 /* AllowAnyNodeKind */ ? nodeBuilder.symbolToNode : nodeBuilder.symbolToEntityName;
     return writer ? symbolToStringWorker(writer).getText() : usingSingleLineStringWriter(symbolToStringWorker);
     function symbolToStringWorker(writer2) {
-      const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
+      const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags, internalNodeFlags);
       const printer = (enclosingDeclaration == null ? void 0 : enclosingDeclaration.kind) === 307 /* SourceFile */ ? createPrinterWithRemoveCommentsNeverAsciiEscape() : createPrinterWithRemoveComments();
       const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
       printer.writeNode(
@@ -49412,7 +49417,13 @@ function createTypeChecker(host) {
   }
   function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
     const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
-    const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0));
+    const typeNode = nodeBuilder.typeToTypeNode(
+      type,
+      enclosingDeclaration,
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
+      /*internalFlags*/
+      void 0
+    );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
     const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
@@ -49461,31 +49472,31 @@ function createTypeChecker(host) {
   }
   function createNodeBuilder() {
     return {
-      typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
         /*typeNode*/
         void 0
       )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToName(
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
         symbol,
         context,
         meaning,
         /*expectsIdentifier*/
         false
       )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -49507,13 +49518,13 @@ function createTypeChecker(host) {
       return setTextRange(setOriginalNode(range, location), location);
     }
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
-      const oldFlags = context.flags;
-      if (expr && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+      const restoreFlags = saveRestoreFlags(context);
+      if (expr && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
         syntacticNodeBuilder.serializeTypeOfExpression(expr, context, addUndefined);
       }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
+      context.internalFlags |= 2 /* NoSyntacticPrinter */;
       const result = expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined);
-      context.flags = oldFlags;
+      restoreFlags();
       return result;
     }
     function expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined) {
@@ -49566,7 +49577,7 @@ function createTypeChecker(host) {
       return void 0;
     }
     function symbolToNode(symbol, context, meaning) {
-      if (context.flags & 1073741824 /* WriteComputedProps */) {
+      if (context.internalFlags & 1 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
           const name = getNameOfDeclaration(symbol.valueDeclaration);
           if (name && isComputedPropertyName(name)) return name;
@@ -49579,12 +49590,13 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, tracker, cb) {
-      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
+    function withContext(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
         enclosingFile: enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration),
         flags: flags || 0 /* None */,
+        internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
         encounteredError: false,
         reportedDiagnostic: false,
@@ -49614,14 +49626,23 @@ function createTypeChecker(host) {
       }
       return context.encounteredError ? void 0 : resultingNode;
     }
+    function saveRestoreFlags(context) {
+      const flags = context.flags;
+      const internalFlags = context.internalFlags;
+      return restore;
+      function restore() {
+        context.flags = flags;
+        context.internalFlags = internalFlags;
+      }
+    }
     function checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
     function typeToTypeNodeHelper(type, context) {
-      const savedFlags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       const typeNode = typeToTypeNodeWorker(type, context);
-      context.flags = savedFlags;
+      restoreFlags();
       return typeNode;
     }
     function typeToTypeNodeWorker(type, context) {
@@ -50075,7 +50096,7 @@ function createTypeChecker(host) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
         const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
-        const key = `${getTypeId(type2)}|${context.flags}`;
+        const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
         }
@@ -50181,10 +50202,10 @@ function createTypeChecker(host) {
           }
           return typeToTypeNodeHelper(getIntersectionType(types), context);
         }
-        const savedFlags = context.flags;
+        const restoreFlags = saveRestoreFlags(context);
         context.flags |= 4194304 /* InObjectTypeLiteral */;
         const members = createTypeNodesFromResolvedType(resolved);
-        context.flags = savedFlags;
+        restoreFlags();
         const typeLiteralNode = factory.createTypeLiteralNode(members);
         context.approximateLength += 2;
         setEmitFlags(typeLiteralNode, context.flags & 1024 /* MultilineObjectLiterals */ ? 0 : 1 /* SingleLine */);
@@ -50247,10 +50268,10 @@ function createTypeChecker(host) {
               } while (i < length2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
               if (!rangeEquals(outerTypeParameters, typeArguments, start, i)) {
                 const typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context);
-                const flags2 = context.flags;
+                const restoreFlags2 = saveRestoreFlags(context);
                 context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
                 const ref = symbolToTypeNode(parent, context, 788968 /* Type */, typeArgumentSlice);
-                context.flags = flags2;
+                restoreFlags2();
                 resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
               }
             }
@@ -50288,10 +50309,10 @@ function createTypeChecker(host) {
             }
             typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
           }
-          const flags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
           const finalRef = symbolToTypeNode(type2.symbol, context, 788968 /* Type */, typeArgumentNodes);
-          context.flags = flags;
+          restoreFlags();
           return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
         }
       }
@@ -50603,7 +50624,7 @@ function createTypeChecker(host) {
           }
         }
         if (seenNames) {
-          const saveContextFlags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 64 /* UseFullyQualifiedType */;
           seenNames.forEach((types2) => {
             if (!arrayIsHomogeneous(types2, ([a], [b]) => typesAreSameReference(a, b))) {
@@ -50612,7 +50633,7 @@ function createTypeChecker(host) {
               }
             }
           });
-          context.flags = saveContextFlags;
+          restoreFlags();
         }
         return result;
       }
@@ -50664,19 +50685,19 @@ function createTypeChecker(host) {
       } else {
         typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
       }
-      const flags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       context.flags &= ~256 /* SuppressAnyReturnType */;
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      context.flags = flags;
+      restoreFlags();
       const returnTypeNode = serializeReturnTypeForSignature(context, signature);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags2 = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
+        const flags = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -50896,13 +50917,13 @@ function createTypeChecker(host) {
       }
     }
     function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
-      const savedContextFlags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       context.flags &= ~512 /* WriteTypeParametersInQualifiedName */;
       const modifiers = factory.createModifiersFromModifierFlags(getTypeParameterModifiers(type));
       const name = typeParameterToName(type, context);
       const defaultParameter = getDefaultFromTypeParameter(type);
       const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
-      context.flags = savedContextFlags;
+      restoreFlags();
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
@@ -51006,7 +51027,7 @@ function createTypeChecker(host) {
     function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
       let chain;
       const isTypeParameter = symbol.flags & 262144 /* TypeParameter */;
-      if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.flags & 134217728 /* DoNotIncludeSymbolChain */)) {
+      if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.internalFlags & 4 /* DoNotIncludeSymbolChain */)) {
         chain = Debug.checkDefined(getSymbolChain(
           symbol,
           meaning,
@@ -51532,19 +51553,19 @@ function createTypeChecker(host) {
       var _a, _b;
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
-      const oldFlags = context.flags;
-      if (declaration && hasInferredType(declaration) && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+      const restoreFlags = saveRestoreFlags(context);
+      if (declaration && hasInferredType(declaration) && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
         syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context);
       }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
-      if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
+      context.internalFlags |= 2 /* NoSyntacticPrinter */;
+      if (enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */)) {
         const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol);
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           const addUndefined = addUndefinedForParameter || !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declWithExistingAnnotation) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type));
           const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
-            context.flags = oldFlags;
+            restoreFlags();
             return result2;
           }
         }
@@ -51555,7 +51576,7 @@ function createTypeChecker(host) {
       const decl = declaration ?? symbol.valueDeclaration ?? ((_b = symbol.declarations) == null ? void 0 : _b[0]);
       const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
       const result = expressionOrTypeToTypeNode(context, expr, type, addUndefinedForParameter);
-      context.flags = oldFlags;
+      restoreFlags();
       return result;
     }
     function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) {
@@ -51569,26 +51590,26 @@ function createTypeChecker(host) {
     }
     function serializeReturnTypeForSignature(context, signature) {
       const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      const flags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       if (suppressAny) context.flags &= ~256 /* SuppressAnyReturnType */;
       let returnTypeNode;
       const returnType = getReturnTypeOfSignature(signature);
       if (returnType && !(suppressAny && isTypeAny(returnType))) {
-        if (signature.declaration && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+        if (signature.declaration && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
           syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, context);
         }
-        context.flags |= -2147483648 /* NoSyntacticPrinter */;
+        context.internalFlags |= 2 /* NoSyntacticPrinter */;
         returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
       } else if (!suppressAny) {
         returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
       }
-      context.flags = flags;
+      restoreFlags();
       return returnTypeNode;
     }
     function serializeReturnTypeForSignatureWorker(context, signature) {
       const typePredicate = getTypePredicateOfSignature(signature);
       const type = getReturnTypeOfSignature(signature);
-      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+      if (context.enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
         const annotation = getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
         if (annotation) {
           const result = tryReuseExistingTypeNode(context, annotation, type, context.enclosingDeclaration);
@@ -52090,7 +52111,7 @@ function createTypeChecker(host) {
           if (!hasDynamicName(node)) {
             return visitEachChild2(node, visitExistingNodeTreeSymbols);
           }
-          if (!(context.flags & 1 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
+          if (!(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
             return void 0;
           }
         }
@@ -52742,7 +52763,7 @@ function createTypeChecker(host) {
         const typeParamDecls = map(typeParams, (p) => typeParameterToDeclaration(p, context));
         const jsdocAliasDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isJSDocTypeAlias);
         const commentText = getTextOfJSDocComment(jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : void 0);
-        const oldFlags = context.flags;
+        const restoreFlags = saveRestoreFlags(context);
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
@@ -52766,7 +52787,7 @@ function createTypeChecker(host) {
           ),
           modifierFlags
         );
-        context.flags = oldFlags;
+        restoreFlags();
         context.enclosingDeclaration = oldEnclosingDecl;
       }
       function serializeInterface(symbol, symbolName2, modifierFlags) {
@@ -53775,10 +53796,10 @@ function createTypeChecker(host) {
       }
       function getNameCandidateWorker(symbol, localName) {
         if (localName === "default" /* Default */ || localName === "__class" /* Class */ || localName === "__function" /* Function */) {
-          const flags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 16777216 /* InInitialEntityName */;
           const nameCandidate = getNameOfSymbolAsWritten(symbol, context);
-          context.flags = flags;
+          restoreFlags();
           localName = nameCandidate.length > 0 && isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? stripQuotes(nameCandidate) : nameCandidate;
         }
         if (localName === "default" /* Default */) {
@@ -55361,7 +55382,8 @@ function createTypeChecker(host) {
       if (!node) {
         return void 0;
       }
-      switch (node.kind) {
+      const kind = node.kind;
+      switch (kind) {
         case 263 /* ClassDeclaration */:
         case 231 /* ClassExpression */:
         case 264 /* InterfaceDeclaration */:
@@ -55383,13 +55405,19 @@ function createTypeChecker(host) {
         case 200 /* MappedType */:
         case 194 /* ConditionalType */: {
           const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
-          if (node.kind === 200 /* MappedType */) {
+          if ((kind === 218 /* FunctionExpression */ || kind === 219 /* ArrowFunction */ || isObjectLiteralMethod(node)) && isContextSensitive(node)) {
+            const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfDeclaration(node)), 0 /* Call */));
+            if (signature && signature.typeParameters) {
+              return [...outerTypeParameters || emptyArray, ...signature.typeParameters];
+            }
+          }
+          if (kind === 200 /* MappedType */) {
             return append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter)));
-          } else if (node.kind === 194 /* ConditionalType */) {
+          } else if (kind === 194 /* ConditionalType */) {
             return concatenate(outerTypeParameters, getInferTypeParameters(node));
           }
           const outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(node));
-          const thisType = includeThisTypes && (node.kind === 263 /* ClassDeclaration */ || node.kind === 231 /* ClassExpression */ || node.kind === 264 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfDeclaration(node)).thisType;
+          const thisType = includeThisTypes && (kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 264 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfDeclaration(node)).thisType;
           return thisType ? append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
         }
         case 341 /* JSDocParameterTag */:
@@ -58201,8 +58229,11 @@ function createTypeChecker(host) {
       true
     );
   }
+  function getTypeParametersForMapper(signature) {
+    return sameMap(signature.typeParameters, (tp) => tp.mapper ? instantiateType(tp, tp.mapper) : tp);
+  }
   function createSignatureTypeMapper(signature, typeArguments) {
-    return createTypeMapper(sameMap(signature.typeParameters, (tp) => tp.mapper ? instantiateType(tp, tp.mapper) : tp), typeArguments);
+    return createTypeMapper(getTypeParametersForMapper(signature), typeArguments);
   }
   function getErasedSignature(signature) {
     return signature.typeParameters ? signature.erasedSignatureCache || (signature.erasedSignatureCache = createErasedSignature(signature)) : signature;
@@ -71216,7 +71247,7 @@ function createTypeChecker(host) {
       type,
       (t) => {
         var _a;
-        if (isGenericMappedType(t) && !t.declaration.nameType) {
+        if (isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */) {
           const constraint = getConstraintTypeFromMappedType(t);
           const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
           const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
@@ -73902,7 +73933,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
-    const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
+    const context = createInferenceContext(getTypeParametersForMapper(signature), signature, 0 /* None */, compareTypes);
     const restType = getEffectiveRestType(contextualSignature);
     const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
@@ -85939,14 +85970,14 @@ function createTypeChecker(host) {
       return 11 /* ObjectType */;
     }
   }
-  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker) {
+  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
     if (!declaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
     const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
@@ -85989,14 +86020,14 @@ function createTypeChecker(host) {
     }
     return candidateExpr;
   }
-  function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
+  function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
-  function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
+  function createTypeOfExpression(exprIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
     if (!expr) {
       return factory.createToken(133 /* AnyKeyword */);
@@ -86009,6 +86040,7 @@ function createTypeChecker(host) {
       void 0,
       enclosingDeclaration,
       flags | 1024 /* MultilineObjectLiterals */,
+      internalFlags,
       tracker
     );
   }
@@ -86114,6 +86146,8 @@ function createTypeChecker(host) {
       enclosing,
       /*flags*/
       void 0,
+      /*internalFlags*/
+      void 0,
       tracker
     ) : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
     if (enumResult) return enumResult;
@@ -86242,15 +86276,15 @@ function createTypeChecker(host) {
         const parseDecl = getParseTreeNode(decl);
         return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
       },
-      getDeclarationStatementsForSourceFile: (node, flags, tracker) => {
+      getDeclarationStatementsForSourceFile: (node, flags, internalFlags, tracker) => {
         const n = getParseTreeNode(node);
         Debug.assert(n && n.kind === 307 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
         const sym = getSymbolOfDeclaration(node);
         if (!sym) {
-          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
+          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, internalFlags, tracker);
         }
         resolveExternalModuleSymbol(sym);
-        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
+        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, internalFlags, tracker);
       },
       isImportRequiredByAugmentation,
       isDefinitelyReferenceToGlobalSymbolObject
@@ -91222,7 +91256,6 @@ function transformTypeScript(context) {
   let currentNamespaceContainerName;
   let currentLexicalScope;
   let currentScopeFirstDeclarationsOfName;
-  let currentClassHasParameterProperties;
   let enabledSubstitutions;
   let applicableSubstitutions;
   return transformSourceFileOrBundle;
@@ -91250,14 +91283,12 @@ function transformTypeScript(context) {
   function saveStateAndInvoke(node, f) {
     const savedCurrentScope = currentLexicalScope;
     const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
-    const savedCurrentClassHasParameterProperties = currentClassHasParameterProperties;
     onBeforeVisitNode(node);
     const visited = f(node);
     if (currentLexicalScope !== savedCurrentScope) {
       currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
     }
     currentLexicalScope = savedCurrentScope;
-    currentClassHasParameterProperties = savedCurrentClassHasParameterProperties;
     return visited;
   }
   function onBeforeVisitNode(node) {
@@ -91890,7 +91921,7 @@ function transformTypeScript(context) {
   }
   function visitPropertyNameOfClassElement(member) {
     const name = member.name;
-    if (isComputedPropertyName(name) && (!hasStaticModifier(member) && currentClassHasParameterProperties || hasDecorators(member) && legacyDecorators)) {
+    if (legacyDecorators && isComputedPropertyName(name) && hasDecorators(member)) {
       const expression = visitNode(name.expression, visitor, isExpression);
       Debug.assert(expression);
       const innerExpression = skipPartiallyEmittedExpressions(expression);
@@ -111353,7 +111384,8 @@ function getDeclarationDiagnostics(host, resolver, file) {
     false
   ).diagnostics : void 0;
 }
-var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitInternalNodeBuilderFlags = 8 /* AllowUnresolvedNames */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
   let getSymbolAccessibilityDiagnostic = throwDiagnostic;
@@ -111509,7 +111541,7 @@ function transformDeclarations(context) {
       diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
       errorNode: s.errorNode || sourceFile
     };
-    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker);
+    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
     getSymbolAccessibilityDiagnostic = oldDiag;
     return result;
   }
@@ -111779,7 +111811,7 @@ function transformDeclarations(context) {
       case 172 /* PropertyDeclaration */:
       case 208 /* BindingElement */:
       case 260 /* VariableDeclaration */:
-        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
         break;
       case 262 /* FunctionDeclaration */:
       case 180 /* ConstructSignature */:
@@ -111787,7 +111819,7 @@ function transformDeclarations(context) {
       case 174 /* MethodDeclaration */:
       case 177 /* GetAccessor */:
       case 179 /* CallSignature */:
-        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
         break;
       default:
         Debug.assertNever(node);
@@ -112388,7 +112420,7 @@ function transformDeclarations(context) {
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker),
+            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
             /*initializer*/
             void 0
           );
@@ -112514,7 +112546,7 @@ function transformDeclarations(context) {
               return void 0;
             }
             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
-            const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags | -2147483648 /* NoSyntacticPrinter */, symbolTracker);
+            const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags | 2 /* NoSyntacticPrinter */, symbolTracker);
             getSymbolAccessibilityDiagnostic = oldDiag;
             const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
             const name = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
@@ -112717,7 +112749,7 @@ function transformDeclarations(context) {
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, symbolTracker),
+            resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
             /*initializer*/
             void 0
           );