@typescript-deploys/pr-build 5.1.0-pr-54072-11 → 5.1.0-pr-54112-10

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230501`;
+var version = `${versionMajorMinor}.0-insiders.20230503`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -44003,7 +44003,7 @@ function createTypeChecker(host) {
       return true;
     }
     if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
-      if (getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
+      if (getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ && useDefineForClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
         return !isPropertyImmediatelyReferencedWithinDeclaration(
           declaration,
           usage,
@@ -49693,7 +49693,7 @@ function createTypeChecker(host) {
         context.enclosingDeclaration = originalDecl || oldEnclosing;
         const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
         const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
-        const classType = getDeclaredTypeOfClassOrInterface(symbol);
+        const classType = getTypeWithThisArgument(getDeclaredTypeOfClassOrInterface(symbol));
         const baseTypes = getBaseTypes(classType);
         const originalImplements = originalDecl && getEffectiveImplementsTypeNodes(originalDecl);
         const implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements) || mapDefined(getImplementsTypes(classType), serializeImplementedType);
@@ -50885,18 +50885,18 @@ function createTypeChecker(host) {
       } else {
         const name = declaration.propertyName || declaration.name;
         const indexType = getLiteralTypeFromPropertyName(name);
-        const declaredType = getIndexedAccessType(parentType, indexType, 32 /* ExpressionPosition */, name);
+        const declaredType = getIndexedAccessType(parentType, indexType, 64 /* ExpressionPosition */, name);
         type = getFlowTypeOfDestructuring(declaration, declaredType);
       }
     } else {
       const elementType = checkIteratedTypeOrElementType(65 /* Destructuring */ | (declaration.dotDotDotToken ? 0 : 128 /* PossiblyOutOfBounds */), parentType, undefinedType, pattern);
       const index = pattern.elements.indexOf(declaration);
       if (declaration.dotDotDotToken) {
-        const baseConstraint = getBaseConstraintOrType(parentType);
+        const baseConstraint = mapType(parentType, (t) => t.flags & 58982400 /* InstantiableNonPrimitive */ ? getBaseConstraintOrType(t) : t);
         type = everyType(baseConstraint, isTupleType) ? mapType(baseConstraint, (t) => sliceTupleType(t, index)) : createArrayType(elementType);
       } else if (isArrayLikeType(parentType)) {
         const indexType = getNumberLiteralType(index);
-        const accessFlags = 32 /* ExpressionPosition */ | (hasDefaultValue(declaration) ? 16 /* NoTupleBoundsCheck */ : 0);
+        const accessFlags = 64 /* ExpressionPosition */ | (hasDefaultValue(declaration) ? 32 /* NoTupleBoundsCheck */ : 0);
         const declaredType = getIndexedAccessTypeOrUndefined(parentType, indexType, accessFlags, declaration.name) || errorType;
         type = getFlowTypeOfDestructuring(declaration, declaredType);
       } else {
@@ -52620,6 +52620,9 @@ function createTypeChecker(host) {
     }
     return needApparentType ? getApparentType(type) : type;
   }
+  function getThisArgument(type) {
+    return getObjectFlags(type) & 4 /* Reference */ && length(getTypeArguments(type)) > getTypeReferenceArity(type) ? last(getTypeArguments(type)) : type;
+  }
   function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
     let mapper;
     let members;
@@ -52750,7 +52753,7 @@ function createTypeChecker(host) {
     }
     return [sig.parameters];
     function expandSignatureParametersWithTupleMembers(restType, restIndex) {
-      const elementTypes = getTypeArguments(restType);
+      const elementTypes = getElementTypes(restType);
       const associatedNames = getUniqAssociatedNamesFromTupleType(restType);
       const restParams = map(elementTypes, (t, i) => {
         const name = associatedNames && associatedNames[i] ? associatedNames[i] : getParameterNameAtPosition(sig, restIndex + i, restType);
@@ -53566,7 +53569,7 @@ function createTypeChecker(host) {
   }
   function isConstTypeVariable(type) {
     var _a;
-    return !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, isConstTypeVariable) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type)) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType) || isGenericTupleType(type) && findIndex(getTypeArguments(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t)) >= 0));
+    return !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, isConstTypeVariable) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type)) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t)) >= 0));
   }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -53668,7 +53671,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function getBaseConstraintOfType(type) {
-    if (type.flags & (58982400 /* InstantiableNonPrimitive */ | 3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) {
+    if (type.flags & (58982400 /* InstantiableNonPrimitive */ | 3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || isGenericTupleType(type)) {
       const constraint = getResolvedBaseConstraint(type);
       return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : void 0;
     }
@@ -53685,7 +53688,7 @@ function createTypeChecker(host) {
       return type.resolvedBaseConstraint;
     }
     const stack = [];
-    return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type);
+    return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), getThisArgument(type));
     function getImmediateBaseConstraint(t) {
       if (!t.immediateBaseConstraint) {
         if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) {
@@ -53775,6 +53778,13 @@ function createTypeChecker(host) {
       if (t.flags & 33554432 /* Substitution */) {
         return getBaseConstraint(getSubstitutionIntersection(t));
       }
+      if (isGenericTupleType(t)) {
+        const newElements = map(getElementTypes(t), (v, i) => {
+          const constraint = t.target.elementFlags[i] & 8 /* Variadic */ && getBaseConstraint(v) || v;
+          return constraint && everyType(constraint, (c) => isArrayOrTupleType(c) && !isGenericTupleType(c)) ? constraint : v;
+        });
+        return createTupleType(newElements, t.target.elementFlags, t.target.readonly, t.target.labeledElementDeclarations);
+      }
       return t;
     }
   }
@@ -55829,7 +55839,7 @@ function createTypeChecker(host) {
         if (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type)) {
           addElement(type, 8 /* Variadic */, (_a = target.labeledElementDeclarations) == null ? void 0 : _a[i]);
         } else if (isTupleType(type)) {
-          const elements = getTypeArguments(type);
+          const elements = getElementTypes(type);
           if (elements.length + expandedTypes.length >= 1e4) {
             error(currentNode, isPartOfTypeNode(currentNode) ? Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent : Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent);
             return errorType;
@@ -55907,6 +55917,11 @@ function createTypeChecker(host) {
   function getEndElementCount(type, flags) {
     return type.elementFlags.length - findLastIndex(type.elementFlags, (f) => !(f & flags)) - 1;
   }
+  function getElementTypes(type) {
+    const typeArguments = getTypeArguments(type);
+    const arity = getTypeReferenceArity(type);
+    return typeArguments.length === arity ? typeArguments : typeArguments.slice(0, arity);
+  }
   function getTypeFromOptionalTypeNode(node) {
     return addOptionality(
       getTypeFromTypeNode(node.type),
@@ -56750,12 +56765,12 @@ function createTypeChecker(host) {
     const accessExpression = accessNode && accessNode.kind === 211 /* ElementAccessExpression */ ? accessNode : void 0;
     const propName = accessNode && isPrivateIdentifier(accessNode) ? void 0 : getPropertyNameFromIndex(indexType, accessNode);
     if (propName !== void 0) {
-      if (accessFlags & 256 /* Contextual */) {
+      if (accessFlags & 512 /* Contextual */) {
         return getTypeOfPropertyOfContextualType(objectType, propName) || anyType;
       }
       const prop = getPropertyOfType(objectType, propName);
       if (prop) {
-        if (accessFlags & 64 /* ReportDeprecated */ && accessNode && prop.declarations && isDeprecatedSymbol(prop) && isUncalledFunctionReference(accessNode, prop)) {
+        if (accessFlags & 128 /* ReportDeprecated */ && accessNode && prop.declarations && isDeprecatedSymbol(prop) && isUncalledFunctionReference(accessNode, prop)) {
           const deprecatedNode = (accessExpression == null ? void 0 : accessExpression.argumentExpression) ?? (isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode);
           addDeprecatedSuggestion(deprecatedNode, prop.declarations, propName);
         }
@@ -56765,7 +56780,7 @@ function createTypeChecker(host) {
             error(accessExpression.argumentExpression, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop));
             return void 0;
           }
-          if (accessFlags & 8 /* CacheSymbol */) {
+          if (accessFlags & 16 /* CacheSymbol */) {
             getNodeLinks(accessNode).resolvedSymbol = prop;
           }
           if (isThisPropertyAccessInConstructor(accessExpression, prop)) {
@@ -56777,7 +56792,7 @@ function createTypeChecker(host) {
       }
       if (everyType(objectType, isTupleType) && isNumericLiteralName(propName)) {
         const index = +propName;
-        if (accessNode && everyType(objectType, (t) => !t.target.hasRestElement) && !(accessFlags & 16 /* NoTupleBoundsCheck */)) {
+        if (accessNode && everyType(objectType, (t) => !t.target.hasRestElement) && !(accessFlags & 32 /* NoTupleBoundsCheck */)) {
           const indexNode = getIndexNodeForAccessExpression(accessNode);
           if (isTupleType(objectType)) {
             if (index < 0) {
@@ -56810,7 +56825,7 @@ function createTypeChecker(host) {
       }
       const indexInfo = getApplicableIndexInfo(objectType, indexType) || getIndexInfoOfType(objectType, stringType);
       if (indexInfo) {
-        if (accessFlags & 2 /* NoIndexSignatures */ && indexInfo.keyType !== numberType) {
+        if (accessFlags & 4 /* NoIndexSignatures */ && indexInfo.keyType !== numberType) {
           if (accessExpression) {
             error(accessExpression, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType));
           }
@@ -56847,7 +56862,7 @@ function createTypeChecker(host) {
         }
         if (objectType.symbol === globalThisSymbol && propName !== void 0 && globalThisSymbol.exports.has(propName) && globalThisSymbol.exports.get(propName).flags & 418 /* BlockScoped */) {
           error(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(propName), typeToString(objectType));
-        } else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !(accessFlags & 128 /* SuppressNoImplicitAnyError */)) {
+        } else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !(accessFlags & 256 /* SuppressNoImplicitAnyError */)) {
           if (propName !== void 0 && typeHasStaticProperty(propName, objectType)) {
             const typeName = typeToString(objectType);
             error(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "[" + getTextOfNode(accessExpression.argumentExpression) + "]");
@@ -57083,13 +57098,13 @@ function createTypeChecker(host) {
     if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
       indexType = stringType;
     }
-    if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */)
+    if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 64 /* ExpressionPosition */)
       accessFlags |= 1 /* IncludeUndefined */;
-    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 198 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)) || isGenericReducibleType(objectType))) {
+    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 198 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)) || !(accessFlags & 2 /* ResolveReducibleTypes */) && isGenericReducibleType(objectType))) {
       if (objectType.flags & 3 /* AnyOrUnknown */) {
         return objectType;
       }
-      const persistentAccessFlags = accessFlags & 1 /* Persistent */;
+      const persistentAccessFlags = accessFlags & 3 /* Persistent */;
       const id = objectType.id + "," + indexType.id + "," + persistentAccessFlags + getAliasId(aliasSymbol, aliasTypeArguments);
       let type = indexedAccessTypes.get(id);
       if (!type) {
@@ -57102,7 +57117,7 @@ function createTypeChecker(host) {
       const propTypes = [];
       let wasMissingProp = false;
       for (const t of indexType.types) {
-        const propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, accessNode, accessFlags | (wasMissingProp ? 128 /* SuppressNoImplicitAnyError */ : 0));
+        const propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, accessNode, accessFlags | (wasMissingProp ? 256 /* SuppressNoImplicitAnyError */ : 0));
         if (propType) {
           propTypes.push(propType);
         } else if (!accessNode) {
@@ -57114,9 +57129,9 @@ function createTypeChecker(host) {
       if (wasMissingProp) {
         return void 0;
       }
-      return accessFlags & 4 /* Writing */ ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments) : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+      return accessFlags & 8 /* Writing */ ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments) : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments);
     }
-    return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 8 /* CacheSymbol */ | 64 /* ReportDeprecated */);
+    return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 16 /* CacheSymbol */ | 128 /* ReportDeprecated */);
   }
   function getTypeFromIndexedAccessTypeNode(node) {
     const links = getNodeLinks(node);
@@ -57157,7 +57172,7 @@ function createTypeChecker(host) {
     return isTupleTypeNode(node) && length(node.elements) > 0 && !some(node.elements, (e) => isOptionalTypeNode(e) || isRestTypeNode(e) || isNamedTupleMember(e) && !!(e.questionToken || e.dotDotDotToken));
   }
   function isDeferredType(type, checkTuples) {
-    return isGenericType(type) || checkTuples && isTupleType(type) && some(getTypeArguments(type), isGenericType);
+    return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
   function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
     let result;
@@ -58092,7 +58107,7 @@ function createTypeChecker(host) {
   }
   function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) {
     const elementFlags = tupleType.target.elementFlags;
-    const elementTypes = map(getTypeArguments(tupleType), (t, i) => {
+    const elementTypes = map(getElementTypes(tupleType), (t, i) => {
       const singleton = elementFlags[i] & 8 /* Variadic */ ? t : elementFlags[i] & 4 /* Rest */ ? createArrayType(t) : createTupleType([t], [elementFlags[i]]);
       return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
     });
@@ -58111,7 +58126,7 @@ function createTypeChecker(host) {
   }
   function instantiateMappedTupleType(tupleType, mappedType, mapper) {
     const elementFlags = tupleType.target.elementFlags;
-    const elementTypes = map(getTypeArguments(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* Optional */), mapper));
+    const elementTypes = map(getElementTypes(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* Optional */), mapper));
     const modifiers = getMappedTypeModifiers(mappedType);
     const newTupleModifiers = modifiers & 4 /* IncludeOptional */ ? map(elementFlags, (f) => f & 1 /* Required */ ? 2 /* Optional */ : f) : modifiers & 8 /* ExcludeOptional */ ? map(elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : elementFlags;
     const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
@@ -59297,7 +59312,7 @@ function createTypeChecker(host) {
     return type;
   }
   function getNormalizedTupleType(type, writing) {
-    const elements = getTypeArguments(type);
+    const elements = getElementTypes(type);
     const normalizedElements = sameMap(elements, (t) => t.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(t, writing) : t);
     return elements !== normalizedElements ? createNormalizedTupleType(type.target, normalizedElements) : type;
   }
@@ -59586,6 +59601,8 @@ function createTypeChecker(host) {
       return isRelatedTo(source2, target2, 3 /* Both */, reportErrors2);
     }
     function isRelatedTo(originalSource, originalTarget, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2, intersectionState = 0 /* None */) {
+      if (originalSource === originalTarget)
+        return -1 /* True */;
       if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 402784252 /* Primitive */) {
         if (relation === comparableRelation && !(originalTarget.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(originalTarget, originalSource, relation) || isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors2 ? reportError : void 0)) {
           return -1 /* True */;
@@ -60537,7 +60554,7 @@ function createTypeChecker(host) {
           const baseObjectType = getBaseConstraintOfType(objectType) || objectType;
           const baseIndexType = getBaseConstraintOfType(indexType) || indexType;
           if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) {
-            const accessFlags = 4 /* Writing */ | (baseObjectType !== objectType ? 2 /* NoIndexSignatures */ : 0);
+            const accessFlags = 8 /* Writing */ | (baseObjectType !== objectType ? 4 /* NoIndexSignatures */ : 0);
             const constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, accessFlags);
             if (constraint) {
               if (reportErrors2 && originalErrorInfo) {
@@ -60804,6 +60821,11 @@ function createTypeChecker(host) {
           } else {
             return 0 /* False */;
           }
+        } else if (isGenericTupleType(source2) && isTupleType(target2) && !isGenericTupleType(target2)) {
+          const constraint = getBaseConstraintOrType(source2);
+          if (constraint !== source2) {
+            return isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2);
+          }
         } else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 8192 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
           return 0 /* False */;
         }
@@ -62719,7 +62741,7 @@ function createTypeChecker(host) {
     return type;
   }
   function isPartiallyInferableType(type) {
-    return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getTypeArguments(type), isPartiallyInferableType);
+    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 !== 0 && isPartiallyInferableType(source))) {
@@ -62729,7 +62751,7 @@ function createTypeChecker(host) {
       return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source));
     }
     if (isTupleType(source)) {
-      const elementTypes = map(getTypeArguments(source), (t) => inferReverseMappedType(t, target, constraint));
+      const elementTypes = map(getElementTypes(source), (t) => inferReverseMappedType(t, target, constraint));
       const elementFlags = getMappedTypeModifiers(target) & 4 /* IncludeOptional */ ? sameMap(source.target.elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : source.target.elementFlags;
       return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations);
     }
@@ -63058,6 +63080,12 @@ function createTypeChecker(host) {
             }
           }
         }
+        if (target.flags & 8388608 /* IndexedAccess */ && isGenericReducibleType(target.objectType)) {
+          const instantiated = getIndexedAccessType(target.objectType, target.indexType, 2 /* ResolveReducibleTypes */);
+          if (instantiated && instantiated !== target) {
+            inferFromTypes(source, instantiated);
+          }
+        }
       }
       if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target)) && !(source.node && target.node)) {
         inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
@@ -63570,7 +63598,7 @@ function createTypeChecker(host) {
         const inferredCovariantType = inference.candidates ? getCovariantInference(inference, context.signature) : void 0;
         const inferredContravariantType = inference.contraCandidates ? getContravariantInference(inference) : void 0;
         if (inferredCovariantType || inferredContravariantType) {
-          const preferCovariantType = inferredCovariantType && (!inferredContravariantType || !(inferredCovariantType.flags & 131072 /* Never */) && every(inference.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType)) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) && every(context.inferences, (other) => other === inference || getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType))));
+          const preferCovariantType = inferredCovariantType && (!inferredContravariantType || !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) && every(context.inferences, (other) => other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType))));
           inferredType = preferCovariantType ? inferredCovariantType : inferredContravariantType;
           fallbackType = preferCovariantType ? inferredContravariantType : inferredCovariantType;
         } else if (context.flags & 1 /* NoDefault */) {
@@ -66583,7 +66611,7 @@ function createTypeChecker(host) {
       return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
     }
     const restIndex = signature.parameters.length - 1;
-    return signatureHasRestParameter(signature) && argIndex >= restIndex ? getIndexedAccessType(getTypeOfSymbol(signature.parameters[restIndex]), getNumberLiteralType(argIndex - restIndex), 256 /* Contextual */) : getTypeAtPosition(signature, argIndex);
+    return signatureHasRestParameter(signature) && argIndex >= restIndex ? getIndexedAccessType(getTypeOfSymbol(signature.parameters[restIndex]), getNumberLiteralType(argIndex - restIndex), 512 /* Contextual */) : getTypeAtPosition(signature, argIndex);
   }
   function getContextualTypeForDecorator(decorator) {
     const signature = getDecoratorCallSignature(decorator);
@@ -69264,7 +69292,7 @@ function createTypeChecker(host) {
       return errorType;
     }
     const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
-    const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
+    const accessFlags = isAssignmentTarget(node) ? 8 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 4 /* NoIndexSignatures */ : 0) : 64 /* ExpressionPosition */;
     const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
     return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
   }
@@ -69510,7 +69538,7 @@ function createTypeChecker(host) {
   }
   function getMutableArrayOrTupleType(type) {
     return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(
-      getTypeArguments(type),
+      getElementTypes(type),
       type.target.elementFlags,
       /*readonly*/
       false,
@@ -69544,7 +69572,7 @@ function createTypeChecker(host) {
           flags.push(4 /* Rest */);
         }
       } else {
-        const contextualType = isTupleType(restType) ? getContextualTypeForElementExpression(restType, i - index, argCount - index) || unknownType : getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
+        const contextualType = isTupleType(restType) ? getContextualTypeForElementExpression(restType, i - index, argCount - index) || unknownType : getIndexedAccessType(restType, getNumberLiteralType(i - index), 512 /* Contextual */);
         const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
         const hasPrimitiveContextualType = inConstContext || maybeTypeOfKind(contextualType, 402784252 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
         types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
@@ -69824,7 +69852,7 @@ function createTypeChecker(host) {
         const arg = args[i];
         const spreadType = arg.kind === 229 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
         if (spreadType && isTupleType(spreadType)) {
-          forEach(getTypeArguments(spreadType), (t, i2) => {
+          forEach(getElementTypes(spreadType), (t, i2) => {
             var _a;
             const flags = spreadType.target.elementFlags[i2];
             const syntheticArg = createSyntheticExpression(
@@ -72929,7 +72957,7 @@ function createTypeChecker(host) {
           );
         }
       }
-      const elementType = getIndexedAccessType(objectLiteralType, exprType, 32 /* ExpressionPosition */, name);
+      const elementType = getIndexedAccessType(objectLiteralType, exprType, 64 /* ExpressionPosition */, name);
       const type = getFlowTypeOfDestructuring(property, elementType);
       return checkDestructuringAssignment(property.kind === 303 /* ShorthandPropertyAssignment */ ? property : property.initializer, type);
     } else if (property.kind === 304 /* SpreadAssignment */) {
@@ -72978,7 +73006,7 @@ function createTypeChecker(host) {
       if (element.kind !== 229 /* SpreadElement */) {
         const indexType = getNumberLiteralType(elementIndex);
         if (isArrayLikeType(sourceType)) {
-          const accessFlags = 32 /* ExpressionPosition */ | (hasDefaultValue(element) ? 16 /* NoTupleBoundsCheck */ : 0);
+          const accessFlags = 64 /* ExpressionPosition */ | (hasDefaultValue(element) ? 32 /* NoTupleBoundsCheck */ : 0);
           const elementType2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, accessFlags, createSyntheticExpression(element, indexType)) || errorType;
           const assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType2, 524288 /* NEUndefined */) : elementType2;
           const type = getFlowTypeOfDestructuring(element, assignedType);
@@ -73818,7 +73846,7 @@ function createTypeChecker(host) {
   }
   function padTupleType(type, pattern) {
     const patternElements = pattern.elements;
-    const elementTypes = getTypeArguments(type).slice();
+    const elementTypes = getElementTypes(type).slice();
     const elementFlags = type.target.elementFlags.slice();
     for (let i = getTypeReferenceArity(type); i < patternElements.length; i++) {
       const e = patternElements[i];