@typescript-deploys/pr-build 6.0.0-pr-54029-2 → 6.0.0-pr-53017-28

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "6.0";
-var version = `${versionMajorMinor}.0-insiders.20251129`;
+var version = `${versionMajorMinor}.0-insiders.20251201`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -17397,16 +17397,15 @@ function getCheckFlags(symbol) {
   return symbol.flags & 33554432 /* Transient */ ? symbol.links.checkFlags : 0;
 }
 function getDeclarationModifierFlagsFromSymbol(s, isWrite = false) {
-  const checkFlags = getCheckFlags(s);
-  if (!(checkFlags & 8192 /* ReverseMapped */) && s.valueDeclaration) {
+  if (s.valueDeclaration) {
     const declaration = isWrite && s.declarations && find(s.declarations, isSetAccessorDeclaration) || s.flags & 32768 /* GetAccessor */ && find(s.declarations, isGetAccessorDeclaration) || s.valueDeclaration;
     const flags = getCombinedModifierFlags(declaration);
     return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~7 /* AccessibilityModifier */;
   }
-  if (checkFlags & 6 /* Synthetic */) {
-    const checkFlags2 = s.links.checkFlags;
-    const accessModifier = checkFlags2 & 1024 /* ContainsPrivate */ ? 2 /* Private */ : checkFlags2 & 256 /* ContainsPublic */ ? 1 /* Public */ : 4 /* Protected */;
-    const staticModifier = checkFlags2 & 2048 /* ContainsStatic */ ? 256 /* Static */ : 0;
+  if (getCheckFlags(s) & 6 /* Synthetic */) {
+    const checkFlags = s.links.checkFlags;
+    const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 2 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 1 /* Public */ : 4 /* Protected */;
+    const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 256 /* Static */ : 0;
     return accessModifier | staticModifier;
   }
   if (s.flags & 4194304 /* Prototype */) {
@@ -47076,6 +47075,32 @@ function createTypeChecker(host) {
     emptyArray
   );
   var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
+  var allKeysUnknownType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    map(stringNumberSymbolType.types, (t) => createIndexInfo(
+      t,
+      unknownType,
+      /*isReadonly*/
+      false
+    ))
+  );
+  var allKeysAllKeysUnknownType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    map(stringNumberSymbolType.types, (t) => createIndexInfo(
+      t,
+      allKeysUnknownType,
+      /*isReadonly*/
+      false
+    ))
+  );
   var emptyGenericType = createAnonymousType(
     /*symbol*/
     void 0,
@@ -47294,6 +47319,7 @@ function createTypeChecker(host) {
   var deferredGlobalBigIntType;
   var deferredGlobalNaNSymbol;
   var deferredGlobalRecordSymbol;
+  var deferredGlobalPartialInferenceSymbol;
   var deferredGlobalClassDecoratorContextType;
   var deferredGlobalClassMethodDecoratorContextType;
   var deferredGlobalClassGetterDecoratorContextType;
@@ -58285,13 +58311,7 @@ function createTypeChecker(host) {
     const modifiers = getMappedTypeModifiers(type.mappedType);
     const readonlyMask = modifiers & 1 /* IncludeReadonly */ ? false : true;
     const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
-    const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(
-      indexInfo.type,
-      type.mappedType,
-      type.constraintType,
-      /*sourceValueDeclaration*/
-      void 0
-    ) || unknownType, readonlyMask && indexInfo.isReadonly)] : emptyArray;
+    const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType) || unknownType, readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
     const limitedConstraint = getLimitedConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
@@ -58304,18 +58324,10 @@ function createTypeChecker(host) {
       const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
       const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
       inferredProp.declarations = prop.declarations;
-      inferredProp.valueDeclaration = prop.valueDeclaration;
       inferredProp.links.nameType = getSymbolLinks(prop).nameType;
       inferredProp.links.propertyType = getTypeOfSymbol(prop);
-      if (type.constraintType.type.flags & 8388608 /* IndexedAccess */ && type.constraintType.type.objectType.flags & 262144 /* TypeParameter */ && type.constraintType.type.indexType.flags & 262144 /* TypeParameter */) {
-        const newTypeParam = type.constraintType.type.objectType;
-        const newMappedType = replaceIndexedAccess(type.mappedType, type.constraintType.type, newTypeParam);
-        inferredProp.links.mappedType = newMappedType;
-        inferredProp.links.constraintType = getIndexType(newTypeParam);
-      } else {
-        inferredProp.links.mappedType = type.mappedType;
-        inferredProp.links.constraintType = type.constraintType;
-      }
+      inferredProp.links.mappedType = type.mappedType;
+      inferredProp.links.constraintType = type.constraintType;
       members.set(prop.escapedName, inferredProp);
     }
     setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos);
@@ -60884,6 +60896,16 @@ function createTypeChecker(host) {
     ) || unknownSymbol);
     return deferredGlobalRecordSymbol === unknownSymbol ? void 0 : deferredGlobalRecordSymbol;
   }
+  function getGlobalPartialInferenceSymbol() {
+    deferredGlobalPartialInferenceSymbol || (deferredGlobalPartialInferenceSymbol = getGlobalTypeAliasSymbol(
+      "PartialInference",
+      /*arity*/
+      2,
+      /*reportErrors*/
+      false
+    ) || unknownSymbol);
+    return deferredGlobalPartialInferenceSymbol === unknownSymbol ? void 0 : deferredGlobalPartialInferenceSymbol;
+  }
   function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) {
     return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType;
   }
