typescript 5.5.0-dev.20240522 → 5.5.0-dev.20240524

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240522`;
+var version = `${versionMajorMinor}.0-dev.20240524`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3561,6 +3561,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["TemplateLiteral"] = 134217728] = "TemplateLiteral";
   TypeFlags2[TypeFlags2["StringMapping"] = 268435456] = "StringMapping";
   TypeFlags2[TypeFlags2["Reserved1"] = 536870912] = "Reserved1";
+  TypeFlags2[TypeFlags2["Reserved2"] = 1073741824] = "Reserved2";
   TypeFlags2[TypeFlags2["AnyOrUnknown"] = 3] = "AnyOrUnknown";
   TypeFlags2[TypeFlags2["Nullable"] = 98304] = "Nullable";
   TypeFlags2[TypeFlags2["Literal"] = 2944] = "Literal";
@@ -3599,6 +3600,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
   TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
   TypeFlags2[TypeFlags2["IncludesConstrainedTypeVariable"] = 536870912 /* Reserved1 */] = "IncludesConstrainedTypeVariable";
+  TypeFlags2[TypeFlags2["IncludesError"] = 1073741824 /* Reserved2 */] = "IncludesError";
   TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323331] = "NotPrimitiveUnion";
   return TypeFlags2;
 })(TypeFlags || {});
@@ -7508,6 +7510,8 @@ var Diagnostics = {
   Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit: diag(9035, 1 /* Error */, "Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit_9035", "Add satisfies and a type assertion to this expression (satisfies T as T) to make the type explicit."),
   Move_the_expression_in_default_export_to_a_variable_and_add_a_type_annotation_to_it: diag(9036, 1 /* Error */, "Move_the_expression_in_default_export_to_a_variable_and_add_a_type_annotation_to_it_9036", "Move the expression in default export to a variable and add a type annotation to it."),
   Default_exports_can_t_be_inferred_with_isolatedDeclarations: diag(9037, 1 /* Error */, "Default_exports_can_t_be_inferred_with_isolatedDeclarations_9037", "Default exports can't be inferred with --isolatedDeclarations."),
+  Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations: diag(9038, 1 /* Error */, "Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations_9038", "Computed property names on class or object literals cannot be inferred with --isolatedDeclarations."),
+  Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations: diag(9039, 1 /* Error */, "Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations_9039", "Type containing private name '{0}' can't be used with --isolatedDeclarations."),
   JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17e3, 1 /* Error */, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
   JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, 1 /* Error */, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."),
   Expected_corresponding_JSX_closing_tag_for_0: diag(17002, 1 /* Error */, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."),
@@ -45053,7 +45057,6 @@ function createTypeChecker(host) {
   var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions, {
     isEntityNameVisible,
     isExpandoFunctionDeclaration,
-    isNonNarrowedBindableName,
     getAllAccessorDeclarations: getAllAccessorDeclarationsForDeclaration,
     requiresAddingImplicitUndefined,
     isUndefinedIdentifierExpression(node) {
@@ -46239,7 +46242,12 @@ function createTypeChecker(host) {
         if (resolvedTarget === unknownSymbol) {
           return source;
         }
-        target = cloneSymbol(resolvedTarget);
+        if (!(resolvedTarget.flags & getExcludedSymbolFlags(source.flags)) || (source.flags | resolvedTarget.flags) & 67108864 /* Assignment */) {
+          target = cloneSymbol(resolvedTarget);
+        } else {
+          reportMergeSymbolError(target, source);
+          return source;
+        }
       }
       if (source.flags & 512 /* ValueModule */ && target.flags & 512 /* ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
         target.constEnumOnlyModule = false;
@@ -46269,27 +46277,30 @@ function createTypeChecker(host) {
         );
       }
     } else {
-      const isEitherEnum = !!(target.flags & 384 /* Enum */ || source.flags & 384 /* Enum */);
-      const isEitherBlockScoped = !!(target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */);
+      reportMergeSymbolError(target, source);
+    }
+    return target;
+    function reportMergeSymbolError(target2, source2) {
+      const isEitherEnum = !!(target2.flags & 384 /* Enum */ || source2.flags & 384 /* Enum */);
+      const isEitherBlockScoped = !!(target2.flags & 2 /* BlockScopedVariable */ || source2.flags & 2 /* BlockScopedVariable */);
       const message = isEitherEnum ? Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations : isEitherBlockScoped ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
-      const sourceSymbolFile = source.declarations && getSourceFileOfNode(source.declarations[0]);
-      const targetSymbolFile = target.declarations && getSourceFileOfNode(target.declarations[0]);
+      const sourceSymbolFile = source2.declarations && getSourceFileOfNode(source2.declarations[0]);
+      const targetSymbolFile = target2.declarations && getSourceFileOfNode(target2.declarations[0]);
       const isSourcePlainJs = isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs);
       const isTargetPlainJs = isPlainJsFile(targetSymbolFile, compilerOptions.checkJs);
-      const symbolName2 = symbolToString(source);
+      const symbolName2 = symbolToString(source2);
       if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
         const firstFile = comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 /* LessThan */ ? sourceSymbolFile : targetSymbolFile;
         const secondFile = firstFile === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
         const filesDuplicates = getOrUpdate(amalgamatedDuplicates, `${firstFile.path}|${secondFile.path}`, () => ({ firstFile, secondFile, conflictingSymbols: /* @__PURE__ */ new Map() }));
         const conflictingSymbolInfo = getOrUpdate(filesDuplicates.conflictingSymbols, symbolName2, () => ({ isBlockScoped: isEitherBlockScoped, firstFileLocations: [], secondFileLocations: [] }));
-        if (!isSourcePlainJs) addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
-        if (!isTargetPlainJs) addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
+        if (!isSourcePlainJs) addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source2);
+        if (!isTargetPlainJs) addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target2);
       } else {
-        if (!isSourcePlainJs) addDuplicateDeclarationErrorsForSymbols(source, message, symbolName2, target);
-        if (!isTargetPlainJs) addDuplicateDeclarationErrorsForSymbols(target, message, symbolName2, source);
+        if (!isSourcePlainJs) addDuplicateDeclarationErrorsForSymbols(source2, message, symbolName2, target2);
+        if (!isTargetPlainJs) addDuplicateDeclarationErrorsForSymbols(target2, message, symbolName2, source2);
       }
     }
-    return target;
     function addDuplicateLocations(locs, symbol) {
       if (symbol.declarations) {
         for (const decl of symbol.declarations) {
@@ -49135,6 +49146,9 @@ function createTypeChecker(host) {
   function isClassInstanceSide(type) {
     return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 16777216 /* IsClassInstanceClone */));
   }
+  function getTypeFromTypeNodeWithoutContext(node) {
+    return getTypeFromTypeNode(node);
+  }
   function createNodeBuilder() {
     return {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
@@ -49163,6 +49177,12 @@ function createTypeChecker(host) {
       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))
     };
+    function getTypeFromTypeNode2(context, node, noMappedTypes) {
+      const type = getTypeFromTypeNodeWithoutContext(node);
+      if (!context.mapper) return type;
+      const mappedType = instantiateType(type, context.mapper);
+      return noMappedTypes && mappedType !== type ? void 0 : mappedType;
+    }
     function setTextRange2(context, range, location) {
       if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
         range = factory.cloneNode(range);
@@ -49208,7 +49228,7 @@ function createTypeChecker(host) {
       }
       const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2);
       if (clone) {
-        if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
+        if (addUndefined && !someType(getTypeFromTypeNode2(context, typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
           return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
         }
         return clone;
@@ -49221,13 +49241,19 @@ function createTypeChecker(host) {
       }
       return void 0;
     }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType) {
-      if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType = getTypeFromTypeNode2(
+      context,
+      existing,
+      /*noMappedTypes*/
+      true
+    )) {
+      if (annotationType && typeNodeIsEquivalentToType(host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
         const result = tryReuseExistingTypeNodeHelper(context, existing);
         if (result) {
           return result;
         }
       }
+      context.tracker.reportInferenceFallback(existing);
       return void 0;
     }
     function symbolToNode(symbol, context, meaning) {
@@ -49269,7 +49295,8 @@ function createTypeChecker(host) {
         mustCreateTypeParametersNamesLookups: true,
         typeParameterNames: void 0,
         typeParameterNamesByText: void 0,
-        typeParameterNamesByTextNextNameCount: void 0
+        typeParameterNamesByTextNextNameCount: void 0,
+        mapper: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -49560,8 +49587,8 @@ function createTypeChecker(host) {
           context.inferTypeParameters = type2.root.inferTypeParameters;
           const extendsTypeNode2 = typeToTypeNodeHelper(instantiateType(type2.root.extendsType, newMapper), context);
           context.inferTypeParameters = saveInferTypeParameters2;
-          const trueTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.trueType), newMapper));
-          const falseTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.falseType), newMapper));
+          const trueTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode2(context, type2.root.node.trueType), newMapper));
+          const falseTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode2(context, type2.root.node.falseType), newMapper));
           return factory.createConditionalTypeNode(
             checkTypeNode,
             factory.createInferTypeNode(factory.createTypeParameterDeclaration(
@@ -49644,7 +49671,7 @@ function createTypeChecker(host) {
         context.approximateLength += 10;
         const result = setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
         if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type2.declaration.typeParameter.constraint.type)) || unknownType, type2.mapper);
+          const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode2(context, type2.declaration.typeParameter.constraint.type)) || unknownType, type2.mapper);
           return factory.createConditionalTypeNode(
             typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context),
             factory.createInferTypeNode(factory.createTypeParameterDeclaration(
@@ -50271,7 +50298,7 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
-      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters);
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters, signature.mapper);
       context.approximateLength += 3;
       if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
         typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
@@ -50379,11 +50406,15 @@ function createTypeChecker(host) {
     function getParametersInScope(node) {
       return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0;
     }
-    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters) {
+    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters, mapper) {
       const cleanupContext = cloneNodeBuilderContext(context);
       let cleanupParams;
       let cleanupTypeParams;
       const oldEnclosingDecl = context.enclosingDeclaration;
+      const oldMapper = context.mapper;
+      if (mapper) {
+        context.mapper = mapper;
+      }
       if (context.enclosingDeclaration && declaration) {
         let pushFakeScope2 = function(kind, addAll) {
           Debug.assert(context.enclosingDeclaration);
@@ -50482,6 +50513,7 @@ function createTypeChecker(host) {
         cleanupTypeParams == null ? void 0 : cleanupTypeParams();
         cleanupContext();
         context.enclosingDeclaration = oldEnclosingDecl;
+        context.mapper = oldMapper;
       };
     }
     function tryGetThisParameterDeclaration(signature, context) {
@@ -50499,7 +50531,7 @@ function createTypeChecker(host) {
             "this",
             /*questionToken*/
             void 0,
-            typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)
+            typeToTypeNodeHelper(getTypeFromTypeNode2(context, thisTag.typeExpression), context)
           );
         }
       }
@@ -51138,10 +51170,10 @@ function createTypeChecker(host) {
       const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
       if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
-        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
+        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol);
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
+          const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
             return result2;
           }
@@ -51161,7 +51193,7 @@ function createTypeChecker(host) {
       context.flags = oldFlags;
       return result;
     }
-    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type, typeFromTypeNode = getTypeFromTypeNode(typeNode)) {
+    function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) {
       if (typeFromTypeNode === type) {
         return true;
       }
@@ -51191,13 +51223,10 @@ function createTypeChecker(host) {
     function serializeReturnTypeForSignatureWorker(context, signature) {
       const typePredicate = getTypePredicateOfSignature(signature);
       const type = getReturnTypeOfSignature(signature);
-      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
+      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
         const annotation = signature.declaration && getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
-        const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
-        if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
-          const annotated = getTypeFromTypeNode(annotation);
-          const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
-          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, thisInstantiated);
+        if (annotation && getTypeFromTypeNode2(context, annotation) === type) {
+          const result = tryReuseExistingTypeNodeHelper(context, annotation);
           if (result) {
             return result;
           }
@@ -51263,6 +51292,9 @@ function createTypeChecker(host) {
           symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it shoudl point to the same reference
           symAtLocation && sym && !getSymbolIfSameReference(getExportSymbolOfValueSymbolIfExported(symAtLocation), sym)
         ) {
+          if (symAtLocation !== unknownSymbol) {
+            context.tracker.reportInferenceFallback(node);
+          }
           introducesError = true;
           return { introducesError, node, sym };
         }
@@ -51281,6 +51313,7 @@ function createTypeChecker(host) {
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
+          context.tracker.reportInferenceFallback(node);
           introducesError = true;
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
@@ -51336,13 +51369,26 @@ function createTypeChecker(host) {
           !(length(existing.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))));
         }
       }
+      if (isThisTypeNode(existing)) {
+        if (context.mapper === void 0) return true;
+        const type = getTypeFromTypeNode2(
+          context,
+          existing,
+          /*noMappedTypes*/
+          true
+        );
+        return !!type;
+      }
       if (isTypeReferenceNode(existing)) {
         if (isConstTypeReference(existing)) return false;
         const type = getTypeFromTypeReference(existing);
         const symbol = getNodeLinks(existing).resolvedSymbol;
         if (!symbol) return false;
         if (symbol.flags & 262144 /* TypeParameter */) {
-          return true;
+          const type2 = getDeclaredTypeOfSymbol(symbol);
+          if (context.mapper && getMappedType(type2, context.mapper) !== type2) {
+            return false;
+          }
         }
         if (isInJSDoc(existing)) {
           return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && symbol.flags & 788968 /* Type */;
@@ -51355,7 +51401,7 @@ function createTypeChecker(host) {
       return true;
     }
     function serializeExistingTypeNode(context, typeNode) {
-      const type = getTypeFromTypeNode(typeNode);
+      const type = getTypeFromTypeNode2(context, typeNode);
       return typeToTypeNodeHelper(type, context);
     }
     function tryReuseExistingTypeNodeHelper(context, existing) {
@@ -51403,8 +51449,8 @@ function createTypeChecker(host) {
         if (isJSDocTypeLiteral(node)) {
           return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => {
             const name = isIdentifier(t.name) ? t.name : t.name.right;
-            const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
-            const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
+            const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode2(context, node), name.escapedText);
+            const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode2(context, t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
             return factory.createPropertySignature(
               /*modifiers*/
               void 0,
@@ -51445,7 +51491,7 @@ function createTypeChecker(host) {
                 /*modifiers*/
                 void 0,
                 getEffectiveDotDotDotForParameter(p),
-                getNameForJSDocFunctionParameter(p, i),
+                setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
                 p.questionToken,
                 visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
                 /*initializer*/
@@ -51460,7 +51506,7 @@ function createTypeChecker(host) {
                 /*modifiers*/
                 void 0,
                 getEffectiveDotDotDotForParameter(p),
-                getNameForJSDocFunctionParameter(p, i),
+                setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
                 p.questionToken,
                 visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
                 /*initializer*/
@@ -51470,6 +51516,21 @@ function createTypeChecker(host) {
             );
           }
         }
+        if (isThisTypeNode(node)) {
+          if (canReuseTypeNode(context, node)) {
+            return node;
+          }
+          return serializeExistingTypeNode(context, node);
+        }
+        if (isTypeParameterDeclaration(node)) {
+          return factory.updateTypeParameterDeclaration(
+            node,
+            node.modifiers,
+            setTextRange2(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node),
+            visitNode(node.constraint, visitExistingNodeTreeSymbols, isTypeNode),
+            visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode)
+          );
+        }
         if (isTypeReferenceNode(node)) {
           if (canReuseTypeNode(context, node)) {
             const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
@@ -51501,7 +51562,7 @@ function createTypeChecker(host) {
           if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic
           (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
           !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
-            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode2(context, node), context), node);
           }
           return factory.updateImportTypeNode(
             node,
@@ -51571,10 +51632,16 @@ function createTypeChecker(host) {
             return factory.updateComputedPropertyName(node, literal);
           }
         }
-        if (isTypePredicateNode(node) && isIdentifier(node.parameterName)) {
-          const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
-          hadError = hadError || introducesError;
-          return factory.updateTypePredicateNode(node, node.assertsModifier, result, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
+        if (isTypePredicateNode(node)) {
+          let parameterName;
+          if (isIdentifier(node.parameterName)) {
+            const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
+            hadError = hadError || introducesError;
+            parameterName = result;
+          } else {
+            parameterName = node.parameterName;
+          }
+          return factory.updateTypePredicateNode(node, node.assertsModifier, parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
           const visited = visitEachChild(
@@ -52350,7 +52417,7 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode(a)) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode2(context, a)) || typeToTypeNodeHelper(getTypeFromTypeNode2(context, a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -58894,6 +58961,7 @@ function createTypeChecker(host) {
       if (flags & 465829888 /* Instantiable */) includes |= 33554432 /* IncludesInstantiable */;
       if (flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) includes |= 536870912 /* IncludesConstrainedTypeVariable */;
       if (type === wildcardType) includes |= 8388608 /* IncludesWildcard */;
+      if (isErrorType(type)) includes |= 1073741824 /* IncludesError */;
       if (!strictNullChecks && flags & 98304 /* Nullable */) {
         if (!(getObjectFlags(type) & 65536 /* ContainsWideningType */)) includes |= 4194304 /* IncludesNonWideningType */;
       } else {
@@ -59085,7 +59153,7 @@ function createTypeChecker(host) {
     const includes = addTypesToUnion(typeSet, 0, types);
     if (unionReduction !== 0 /* None */) {
       if (includes & 3 /* AnyOrUnknown */) {
-        return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType : unknownType;
+        return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : includes & 1073741824 /* IncludesError */ ? errorType : anyType : unknownType;
       }
       if (includes & 32768 /* Undefined */) {
         if (typeSet.length >= 2 && typeSet[0] === undefinedType && typeSet[1] === missingType) {
@@ -59211,6 +59279,7 @@ function createTypeChecker(host) {
     } else {
       if (flags & 3 /* AnyOrUnknown */) {
         if (type === wildcardType) includes |= 8388608 /* IncludesWildcard */;
+        if (isErrorType(type)) includes |= 1073741824 /* IncludesError */;
       } else if (strictNullChecks || !(flags & 98304 /* Nullable */)) {
         if (type === missingType) {
           includes |= 262144 /* IncludesMissingType */;
@@ -59338,7 +59407,7 @@ function createTypeChecker(host) {
       return neverType;
     }
     if (includes & 1 /* Any */) {
-      return includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType;
+      return includes & 8388608 /* IncludesWildcard */ ? wildcardType : includes & 1073741824 /* IncludesError */ ? errorType : anyType;
     }
     if (!strictNullChecks && includes & 98304 /* Nullable */) {
       return includes & 16777216 /* IncludesEmptyObject */ ? neverType : includes & 32768 /* Undefined */ ? undefinedType : nullType;
@@ -84841,6 +84910,7 @@ function createTypeChecker(host) {
   function getSingleReturnExpression(declaration) {
     let candidateExpr;
     if (declaration && !nodeIsMissing(declaration.body)) {
+      if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0;
       const body = declaration.body;
       if (body && isBlock(body)) {
         forEachReturnStatement(body, (s) => {
@@ -84975,22 +85045,6 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function isNonNarrowedBindableName(node) {
-    if (!hasBindableName(node.parent)) {
-      return false;
-    }
-    const expression = node.expression;
-    if (!isEntityNameExpression(expression)) {
-      return true;
-    }
-    const type = getTypeOfExpression(expression);
-    const symbol = getSymbolAtLocation(expression);
-    if (!symbol) {
-      return false;
-    }
-    const declaredType = getTypeOfSymbol(symbol);
-    return declaredType === type;
-  }
   function literalTypeToNode(type, enclosing, tracker) {
     const enumResult = type.flags & 1056 /* EnumLike */ ? nodeBuilder.symbolToExpression(
       type.symbol,
@@ -85109,7 +85163,6 @@ function createTypeChecker(host) {
         return node && getExternalModuleFileFromDeclaration(node);
       },
       isLiteralConstDeclaration,
-      isNonNarrowedBindableName,
       isLateBound: (nodeIn) => {
         const node = getParseTreeNode(nodeIn, isDeclaration);
         const symbol = node && getSymbolOfDeclaration(node);
@@ -92259,10 +92312,9 @@ function transformClassFields(context) {
       }
     }
   }
-  function getClassThis() {
+  function tryGetClassThis() {
     const lex = getClassLexicalEnvironment();
-    const classThis = lex.classThis ?? lex.classConstructor ?? (currentClassContainer == null ? void 0 : currentClassContainer.name);
-    return Debug.checkDefined(classThis);
+    return lex.classThis ?? lex.classConstructor ?? (currentClassContainer == null ? void 0 : currentClassContainer.name);
   }
   function transformAutoAccessor(node) {
     const commentRange = getCommentRange(node);
@@ -92290,7 +92342,7 @@ function transformClassFields(context) {
     setOriginalNode(backingField, node);
     setEmitFlags(backingField, 3072 /* NoComments */);
     setSourceMapRange(backingField, sourceMapRange);
-    const receiver = isStatic(node) ? getClassThis() : factory2.createThis();
+    const receiver = isStatic(node) ? tryGetClassThis() ?? factory2.createThis() : factory2.createThis();
     const getter = createAccessorPropertyGetRedirector(factory2, node, modifiers, getterName, receiver);
     setOriginalNode(getter, node);
     setCommentRange(getter, commentRange);
@@ -92856,7 +92908,7 @@ function transformClassFields(context) {
     var _a;
     let facts = 0 /* None */;
     const original = getOriginalNode(node);
-    if (isClassDeclaration(original) && classOrConstructorParameterIsDecorated(legacyDecorators, original)) {
+    if (isClassLike(original) && classOrConstructorParameterIsDecorated(legacyDecorators, original)) {
       facts |= 1 /* ClassWasDecorated */;
     }
     if (shouldTransformPrivateElementsOrClassStaticBlocks && (classHasClassThisAssignment(node) || classHasExplicitlyAssignedName(node))) {
@@ -110029,7 +110081,7 @@ function createGetIsolatedDeclarationErrors(resolver) {
     [260 /* VariableDeclaration */]: Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
     [172 /* PropertyDeclaration */]: Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
     [171 /* PropertySignature */]: Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
-    [167 /* ComputedPropertyName */]: Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations,
+    [167 /* ComputedPropertyName */]: Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations,
     [305 /* SpreadAssignment */]: Diagnostics.Objects_that_contain_spread_assignments_can_t_be_inferred_with_isolatedDeclarations,
     [304 /* ShorthandPropertyAssignment */]: Diagnostics.Objects_that_contain_shorthand_properties_can_t_be_inferred_with_isolatedDeclarations,
     [209 /* ArrayLiteralExpression */]: Diagnostics.Only_const_arrays_can_be_inferred_with_isolatedDeclarations,
@@ -110042,6 +110094,9 @@ function createGetIsolatedDeclarationErrors(resolver) {
     if (heritageClause) {
       return createDiagnosticForNode(node, Diagnostics.Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations);
     }
+    if ((isPartOfTypeNode(node) || isTypeQueryNode(node.parent)) && (isEntityName(node) || isEntityNameExpression(node))) {
+      return createEntityInTypeNodeError(node);
+    }
     Debug.type(node);
     switch (node.kind) {
       case 177 /* GetAccessor */:
@@ -110077,8 +110132,13 @@ function createGetIsolatedDeclarationErrors(resolver) {
     }
   }
   function findNearestDeclaration(node) {
-    const result = findAncestor(node, (n) => isExportAssignment(n) || (isStatement(n) ? "quit" : isVariableDeclaration(n) || isPropertyDeclaration(n) || isParameter(n)));
-    return result;
+    const result = findAncestor(node, (n) => isExportAssignment(n) || isStatement(n) || isVariableDeclaration(n) || isPropertyDeclaration(n) || isParameter(n));
+    if (!result) return void 0;
+    if (isExportAssignment(result)) return result;
+    if (isReturnStatement(result)) {
+      return findAncestor(result, (n) => isFunctionLikeDeclaration(n) && !isConstructorDeclaration(n));
+    }
+    return isStatement(result) ? void 0 : result;
   }
   function createAccessorTypeError(node) {
     const { getAccessor, setAccessor } = getAllAccessorDeclarations(node.symbol.declarations, node);
@@ -110092,11 +110152,10 @@ function createGetIsolatedDeclarationErrors(resolver) {
     }
     return diag2;
   }
-  function createObjectLiteralError(node) {
-    const diag2 = createDiagnosticForNode(node, errorByDeclarationKind[node.kind]);
+  function addParentDeclarationRelatedInfo(node, diag2) {
     const parentDeclaration = findNearestDeclaration(node);
     if (parentDeclaration) {
-      const targetStr = isExportAssignment(parentDeclaration) ? "" : getTextOfNode(
+      const targetStr = isExportAssignment(parentDeclaration) || !parentDeclaration.name ? "" : getTextOfNode(
         parentDeclaration.name,
         /*includeTrivia*/
         false
@@ -110105,30 +110164,19 @@ function createGetIsolatedDeclarationErrors(resolver) {
     }
     return diag2;
   }
+  function createObjectLiteralError(node) {
+    const diag2 = createDiagnosticForNode(node, errorByDeclarationKind[node.kind]);
+    addParentDeclarationRelatedInfo(node, diag2);
+    return diag2;
+  }
   function createArrayLiteralError(node) {
     const diag2 = createDiagnosticForNode(node, errorByDeclarationKind[node.kind]);
-    const parentDeclaration = findNearestDeclaration(node);
-    if (parentDeclaration) {
-      const targetStr = isExportAssignment(parentDeclaration) ? "" : getTextOfNode(
-        parentDeclaration.name,
-        /*includeTrivia*/
-        false
-      );
-      addRelatedInfo(diag2, createDiagnosticForNode(parentDeclaration, relatedSuggestionByDeclarationKind[parentDeclaration.kind], targetStr));
-    }
+    addParentDeclarationRelatedInfo(node, diag2);
     return diag2;
   }
   function createReturnTypeError(node) {
     const diag2 = createDiagnosticForNode(node, errorByDeclarationKind[node.kind]);
-    const parentDeclaration = findNearestDeclaration(node);
-    if (parentDeclaration) {
-      const targetStr = isExportAssignment(parentDeclaration) ? "" : getTextOfNode(
-        parentDeclaration.name,
-        /*includeTrivia*/
-        false
-      );
-      addRelatedInfo(diag2, createDiagnosticForNode(parentDeclaration, relatedSuggestionByDeclarationKind[parentDeclaration.kind], targetStr));
-    }
+    addParentDeclarationRelatedInfo(node, diag2);
     addRelatedInfo(diag2, createDiagnosticForNode(node, relatedSuggestionByDeclarationKind[node.kind]));
     return diag2;
   }
@@ -110166,11 +110214,20 @@ function createGetIsolatedDeclarationErrors(resolver) {
   function createClassExpressionError(node) {
     return createExpressionError(node, Diagnostics.Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations);
   }
+  function createEntityInTypeNodeError(node) {
+    const diag2 = createDiagnosticForNode(node, Diagnostics.Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations, getTextOfNode(
+      node,
+      /*includeTrivia*/
+      false
+    ));
+    addParentDeclarationRelatedInfo(node, diag2);
+    return diag2;
+  }
   function createExpressionError(node, diagnosticMessage) {
     const parentDeclaration = findNearestDeclaration(node);
     let diag2;
     if (parentDeclaration) {
-      const targetStr = isExportAssignment(parentDeclaration) ? "" : getTextOfNode(
+      const targetStr = isExportAssignment(parentDeclaration) || !parentDeclaration.name ? "" : getTextOfNode(
         parentDeclaration.name,
         /*includeTrivia*/
         false
@@ -110895,8 +110952,11 @@ function transformDeclarations(context) {
     if (shouldStripInternal(input)) return;
     if (isDeclaration(input)) {
       if (isDeclarationAndNotVisible(input)) return;
-      if (hasDynamicName(input) && !resolver.isLateBound(getParseTreeNode(input))) {
-        if (isolatedDeclarations && isClassDeclaration(input.parent) && isEntityNameExpression(input.name.expression) && resolver.isEntityNameVisible(input.name.expression, input.parent).accessibility === 0 /* Accessible */ && !resolver.isNonNarrowedBindableName(input.name)) {
+      if (hasDynamicName(input)) {
+        if (isolatedDeclarations && (isClassDeclaration(input.parent) || isObjectLiteralExpression(input.parent))) {
+          context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations));
+        }
+        if (isolatedDeclarations && (isInterfaceDeclaration(input.parent) || isTypeLiteralNode(input.parent)) && !isEntityNameExpression(input.name.expression)) {
           context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations));
         }
         if (!isEntityNameExpression(input.name.expression)) {
@@ -112829,7 +112889,6 @@ var notImplementedResolver = {
   isArgumentsLocalBinding: notImplemented,
   getExternalModuleFileFromDeclaration: notImplemented,
   isLiteralConstDeclaration: notImplemented,
-  isNonNarrowedBindableName: notImplemented,
   getJsxFactoryEntity: notImplemented,
   getJsxFragmentFactoryEntity: notImplemented,
   isBindingCapturedByNode: notImplemented,
@@ -129110,7 +129169,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
           expression,
           /*includeBigInt*/
           false
-        ) && !isEntityNameExpression(expression)) {
+        )) {
           context.tracker.reportInferenceFallback(prop.name);
           result = false;
         }
@@ -129124,21 +129183,6 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     for (const prop of objectLiteral.properties) {
       Debug.assert(!isShorthandPropertyAssignment(prop) && !isSpreadAssignment(prop));
       const name = prop.name;
-      if (prop.name.kind === 167 /* ComputedPropertyName */) {
-        if (!resolver.isNonNarrowedBindableName(prop.name)) {
-          context.tracker.reportInferenceFallback(prop.name);
-        } else if (isEntityNameExpression(prop.name.expression)) {
-          const visibilityResult = resolver.isEntityNameVisible(
-            prop.name.expression,
-            context.enclosingDeclaration,
-            /*shouldComputeAliasToMakeVisible*/
-            false
-          );
-          if (visibilityResult.accessibility !== 0 /* Accessible */) {
-            context.tracker.reportInferenceFallback(prop.name);
-          }
-        }
-      }
       switch (prop.kind) {
         case 174 /* MethodDeclaration */:
           canInferObjectLiteral = !!typeFromObjectLiteralMethod(prop, name, context) && canInferObjectLiteral;
@@ -129219,6 +129263,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
   function typeFromSingleReturnExpression(declaration, context) {
     let candidateExpr;
     if (declaration && !nodeIsMissing(declaration.body)) {
+      if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0;
       const body = declaration.body;
       if (body && isBlock(body)) {
         forEachReturnStatement(body, (s) => {