@typescript-deploys/pr-build 6.0.0-pr-56300-12 → 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 = [];
@@ -47075,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,
@@ -47293,6 +47319,7 @@ function createTypeChecker(host) {
   var deferredGlobalBigIntType;
   var deferredGlobalNaNSymbol;
   var deferredGlobalRecordSymbol;
+  var deferredGlobalPartialInferenceSymbol;
   var deferredGlobalClassDecoratorContextType;
   var deferredGlobalClassMethodDecoratorContextType;
   var deferredGlobalClassGetterDecoratorContextType;
@@ -58284,7 +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, type.inferenceConstraintType && getIndexedAccessTypeOrUndefined(type.inferenceConstraintType, indexInfo.keyType)) ?? 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)) {
@@ -58299,16 +58326,8 @@ function createTypeChecker(host) {
       inferredProp.declarations = prop.declarations;
       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.inferenceConstraintType = type.inferenceConstraintType;
+      inferredProp.links.mappedType = type.mappedType;
+      inferredProp.links.constraintType = type.constraintType;
       members.set(prop.escapedName, inferredProp);
     }
     setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos);
@@ -60877,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;
   }
@@ -68154,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) {
@@ -68166,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) {
@@ -68232,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);
@@ -68275,20 +68311,28 @@ function createTypeChecker(host) {
   function getTypeOfReverseMappedSymbol(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
-      const reverseConstraint = symbol.links.inferenceConstraintType && getIndexedAccessTypeOrUndefined(symbol.links.inferenceConstraintType, getStringLiteralType(unescapeLeadingUnderscores(symbol.escapedName)));
-      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType, reverseConstraint) ?? unknownType;
+      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType) || unknownType;
     }
     return links.type;
   }
-  function inferReverseMappedTypeWorker(sourceType, target, constraint, reverseMappedConstraint) {
-    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);
-    return getTypeFromInference(inference) ?? reverseMappedConstraint ?? unknownType;
+    const inferredType = getTypeFromInference(inference);
+    if (inferredType) {
+      return inferredType;
+    }
+    if (inference.indexes) {
+      const eraseSelfMapper = makeArrayTypeMapper([constraint.type, typeParameter], [allKeysAllKeysUnknownType, stringNumberSymbolType]);
+      return instantiateType(getIntersectionType(inference.indexes), eraseSelfMapper);
+    }
+    return unknownType;
   }
-  function inferReverseMappedType(source, target, constraint, reverseMappedConstraint) {
-    const cacheKey = source.id + "," + target.id + "," + constraint.id + "," + ((reverseMappedConstraint == null ? void 0 : reverseMappedConstraint.id) ?? "0");
+  function inferReverseMappedType(source, target, constraint) {
+    const cacheKey = source.id + "," + target.id + "," + constraint.id;
     if (reverseMappedCache.has(cacheKey)) {
       return reverseMappedCache.get(cacheKey) || unknownType;
     }
@@ -68299,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, reverseMappedConstraint);
+      type = inferReverseMappedTypeWorker(source, target, constraint);
     }
     reverseMappedSourceStack.pop();
     reverseMappedTargetStack.pop();
@@ -68626,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);
@@ -69129,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 {
@@ -69144,39 +69257,13 @@ function createTypeChecker(host) {
       const constraint = getConstraintOfTypeParameter(inference.typeParameter);
       if (constraint) {
         const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
-        inferredType = cloneWithInferenceConstraintIfNeeded(inferredType, instantiatedConstraint);
-        if (inferredType) {
-          inference.inferredType = inferredType;
-        }
         if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
-          fallbackType = cloneWithInferenceConstraintIfNeeded(fallbackType, instantiatedConstraint);
           inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
         }
       }
       clearActiveMapperCaches();
     }
     return inference.inferredType;
-    function cloneWithInferenceConstraintIfNeeded(type, inferenceConstraintType) {
-      if (!type || !(type.flags & 524288 /* Object */) || !(type.objectFlags & 1024 /* ReverseMapped */)) {
-        return type;
-      }
-      const reversed = type;
-      const cacheKey = reversed.source.id + "," + reversed.mappedType.id + "," + reversed.constraintType.id + "," + inferenceConstraintType.id;
-      if (reverseHomomorphicMappedCache.has(cacheKey)) {
-        return reverseHomomorphicMappedCache.get(cacheKey);
-      }
-      const clone = createObjectType(
-        1024 /* ReverseMapped */ | 16 /* Anonymous */,
-        /*symbol*/
-        void 0
-      );
-      clone.source = reversed.source;
-      clone.mappedType = reversed.mappedType;
-      clone.constraintType = reversed.constraintType;
-      clone.inferenceConstraintType = inferenceConstraintType;
-      reverseHomomorphicMappedCache.set(cacheKey, clone);
-      return clone;
-    }
   }
   function getDefaultTypeArgumentType(isInJavaScriptFile) {
     return isInJavaScriptFile ? anyType : unknownType;

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";
@@ -51703,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,
@@ -51921,6 +51947,7 @@ function createTypeChecker(host) {
   var deferredGlobalBigIntType;
   var deferredGlobalNaNSymbol;
   var deferredGlobalRecordSymbol;
+  var deferredGlobalPartialInferenceSymbol;
   var deferredGlobalClassDecoratorContextType;
   var deferredGlobalClassMethodDecoratorContextType;
   var deferredGlobalClassGetterDecoratorContextType;
@@ -62912,7 +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, type.inferenceConstraintType && getIndexedAccessTypeOrUndefined(type.inferenceConstraintType, indexInfo.keyType)) ?? 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)) {
@@ -62927,16 +62954,8 @@ function createTypeChecker(host) {
       inferredProp.declarations = prop.declarations;
       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.inferenceConstraintType = type.inferenceConstraintType;
+      inferredProp.links.mappedType = type.mappedType;
+      inferredProp.links.constraintType = type.constraintType;
       members.set(prop.escapedName, inferredProp);
     }
     setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos);