@@ -68115,10 +68137,7 @@ function createTypeChecker(host) {
       map(context.inferences, (i) => i.typeParameter),
       map(context.inferences, (inference, i) => () => {
         if (!inference.isFixed) {
-          if (context.intraExpressionInferenceSites) {
-            inferFromIntraExpressionSites(context.inferences, context.intraExpressionInferenceSites);
-            context.intraExpressionInferenceSites = void 0;
-          }
+          inferFromIntraExpressionSites(context);
           clearCachedInferences(context.inferences);
           inference.isFixed = true;
         }
@@ -68142,38 +68161,17 @@ function createTypeChecker(host) {
     }
   }
   function addIntraExpressionInferenceSite(context, node, type) {
-    const site = { node, type };
-    (context.intraExpressionInferenceSites ?? (context.intraExpressionInferenceSites = [])).push(site);
-    if (context.reverseMappedIntraExpressionInferenceSites) {
-      for (const reverseMappedSites of context.reverseMappedIntraExpressionInferenceSites) {
-        reverseMappedSites.push(site);
-      }
-    }
-  }
-  function pushReverseMappedTypeIntraExpressionInferenceScope(context, node) {
-    (context.reverseMappedIntraExpressionInferenceScopeNodes ?? (context.reverseMappedIntraExpressionInferenceScopeNodes = [])).push(node);
-    (context.reverseMappedIntraExpressionInferenceSites ?? (context.reverseMappedIntraExpressionInferenceSites = [])).push([]);
+    (context.intraExpressionInferenceSites ?? (context.intraExpressionInferenceSites = [])).push({ node, type });
   }
-  function popReverseMappedTypeIntraExpressionInferenceScope(context) {
-    context.reverseMappedIntraExpressionInferenceScopeNodes.pop();
-    context.reverseMappedIntraExpressionInferenceSites.pop();
-  }
-  function findReverseMappedTypeIntraExpressionInferenceScope(context, node) {
-    if (context == null ? void 0 : context.reverseMappedIntraExpressionInferenceScopeNodes) {
-      for (let i = context.reverseMappedIntraExpressionInferenceScopeNodes.length - 1; i >= 0; i--) {
-        if (context.reverseMappedIntraExpressionInferenceScopeNodes[i] === node) {
-          return i;
+  function inferFromIntraExpressionSites(context) {
+    if (context.intraExpressionInferenceSites) {
+      for (const { node, type } of context.intraExpressionInferenceSites) {
+        const contextualType = node.kind === 175 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
+        if (contextualType) {
+          inferTypes(context.inferences, type, contextualType);
         }
       }
-    }
-    return -1;
-  }
-  function inferFromIntraExpressionSites(inferences, intraExpressionInferenceSites) {
-    for (const { node, type } of intraExpressionInferenceSites) {
-      const contextualType = node.kind === 175 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
-      if (contextualType) {
-        inferTypes(inferences, type, contextualType);
-      }
+      context.intraExpressionInferenceSites = void 0;
     }
   }
   function createInferenceInfo(typeParameter) {
@@ -68185,7 +68183,8 @@ function createTypeChecker(host) {
       priority: void 0,
       topLevel: true,
       isFixed: false,
-      impliedArity: void 0
+      impliedArity: void 0,
+      indexes: void 0
     };
   }
   function cloneInferenceInfo(inference) {
@@ -68197,7 +68196,8 @@ function createTypeChecker(host) {
       priority: inference.priority,
       topLevel: inference.topLevel,
       isFixed: inference.isFixed,
-      impliedArity: inference.impliedArity
+      impliedArity: inference.impliedArity,
+      indexes: inference.indexes && inference.indexes.slice()
     };
   }
   function cloneInferredPartOfContext(context) {
@@ -68263,6 +68263,11 @@ function createTypeChecker(host) {
     );
   }
   function inferTypeForHomomorphicMappedType(source, target, constraint) {
+    if (constraint.type.flags & 8388608 /* IndexedAccess */) {
+      const newTypeParam = constraint.type.objectType;
+      target = replaceIndexedAccess(target, constraint.type, newTypeParam);
+      constraint = getIndexType(newTypeParam);
+    }
     const cacheKey = source.id + "," + target.id + "," + constraint.id;
     if (reverseHomomorphicMappedCache.has(cacheKey)) {
       return reverseHomomorphicMappedCache.get(cacheKey);
@@ -68271,31 +68276,22 @@ function createTypeChecker(host) {
     reverseHomomorphicMappedCache.set(cacheKey, type);
     return type;
   }
+  function isPartiallyInferableType(type) {
+    return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getElementTypes(type), isPartiallyInferableType);
+  }
   function createReverseMappedType(source, target, constraint) {
-    if (!getIndexInfoOfType(source, stringType) && !getPropertiesOfType(source).length) {
+    if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
       return void 0;
     }
     if (isArrayType(source)) {
-      const elementType = inferReverseMappedType(
-        getTypeArguments(source)[0],
-        target,
-        constraint,
-        /*sourceValueDeclaration*/
-        void 0
-      );
+      const elementType = inferReverseMappedType(getTypeArguments(source)[0], target, constraint);
       if (!elementType) {
         return void 0;
       }
       return createArrayType(elementType, isReadonlyArrayType(source));
     }
     if (isTupleType(source)) {
-      const elementTypes = map(getElementTypes(source), (t) => inferReverseMappedType(
-        t,
-        target,
-        constraint,
-        /*sourceValueDeclaration*/
-        void 0
-      ));
+      const elementTypes = map(getElementTypes(source), (t) => inferReverseMappedType(t, target, constraint));
       if (!every(elementTypes, (t) => !!t)) {
         return void 0;
       }
@@ -68315,39 +68311,28 @@ function createTypeChecker(host) {
   function getTypeOfReverseMappedSymbol(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
-      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType, symbol.valueDeclaration) || unknownType;
+      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType) || unknownType;
     }
     return links.type;
   }
-  function inferReverseMappedTypeWorker(sourceType, target, constraint, sourceValueDeclaration) {
-    const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
+  function inferReverseMappedTypeWorker(sourceType, target, constraint) {
+    const typeParameter = getTypeParameterFromMappedType(target);
+    const inferenceTarget = getIndexedAccessType(constraint.type, typeParameter);
     const templateType = getTemplateTypeFromMappedType(target);
-    const inference = createInferenceInfo(typeParameter);
+    const inference = createInferenceInfo(inferenceTarget);
     inferTypes([inference], sourceType, templateType);
-    if (sourceValueDeclaration && getObjectFlags(sourceType) & 262144 /* NonInferrableType */) {
-      const scopeNode = sourceValueDeclaration.parent;
-      const inferenceContext = getInferenceContext(scopeNode);
-      const index = findReverseMappedTypeIntraExpressionInferenceScope(inferenceContext, scopeNode);
-      if (index !== -1) {
-        Debug.assert(inferenceContext);
-        const intraExpressionSites = inferenceContext.reverseMappedIntraExpressionInferenceSites[index];
-        const recordSymbol = getGlobalRecordSymbol();
-        if (intraExpressionSites.length && recordSymbol) {
-          pushContextualType(
-            scopeNode,
-            getTypeAliasInstantiation(recordSymbol, [stringNumberSymbolType, templateType]),
-            /*isCache*/
-            false
-          );
-          inferFromIntraExpressionSites([inference], intraExpressionSites);
-          popContextualType();
-        }
-      }
+    const inferredType = getTypeFromInference(inference);
+    if (inferredType) {
+      return inferredType;
     }
-    return getTypeFromInference(inference) || unknownType;
+    if (inference.indexes) {
+      const eraseSelfMapper = makeArrayTypeMapper([constraint.type, typeParameter], [allKeysAllKeysUnknownType, stringNumberSymbolType]);
+      return instantiateType(getIntersectionType(inference.indexes), eraseSelfMapper);
+    }
+    return unknownType;
   }
-  function inferReverseMappedType(source, target, constraint, sourceValueDeclaration) {
-    const cacheKey = source.id + "," + target.id + "," + constraint.id + (sourceValueDeclaration && getObjectFlags(source) & 262144 /* NonInferrableType */ ? "," + getNodeId(sourceValueDeclaration) : "");
+  function inferReverseMappedType(source, target, constraint) {
+    const cacheKey = source.id + "," + target.id + "," + constraint.id;
     if (reverseMappedCache.has(cacheKey)) {
       return reverseMappedCache.get(cacheKey) || unknownType;
     }
@@ -68358,7 +68343,7 @@ function createTypeChecker(host) {
     if (isDeeplyNestedType(target, reverseMappedTargetStack, reverseMappedTargetStack.length, 2)) reverseExpandingFlags |= 2 /* Target */;
     let type;
     if (reverseExpandingFlags !== 3 /* Both */) {
-      type = inferReverseMappedTypeWorker(source, target, constraint, sourceValueDeclaration);
+      type = inferReverseMappedTypeWorker(source, target, constraint);
     }
     reverseMappedSourceStack.pop();
     reverseMappedTargetStack.pop();
@@ -68685,6 +68670,29 @@ function createTypeChecker(host) {
       } else if (source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */) {
         inferFromTypes(source.objectType, target.objectType);
         inferFromTypes(source.indexType, target.indexType);
+      } else if (!(priority & 1 /* NakedTypeVariable */) && target.flags & 8388608 /* IndexedAccess */) {
+        if (isFromInferenceBlockedSource(source)) {
+          return;
+        }
+        const inference = getInferenceInfoForType(getActualTypeVariable(target.objectType));
+        if (inference) {
+          if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
+            return;
+          }
+          if (!inference.isFixed) {
+            const partialInferenceTypeSymbol = getGlobalPartialInferenceSymbol();
+            if (partialInferenceTypeSymbol) {
+              if (target.indexType.flags & 465829888 /* Instantiable */) {
+                const recordSymbol = getGlobalRecordSymbol();
+                if (recordSymbol) {
+                  inference.indexes = append(inference.indexes, getTypeAliasInstantiation(recordSymbol, [target.indexType, source]));
+                }
+              } else {
+                inference.indexes = append(inference.indexes, getTypeAliasInstantiation(partialInferenceTypeSymbol, [source, target.indexType]));
+              }
+            }
+          }
+        }
       } else if (source.flags & 268435456 /* StringMapping */ && target.flags & 268435456 /* StringMapping */) {
         if (source.symbol === target.symbol) {
           inferFromTypes(source.type, target.type);
@@ -68878,7 +68886,7 @@ function createTypeChecker(host) {
       }
     }
     function inferToMappedType(source, target, constraintType) {
-      if (constraintType.flags & 3145728 /* UnionOrIntersection */) {
+      if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
         let result = false;
         for (const type of constraintType.types) {
           result = inferToMappedType(source, target, type) || result;
@@ -69188,6 +69196,52 @@ function createTypeChecker(host) {
           const preferCovariantType = inferredCovariantType && (!inferredContravariantType || !(inferredCovariantType.flags & (131072 /* Never */ | 1 /* Any */)) && some(inference.contraCandidates, (t) => isTypeAssignableTo(inferredCovariantType, t)) && every(context.inferences, (other) => other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeAssignableTo(t, inferredCovariantType))));
           inferredType = preferCovariantType ? inferredCovariantType : inferredContravariantType;
           fallbackType = preferCovariantType ? inferredContravariantType : inferredCovariantType;
+        } else if (inference.indexes) {
+          const eraseSelfMapper = makeUnaryTypeMapper(inference.typeParameter, allKeysUnknownType);
+          let aggregateInference = instantiateType(getIntersectionType(inference.indexes), mergeTypeMappers(eraseSelfMapper, context.nonFixingMapper));
+          const constraint2 = getConstraintOfTypeParameter(inference.typeParameter);
+          if (constraint2) {
+            const instantiatedConstraint = instantiateType(constraint2, context.nonFixingMapper);
+            if (instantiatedConstraint.flags & 1048576 /* Union */ && !context.compareTypes(aggregateInference, getTypeWithThisArgument(instantiatedConstraint, aggregateInference))) {
+              const discriminantProps = findDiscriminantProperties(getPropertiesOfType(aggregateInference), instantiatedConstraint);
+              if (discriminantProps) {
+                let match;
+                findDiscriminant:
+                  for (const p of discriminantProps) {
+                    const candidatePropType = getTypeOfPropertyOfType(aggregateInference, p.escapedName);
+                    for (const type of instantiatedConstraint.types) {
+                      const propType = getTypeOfPropertyOfType(type, p.escapedName);
+                      if (propType && candidatePropType && checkTypeAssignableTo(
+                        candidatePropType,
+                        propType,
+                        /*errorNode*/
+                        void 0
+                      )) {
+                        if (match && match !== type) {
+                          match = void 0;
+                          break findDiscriminant;
+                        } else {
+                          match = type;
+                        }
+                      }
+                    }
+                  }
+                if (match) {
+                  aggregateInference = getSpreadType(
+                    match,
+                    aggregateInference,
+                    /*symbol*/
+                    void 0,
+                    /*propegatedFlags*/
+                    0,
+                    /*readonly*/
+                    false
+                  );
+                }
+              }
+            }
+          }
+          inferredType = aggregateInference;
         } else if (context.flags & 1 /* NoDefault */) {
           inferredType = silentNeverType;
         } else {
@@ -74042,25 +74096,17 @@ function createTypeChecker(host) {
         checkComputedPropertyName(elem.name);
       }
     }
-    const intraExpressionInferenceContext = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) ? getInferenceContext(node) : void 0;
     let offset = 0;
     for (const memberDecl of node.properties) {
       let member = getSymbolOfDeclaration(memberDecl);
       const computedNameType = memberDecl.name && memberDecl.name.kind === 168 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
       if (memberDecl.kind === 304 /* PropertyAssignment */ || memberDecl.kind === 305 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
-        const isIntraExpressionInferenceSource = intraExpressionInferenceContext && (memberDecl.kind === 304 /* PropertyAssignment */ || memberDecl.kind === 175 /* MethodDeclaration */) && isContextSensitive(memberDecl);
-        if (isIntraExpressionInferenceSource) {
-          pushReverseMappedTypeIntraExpressionInferenceScope(intraExpressionInferenceContext, node);
-        }
         let type = memberDecl.kind === 304 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : (
           // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring
           // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`.
           // we don't want to say "could not find 'a'".
           memberDecl.kind === 305 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode)
         );
-        if (isIntraExpressionInferenceSource) {
-          popReverseMappedTypeIntraExpressionInferenceScope(intraExpressionInferenceContext);
-        }
         if (isInJavascript) {
           const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
           if (jsDocType) {
@@ -74095,9 +74141,11 @@ function createTypeChecker(host) {
         prop.links.target = member;
         member = prop;
         allPropertiesTable == null ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
-        if (isIntraExpressionInferenceSource) {
+        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 304 /* PropertyAssignment */ || memberDecl.kind === 175 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
+          const inferenceContext = getInferenceContext(node);
+          Debug.assert(inferenceContext);
           const inferenceNode = memberDecl.kind === 304 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
-          addIntraExpressionInferenceSite(intraExpressionInferenceContext, inferenceNode, type);
+          addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
         }
       } else if (memberDecl.kind === 306 /* SpreadAssignment */) {
         if (languageVersion < LanguageFeatureMinimumTarget.ObjectAssign) {

package/lib/lib.es5.d.ts

@@ -1682,6 +1682,15 @@ type NoInfer<T> = intrinsic;
  */
 interface ThisType<T> {}
 
+/**
+ * Type instantiated to perform partial inferences from indexed accesses
+ */
+type PartialInference<T, Keys extends PropertyKey> = ({
+    [K in Keys]: {
+        [K1 in K]: T;
+    };
+})[Keys];
+
 /**
  * Stores types to be used with WeakSet, WeakMap, WeakRef, and FinalizationRegistry
  */

package/lib/typescript.js

@@ -2286,7 +2286,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "6.0";
-var version = `${versionMajorMinor}.0-insiders.20251129`;
+var version = `${versionMajorMinor}.0-insiders.20251201`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -21301,16 +21301,15 @@ function getCheckFlags(symbol) {
   return symbol.flags & 33554432 /* Transient */ ? symbol.links.checkFlags : 0;
 }
 function getDeclarationModifierFlagsFromSymbol(s, isWrite = false) {
-  const checkFlags = getCheckFlags(s);
-  if (!(checkFlags & 8192 /* ReverseMapped */) && s.valueDeclaration) {
+  if (s.valueDeclaration) {
     const declaration = isWrite && s.declarations && find(s.declarations, isSetAccessorDeclaration) || s.flags & 32768 /* GetAccessor */ && find(s.declarations, isGetAccessorDeclaration) || s.valueDeclaration;
     const flags = getCombinedModifierFlags(declaration);
     return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~7 /* AccessibilityModifier */;
   }
-  if (checkFlags & 6 /* Synthetic */) {
-    const checkFlags2 = s.links.checkFlags;
-    const accessModifier = checkFlags2 & 1024 /* ContainsPrivate */ ? 2 /* Private */ : checkFlags2 & 256 /* ContainsPublic */ ? 1 /* Public */ : 4 /* Protected */;
-    const staticModifier = checkFlags2 & 2048 /* ContainsStatic */ ? 256 /* Static */ : 0;
+  if (getCheckFlags(s) & 6 /* Synthetic */) {
+    const checkFlags = s.links.checkFlags;
+    const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 2 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 1 /* Public */ : 4 /* Protected */;
+    const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 256 /* Static */ : 0;
     return accessModifier | staticModifier;
   }
   if (s.flags & 4194304 /* Prototype */) {
@@ -51704,6 +51703,32 @@ function createTypeChecker(host) {
     emptyArray
   );
   var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
+  var allKeysUnknownType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    map(stringNumberSymbolType.types, (t) => createIndexInfo(
+      t,
+      unknownType,
+      /*isReadonly*/
+      false
+    ))
+  );
+  var allKeysAllKeysUnknownType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    map(stringNumberSymbolType.types, (t) => createIndexInfo(
+      t,
+      allKeysUnknownType,
+      /*isReadonly*/
+      false
+    ))
+  );
   var emptyGenericType = createAnonymousType(
     /*symbol*/
     void 0,
@@ -51922,6 +51947,7 @@ function createTypeChecker(host) {
   var deferredGlobalBigIntType;
   var deferredGlobalNaNSymbol;
   var deferredGlobalRecordSymbol;
+  var deferredGlobalPartialInferenceSymbol;
   var deferredGlobalClassDecoratorContextType;
   var deferredGlobalClassMethodDecoratorContextType;
   var deferredGlobalClassGetterDecoratorContextType;
@@ -62913,13 +62939,7 @@ function createTypeChecker(host) {
     const modifiers = getMappedTypeModifiers(type.mappedType);
     const readonlyMask = modifiers & 1 /* IncludeReadonly */ ? false : true;
     const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
-    const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(
-      indexInfo.type,
-      type.mappedType,
-      type.constraintType,
-      /*sourceValueDeclaration*/
-      void 0
-    ) || unknownType, readonlyMask && indexInfo.isReadonly)] : emptyArray;
+    const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType) || unknownType, readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
     const limitedConstraint = getLimitedConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
@@ -62932,18 +62952,10 @@ function createTypeChecker(host) {
       const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
       const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
       inferredProp.declarations = prop.declarations;
-      inferredProp.valueDeclaration = prop.valueDeclaration;
       inferredProp.links.nameType = getSymbolLinks(prop).nameType;
       inferredProp.links.propertyType = getTypeOfSymbol(prop);
-      if (type.constraintType.type.flags & 8388608 /* IndexedAccess */ && type.constraintType.type.objectType.flags & 262144 /* TypeParameter */ && type.constraintType.type.indexType.flags & 262144 /* TypeParameter */) {
-        const newTypeParam = type.constraintType.type.objectType;
-        const newMappedType = replaceIndexedAccess(type.mappedType, type.constraintType.type, newTypeParam);
-        inferredProp.links.mappedType = newMappedType;
-        inferredProp.links.constraintType = getIndexType(newTypeParam);
-      } else {
-        inferredProp.links.mappedType = type.mappedType;
-        inferredProp.links.constraintType = type.constraintType;
-      }
+      inferredProp.links.mappedType = type.mappedType;
+      inferredProp.links.constraintType = type.constraintType;
       members.set(prop.escapedName, inferredProp);
     }
     setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos);
@@ -65512,6 +65524,16 @@ function createTypeChecker(host) {
     ) || unknownSymbol);
     return deferredGlobalRecordSymbol === unknownSymbol ? void 0 : deferredGlobalRecordSymbol;
   }
+  function getGlobalPartialInferenceSymbol() {
+    deferredGlobalPartialInferenceSymbol || (deferredGlobalPartialInferenceSymbol = getGlobalTypeAliasSymbol(
+      "PartialInference",
+      /*arity*/
+      2,
+      /*reportErrors*/
+      false
+    ) || unknownSymbol);
+    return deferredGlobalPartialInferenceSymbol === unknownSymbol ? void 0 : deferredGlobalPartialInferenceSymbol;
+  }
   function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) {
     return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType;
   }
@@ -72743,10 +72765,7 @@ function createTypeChecker(host) {
       map(context.inferences, (i) => i.typeParameter),
       map(context.inferences, (inference, i) => () => {
         if (!inference.isFixed) {
-          if (context.intraExpressionInferenceSites) {
-            inferFromIntraExpressionSites(context.inferences, context.intraExpressionInferenceSites);
-            context.intraExpressionInferenceSites = void 0;
-          }
+          inferFromIntraExpressionSites(context);
           clearCachedInferences(context.inferences);
           inference.isFixed = true;
         }
@@ -72770,38 +72789,17 @@ function createTypeChecker(host) {
     }
   }
   function addIntraExpressionInferenceSite(context, node, type) {
-    const site = { node, type };
-    (context.intraExpressionInferenceSites ?? (context.intraExpressionInferenceSites = [])).push(site);
-    if (context.reverseMappedIntraExpressionInferenceSites) {
-      for (const reverseMappedSites of context.reverseMappedIntraExpressionInferenceSites) {
-        reverseMappedSites.push(site);
-      }
-    }
-  }
-  function pushReverseMappedTypeIntraExpressionInferenceScope(context, node) {
-    (context.reverseMappedIntraExpressionInferenceScopeNodes ?? (context.reverseMappedIntraExpressionInferenceScopeNodes = [])).push(node);
-    (context.reverseMappedIntraExpressionInferenceSites ?? (context.reverseMappedIntraExpressionInferenceSites = [])).push([]);
-  }
-  function popReverseMappedTypeIntraExpressionInferenceScope(context) {
-    context.reverseMappedIntraExpressionInferenceScopeNodes.pop();
-    context.reverseMappedIntraExpressionInferenceSites.pop();
+    (context.intraExpressionInferenceSites ?? (context.intraExpressionInferenceSites = [])).push({ node, type });
   }
-  function findReverseMappedTypeIntraExpressionInferenceScope(context, node) {
-    if (context == null ? void 0 : context.reverseMappedIntraExpressionInferenceScopeNodes) {
-      for (let i = context.reverseMappedIntraExpressionInferenceScopeNodes.length - 1; i >= 0; i--) {
-        if (context.reverseMappedIntraExpressionInferenceScopeNodes[i] === node) {
-          return i;
+  function inferFromIntraExpressionSites(context) {
+    if (context.intraExpressionInferenceSites) {
+      for (const { node, type } of context.intraExpressionInferenceSites) {
+        const contextualType = node.kind === 175 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType2(node, 2 /* NoConstraints */);
+        if (contextualType) {
+          inferTypes(context.inferences, type, contextualType);
         }
       }
-    }
-    return -1;
-  }
-  function inferFromIntraExpressionSites(inferences, intraExpressionInferenceSites) {
-    for (const { node, type } of intraExpressionInferenceSites) {
-      const contextualType = node.kind === 175 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType2(node, 2 /* NoConstraints */);
-      if (contextualType) {
-        inferTypes(inferences, type, contextualType);
-      }
+      context.intraExpressionInferenceSites = void 0;
     }
   }
   function createInferenceInfo(typeParameter) {
@@ -72813,7 +72811,8 @@ function createTypeChecker(host) {
       priority: void 0,
       topLevel: true,
       isFixed: false,
-      impliedArity: void 0
+      impliedArity: void 0,
+      indexes: void 0
     };
   }
   function cloneInferenceInfo(inference) {
@@ -72825,7 +72824,8 @@ function createTypeChecker(host) {
       priority: inference.priority,
       topLevel: inference.topLevel,
       isFixed: inference.isFixed,
-      impliedArity: inference.impliedArity
+      impliedArity: inference.impliedArity,
+      indexes: inference.indexes && inference.indexes.slice()
     };
   }
   function cloneInferredPartOfContext(context) {
@@ -72891,6 +72891,11 @@ function createTypeChecker(host) {
     );
   }
   function inferTypeForHomomorphicMappedType(source, target, constraint) {
+    if (constraint.type.flags & 8388608 /* IndexedAccess */) {
+      const newTypeParam = constraint.type.objectType;
+      target = replaceIndexedAccess(target, constraint.type, newTypeParam);
+      constraint = getIndexType(newTypeParam);
+    }
     const cacheKey = source.id + "," + target.id + "," + constraint.id;
     if (reverseHomomorphicMappedCache.has(cacheKey)) {
       return reverseHomomorphicMappedCache.get(cacheKey);
@@ -72899,31 +72904,22 @@ function createTypeChecker(host) {
     reverseHomomorphicMappedCache.set(cacheKey, type);
     return type;
   }
+  function isPartiallyInferableType(type) {
+    return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType2(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getElementTypes(type), isPartiallyInferableType);
+  }
   function createReverseMappedType(source, target, constraint) {
-    if (!getIndexInfoOfType(source, stringType) && !getPropertiesOfType(source).length) {
+    if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
       return void 0;
     }
     if (isArrayType(source)) {
-      const elementType = inferReverseMappedType(
-        getTypeArguments(source)[0],
-        target,
-        constraint,
-        /*sourceValueDeclaration*/
-        void 0
-      );
+      const elementType = inferReverseMappedType(getTypeArguments(source)[0], target, constraint);
       if (!elementType) {
         return void 0;
       }
       return createArrayType(elementType, isReadonlyArrayType(source));
     }
     if (isTupleType(source)) {
-      const elementTypes = map(getElementTypes(source), (t) => inferReverseMappedType(
-        t,
-        target,
-        constraint,
-        /*sourceValueDeclaration*/
-        void 0
-      ));
+      const elementTypes = map(getElementTypes(source), (t) => inferReverseMappedType(t, target, constraint));
       if (!every(elementTypes, (t) => !!t)) {
         return void 0;
       }
@@ -72943,39 +72939,28 @@ function createTypeChecker(host) {
   function getTypeOfReverseMappedSymbol(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
-      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType, symbol.valueDeclaration) || unknownType;
+      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType) || unknownType;
     }
     return links.type;
   }
-  function inferReverseMappedTypeWorker(sourceType, target, constraint, sourceValueDeclaration) {
-    const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
+  function inferReverseMappedTypeWorker(sourceType, target, constraint) {
+    const typeParameter = getTypeParameterFromMappedType(target);
+    const inferenceTarget = getIndexedAccessType(constraint.type, typeParameter);
     const templateType = getTemplateTypeFromMappedType(target);
-    const inference = createInferenceInfo(typeParameter);
+    const inference = createInferenceInfo(inferenceTarget);
     inferTypes([inference], sourceType, templateType);
-    if (sourceValueDeclaration && getObjectFlags(sourceType) & 262144 /* NonInferrableType */) {
-      const scopeNode = sourceValueDeclaration.parent;
-      const inferenceContext = getInferenceContext(scopeNode);
-      const index = findReverseMappedTypeIntraExpressionInferenceScope(inferenceContext, scopeNode);
-      if (index !== -1) {
-        Debug.assert(inferenceContext);
-        const intraExpressionSites = inferenceContext.reverseMappedIntraExpressionInferenceSites[index];
-        const recordSymbol = getGlobalRecordSymbol();
-        if (intraExpressionSites.length && recordSymbol) {
-          pushContextualType(
-            scopeNode,
-            getTypeAliasInstantiation(recordSymbol, [stringNumberSymbolType, templateType]),
-            /*isCache*/
-            false
-          );
-          inferFromIntraExpressionSites([inference], intraExpressionSites);
-          popContextualType();
-        }
-      }
+    const inferredType = getTypeFromInference(inference);
+    if (inferredType) {
+      return inferredType;
     }
-    return getTypeFromInference(inference) || unknownType;
+    if (inference.indexes) {
+      const eraseSelfMapper = makeArrayTypeMapper([constraint.type, typeParameter], [allKeysAllKeysUnknownType, stringNumberSymbolType]);
+      return instantiateType(getIntersectionType(inference.indexes), eraseSelfMapper);
+    }
+    return unknownType;
   }
-  function inferReverseMappedType(source, target, constraint, sourceValueDeclaration) {
-    const cacheKey = source.id + "," + target.id + "," + constraint.id + (sourceValueDeclaration && getObjectFlags(source) & 262144 /* NonInferrableType */ ? "," + getNodeId(sourceValueDeclaration) : "");
+  function inferReverseMappedType(source, target, constraint) {
+    const cacheKey = source.id + "," + target.id + "," + constraint.id;
     if (reverseMappedCache.has(cacheKey)) {
       return reverseMappedCache.get(cacheKey) || unknownType;
     }
@@ -72986,7 +72971,7 @@ function createTypeChecker(host) {
     if (isDeeplyNestedType(target, reverseMappedTargetStack, reverseMappedTargetStack.length, 2)) reverseExpandingFlags |= 2 /* Target */;
     let type;
     if (reverseExpandingFlags !== 3 /* Both */) {
-      type = inferReverseMappedTypeWorker(source, target, constraint, sourceValueDeclaration);
+      type = inferReverseMappedTypeWorker(source, target, constraint);
     }
     reverseMappedSourceStack.pop();
     reverseMappedTargetStack.pop();
@@ -73313,6 +73298,29 @@ function createTypeChecker(host) {
       } else if (source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */) {
         inferFromTypes(source.objectType, target.objectType);
         inferFromTypes(source.indexType, target.indexType);
+      } else if (!(priority & 1 /* NakedTypeVariable */) && target.flags & 8388608 /* IndexedAccess */) {
+        if (isFromInferenceBlockedSource(source)) {
+          return;
+        }
+        const inference = getInferenceInfoForType(getActualTypeVariable(target.objectType));
+        if (inference) {
+          if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
+            return;
+          }
+          if (!inference.isFixed) {
+            const partialInferenceTypeSymbol = getGlobalPartialInferenceSymbol();
+            if (partialInferenceTypeSymbol) {
+              if (target.indexType.flags & 465829888 /* Instantiable */) {
+                const recordSymbol = getGlobalRecordSymbol();
+                if (recordSymbol) {
+                  inference.indexes = append(inference.indexes, getTypeAliasInstantiation(recordSymbol, [target.indexType, source]));
+                }
+              } else {
+                inference.indexes = append(inference.indexes, getTypeAliasInstantiation(partialInferenceTypeSymbol, [source, target.indexType]));
+              }
+            }
+          }
+        }
       } else if (source.flags & 268435456 /* StringMapping */ && target.flags & 268435456 /* StringMapping */) {
         if (source.symbol === target.symbol) {
           inferFromTypes(source.type, target.type);
@@ -73506,7 +73514,7 @@ function createTypeChecker(host) {
       }
     }
     function inferToMappedType(source, target, constraintType) {
-      if (constraintType.flags & 3145728 /* UnionOrIntersection */) {
+      if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
         let result = false;
         for (const type of constraintType.types) {
           result = inferToMappedType(source, target, type) || result;
@@ -73816,6 +73824,52 @@ function createTypeChecker(host) {
           const preferCovariantType = inferredCovariantType && (!inferredContravariantType || !(inferredCovariantType.flags & (131072 /* Never */ | 1 /* Any */)) && some(inference.contraCandidates, (t) => isTypeAssignableTo(inferredCovariantType, t)) && every(context.inferences, (other) => other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeAssignableTo(t, inferredCovariantType))));
           inferredType = preferCovariantType ? inferredCovariantType : inferredContravariantType;
           fallbackType = preferCovariantType ? inferredContravariantType : inferredCovariantType;
+        } else if (inference.indexes) {
+          const eraseSelfMapper = makeUnaryTypeMapper(inference.typeParameter, allKeysUnknownType);
+          let aggregateInference = instantiateType(getIntersectionType(inference.indexes), mergeTypeMappers(eraseSelfMapper, context.nonFixingMapper));
+          const constraint2 = getConstraintOfTypeParameter(inference.typeParameter);
+          if (constraint2) {
+            const instantiatedConstraint = instantiateType(constraint2, context.nonFixingMapper);
+            if (instantiatedConstraint.flags & 1048576 /* Union */ && !context.compareTypes(aggregateInference, getTypeWithThisArgument(instantiatedConstraint, aggregateInference))) {
+              const discriminantProps = findDiscriminantProperties(getPropertiesOfType(aggregateInference), instantiatedConstraint);
+              if (discriminantProps) {
+                let match;
+                findDiscriminant:
+                  for (const p of discriminantProps) {
+                    const candidatePropType = getTypeOfPropertyOfType(aggregateInference, p.escapedName);
+                    for (const type of instantiatedConstraint.types) {
+                      const propType = getTypeOfPropertyOfType(type, p.escapedName);
+                      if (propType && candidatePropType && checkTypeAssignableTo(
+                        candidatePropType,
+                        propType,
+                        /*errorNode*/
+                        void 0
+                      )) {
+                        if (match && match !== type) {
+                          match = void 0;
+                          break findDiscriminant;
+                        } else {
+                          match = type;
+                        }
+                      }
+                    }
+                  }
+                if (match) {
+                  aggregateInference = getSpreadType(
+                    match,
+                    aggregateInference,
+                    /*symbol*/
+                    void 0,
+                    /*propegatedFlags*/
+                    0,
+                    /*readonly*/
+                    false
+                  );
+                }
+              }
+            }
+          }
+          inferredType = aggregateInference;
         } else if (context.flags & 1 /* NoDefault */) {
           inferredType = silentNeverType;
         } else {
@@ -78670,25 +78724,17 @@ function createTypeChecker(host) {
         checkComputedPropertyName(elem.name);
       }
     }
-    const intraExpressionInferenceContext = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) ? getInferenceContext(node) : void 0;
     let offset = 0;
     for (const memberDecl of node.properties) {
       let member = getSymbolOfDeclaration(memberDecl);
       const computedNameType = memberDecl.name && memberDecl.name.kind === 168 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
       if (memberDecl.kind === 304 /* PropertyAssignment */ || memberDecl.kind === 305 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
-        const isIntraExpressionInferenceSource = intraExpressionInferenceContext && (memberDecl.kind === 304 /* PropertyAssignment */ || memberDecl.kind === 175 /* MethodDeclaration */) && isContextSensitive(memberDecl);
-        if (isIntraExpressionInferenceSource) {
-          pushReverseMappedTypeIntraExpressionInferenceScope(intraExpressionInferenceContext, node);
-        }
         let type = memberDecl.kind === 304 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : (
           // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring
           // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`.
           // we don't want to say "could not find 'a'".
           memberDecl.kind === 305 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode)
         );
-        if (isIntraExpressionInferenceSource) {
-          popReverseMappedTypeIntraExpressionInferenceScope(intraExpressionInferenceContext);
-        }
         if (isInJavascript) {
           const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
           if (jsDocType) {
@@ -78723,9 +78769,11 @@ function createTypeChecker(host) {
         prop.links.target = member;
         member = prop;
         allPropertiesTable == null ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
-        if (isIntraExpressionInferenceSource) {
+        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 304 /* PropertyAssignment */ || memberDecl.kind === 175 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
+          const inferenceContext = getInferenceContext(node);
+          Debug.assert(inferenceContext);
           const inferenceNode = memberDecl.kind === 304 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
-          addIntraExpressionInferenceSite(intraExpressionInferenceContext, inferenceNode, type);
+          addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
         }
       } else if (memberDecl.kind === 306 /* SpreadAssignment */) {
         if (languageVersion < LanguageFeatureMinimumTarget.ObjectAssign) {

package/package.json

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