@@ -65505,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;
   }
@@ -72782,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) {
@@ -72794,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) {
@@ -72860,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);
@@ -72903,20 +72939,28 @@ function createTypeChecker(host) {
   function getTypeOfReverseMappedSymbol(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
-      const reverseConstraint = symbol.links.inferenceConstraintType && getIndexedAccessTypeOrUndefined(symbol.links.inferenceConstraintType, getStringLiteralType(unescapeLeadingUnderscores(symbol.escapedName)));
-      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType, reverseConstraint) ?? unknownType;
+      links.type = inferReverseMappedType(symbol.links.propertyType, symbol.links.mappedType, symbol.links.constraintType) || unknownType;
     }
     return links.type;
   }
-  function inferReverseMappedTypeWorker(sourceType, target, constraint, reverseMappedConstraint) {
-    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);
-    return getTypeFromInference(inference) ?? reverseMappedConstraint ?? unknownType;
+    const inferredType = getTypeFromInference(inference);
+    if (inferredType) {
+      return inferredType;
+    }
+    if (inference.indexes) {
+      const eraseSelfMapper = makeArrayTypeMapper([constraint.type, typeParameter], [allKeysAllKeysUnknownType, stringNumberSymbolType]);
+      return instantiateType(getIntersectionType(inference.indexes), eraseSelfMapper);
+    }
+    return unknownType;
   }
-  function inferReverseMappedType(source, target, constraint, reverseMappedConstraint) {
-    const cacheKey = source.id + "," + target.id + "," + constraint.id + "," + ((reverseMappedConstraint == null ? void 0 : reverseMappedConstraint.id) ?? "0");
+  function inferReverseMappedType(source, target, constraint) {
+    const cacheKey = source.id + "," + target.id + "," + constraint.id;
     if (reverseMappedCache.has(cacheKey)) {
       return reverseMappedCache.get(cacheKey) || unknownType;
     }
@@ -72927,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, reverseMappedConstraint);
+      type = inferReverseMappedTypeWorker(source, target, constraint);
     }
     reverseMappedSourceStack.pop();
     reverseMappedTargetStack.pop();
@@ -73254,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);
@@ -73757,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 {
@@ -73772,39 +73885,13 @@ function createTypeChecker(host) {
       const constraint = getConstraintOfTypeParameter(inference.typeParameter);
       if (constraint) {
         const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
-        inferredType = cloneWithInferenceConstraintIfNeeded(inferredType, instantiatedConstraint);
-        if (inferredType) {
-          inference.inferredType = inferredType;
-        }
         if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
-          fallbackType = cloneWithInferenceConstraintIfNeeded(fallbackType, instantiatedConstraint);
           inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
         }
       }
       clearActiveMapperCaches();
     }
     return inference.inferredType;
-    function cloneWithInferenceConstraintIfNeeded(type, inferenceConstraintType) {
-      if (!type || !(type.flags & 524288 /* Object */) || !(type.objectFlags & 1024 /* ReverseMapped */)) {
-        return type;
-      }
-      const reversed = type;
-      const cacheKey = reversed.source.id + "," + reversed.mappedType.id + "," + reversed.constraintType.id + "," + inferenceConstraintType.id;
-      if (reverseHomomorphicMappedCache.has(cacheKey)) {
-        return reverseHomomorphicMappedCache.get(cacheKey);
-      }
-      const clone2 = createObjectType(
-        1024 /* ReverseMapped */ | 16 /* Anonymous */,
-        /*symbol*/
-        void 0
-      );
-      clone2.source = reversed.source;
-      clone2.mappedType = reversed.mappedType;
-      clone2.constraintType = reversed.constraintType;
-      clone2.inferenceConstraintType = inferenceConstraintType;
-      reverseHomomorphicMappedCache.set(cacheKey, clone2);
-      return clone2;
-    }
   }
   function getDefaultTypeArgumentType(isInJavaScriptFile) {
     return isInJavaScriptFile ? anyType : unknownType;

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-56300-12",
+  "version": "6.0.0-pr-53017-28",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [