@zzzen/pyright-internal 1.2.0-dev.20240721 → 1.2.0-dev.20240728

package/dist/analyzer/patternMatching.js

@@ -110,6 +110,7 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
         let isPlausibleMatch = true;
         let isDefiniteMatch = true;
         const narrowedEntryTypes = [];
+        const unnarrowedEntryTypes = [];
         let canNarrowTuple = entry.isTuple;
         // Don't attempt to narrow tuples in the negative case if the subject
         // contains indeterminate-length entries or the tuple is of indeterminate
@@ -118,8 +119,8 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
             if (entry.isIndeterminateLength) {
                 canNarrowTuple = false;
             }
-            if ((0, types_1.isClassInstance)(entry.subtype) && entry.subtype.priv.tupleTypeArguments) {
-                const unboundedIndex = entry.subtype.priv.tupleTypeArguments.findIndex((typeArg) => typeArg.isUnbounded);
+            if ((0, types_1.isClassInstance)(entry.subtype) && entry.subtype.priv.tupleTypeArgs) {
+                const unboundedIndex = entry.subtype.priv.tupleTypeArgs.findIndex((typeArg) => typeArg.isUnbounded);
                 if (unboundedIndex >= 0) {
                     // If the pattern includes a "star" entry that aligns exactly with
                     // the corresponding unbounded entry in the tuple, we can narrow
@@ -138,18 +139,19 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
                 isDefiniteMatch = false;
             }
         }
-        let negativeEntriesNarrowed = 0;
+        const negativeNarrowedDims = [];
         pattern.d.entries.forEach((sequenceEntry, index) => {
             const entryType = getTypeOfPatternSequenceEntry(evaluator, pattern, entry, index, pattern.d.entries.length, pattern.d.starEntryIndex, 
             /* unpackStarEntry */ true);
+            unnarrowedEntryTypes.push(entryType);
             const narrowedEntryType = narrowTypeBasedOnPattern(evaluator, entryType, sequenceEntry, isPositiveTest);
             if (isPositiveTest) {
                 if (index === pattern.d.starEntryIndex) {
                     if ((0, types_1.isClassInstance)(narrowedEntryType) &&
-                        narrowedEntryType.priv.tupleTypeArguments &&
+                        narrowedEntryType.priv.tupleTypeArgs &&
                         !(0, typeUtils_1.isUnboundedTupleClass)(narrowedEntryType) &&
-                        narrowedEntryType.priv.tupleTypeArguments) {
-                        (0, collectionUtils_1.appendArray)(narrowedEntryTypes, narrowedEntryType.priv.tupleTypeArguments.map((t) => t.type));
+                        narrowedEntryType.priv.tupleTypeArgs) {
+                        (0, collectionUtils_1.appendArray)(narrowedEntryTypes, narrowedEntryType.priv.tupleTypeArgs.map((t) => t.type));
                     }
                     else {
                         narrowedEntryTypes.push(narrowedEntryType);
@@ -169,10 +171,11 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
                 }
                 if (!(0, types_1.isNever)(narrowedEntryType)) {
                     isDefiniteMatch = false;
-                    // Record the number of entries that were narrowed in the negative
-                    // case. We can apply the tuple narrowing only if exactly one entry
-                    // is narrowed.
-                    negativeEntriesNarrowed++;
+                    // Record which entries were narrowed in the negative case
+                    // by storing their indexes. If more than one is narrowed,
+                    // we need to perform tuple expansion to represent the
+                    // resulting narrowed type.
+                    negativeNarrowedDims.push(index);
                     narrowedEntryTypes.push(narrowedEntryType);
                 }
                 else {
@@ -199,12 +202,22 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
                 return false;
             }
             // Can we narrow a tuple?
-            if (canNarrowTuple && negativeEntriesNarrowed === 1) {
+            if (canNarrowTuple && negativeNarrowedDims.length > 0) {
                 const tupleClassType = evaluator.getBuiltInType(pattern, 'tuple');
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    entry.subtype = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, narrowedEntryTypes.map((t) => {
-                        return { type: t, isUnbounded: false };
-                    })));
+                    // Expand the tuple in the dimensions that were narrowed.
+                    // Start with the fully-narrowed set of entries.
+                    const expandedEntryTypes = [];
+                    for (const dim of negativeNarrowedDims) {
+                        const newEntryTypes = [...unnarrowedEntryTypes];
+                        newEntryTypes[dim] = narrowedEntryTypes[dim];
+                        expandedEntryTypes.push(newEntryTypes);
+                    }
+                    entry.subtype = (0, types_1.combineTypes)(expandedEntryTypes.map((entryTypes) => {
+                        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, entryTypes.map((t) => {
+                            return { type: t, isUnbounded: false };
+                        })));
+                    }));
                 }
             }
             return true;
@@ -229,7 +242,7 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
                     // If the type is a union that contains Any or Unknown, remove the other types
                     // before wrapping it in a Sequence.
                     typeArgType = (_a = (0, typeUtils_1.containsAnyOrUnknown)(typeArgType, /* recurse */ false)) !== null && _a !== void 0 ? _a : typeArgType;
-                    entry.subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(sequenceType, [typeArgType], /* isTypeArgumentExplicit */ true));
+                    entry.subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(sequenceType, [typeArgType]));
                 }
             }
         }
@@ -380,8 +393,8 @@ function getPositionalMatchArgNames(evaluator, type) {
         if ((0, types_1.isClassInstance)(matchArgsType) &&
             (0, typeUtils_1.isTupleClass)(matchArgsType) &&
             !(0, typeUtils_1.isUnboundedTupleClass)(matchArgsType) &&
-            matchArgsType.priv.tupleTypeArguments) {
-            const tupleArgs = matchArgsType.priv.tupleTypeArguments;
+            matchArgsType.priv.tupleTypeArgs) {
+            const tupleArgs = matchArgsType.priv.tupleTypeArgs;
             // Are all the args string literals?
             if (tupleArgs.every((arg) => (0, types_1.isClassInstance)(arg.type) && types_1.ClassType.isBuiltIn(arg.type, 'str') && (0, typeUtils_1.isLiteralType)(arg.type))) {
                 return tupleArgs.map((arg) => arg.type.priv.literalValue);
@@ -455,10 +468,8 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
             return type;
         }
         let classType = exprType;
-        if (classType.shared.typeParameters.length > 0) {
-            classType = types_1.ClassType.cloneForSpecialization(classType, 
-            /* typeArguments */ undefined, 
-            /* isTypeArgumentExplicit */ false);
+        if (classType.shared.typeParams.length > 0) {
+            classType = types_1.ClassType.specialize(classType, /* typeArgs */ undefined);
         }
         const classInstance = (0, typeUtils_1.convertToInstance)(classType);
         const isPatternMetaclass = (0, typeUtils_1.isMetaclassInstance)(classInstance);
@@ -515,7 +526,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                 }
             }
             for (let index = 0; index < pattern.d.args.length; index++) {
-                const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, pattern.d.args[index], index, positionalArgNames, subjectSubtypeExpanded, isPositiveTest);
+                const narrowedArgType = narrowTypeOfClassPatternArg(evaluator, pattern.d.args[index], index, positionalArgNames, subjectSubtypeExpanded, isPositiveTest);
                 if (!(0, types_1.isNever)(narrowedArgType)) {
                     return subjectSubtypeUnexpanded;
                 }
@@ -547,7 +558,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                     if ((0, types_1.isInstantiableClass)(expandedSubtype) && types_1.ClassType.isBuiltIn(expandedSubtype, 'Callable')) {
                         // Convert to an unknown callable type.
                         const unknownCallable = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
-                        types_1.FunctionType.addDefaultParameters(unknownCallable, 
+                        types_1.FunctionType.addDefaultParams(unknownCallable, 
                         /* useUnknown */ (0, types_1.isUnknown)(subjectSubtypeExpanded));
                         unknownCallable.shared.declaredReturnType = subjectSubtypeExpanded;
                         return unknownCallable;
@@ -592,11 +603,10 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                         // Try to retain the type arguments for the pattern class type.
                         if ((0, types_1.isInstantiableClass)(unexpandedSubtype) && (0, types_1.isClassInstance)(subjectSubtypeExpanded)) {
                             if (types_1.ClassType.isSpecialBuiltIn(unexpandedSubtype) ||
-                                unexpandedSubtype.shared.typeParameters.length > 0) {
+                                unexpandedSubtype.shared.typeParams.length > 0) {
                                 const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(unexpandedSubtype));
-                                const unspecializedMatchType = types_1.ClassType.cloneForSpecialization(unexpandedSubtype, 
-                                /* typeArguments */ undefined, 
-                                /* isTypeArgumentExplicit */ false);
+                                const unspecializedMatchType = types_1.ClassType.specialize(unexpandedSubtype, 
+                                /* typeArgs */ undefined);
                                 const matchTypeInstance = types_1.ClassType.cloneAsInstance(unspecializedMatchType);
                                 if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, matchTypeInstance, subjectSubtypeExpanded, typeVarContext, 
                                 /* liveTypeVarScopes */ undefined, 
@@ -623,7 +633,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                         // Narrow the arg pattern. It's possible that the actual type of the object
                         // being matched is a subtype of the resultType, so it might contain additional
                         // attributes that we don't know about.
-                        const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, arg, index, positionalArgNames, resultType, isPositiveTest);
+                        const narrowedArgType = narrowTypeOfClassPatternArg(evaluator, arg, index, positionalArgNames, resultType, isPositiveTest);
                         if ((0, types_1.isNever)(narrowedArgType)) {
                             isMatchValid = false;
                         }
@@ -658,7 +668,7 @@ function isClassSpecialCaseForClassPattern(classType) {
     return false;
 }
 // Narrows the pattern provided for a class pattern argument.
-function narrowTypeOfClassPatternArgument(evaluator, arg, argIndex, positionalArgNames, matchType, isPositiveTest) {
+function narrowTypeOfClassPatternArg(evaluator, arg, argIndex, positionalArgNames, matchType, isPositiveTest) {
     var _a;
     let argName;
     if (arg.d.name) {
@@ -802,44 +812,40 @@ function getMappingPatternInfo(evaluator, type, node) {
                 });
                 return;
             }
-            // Is it a subclass of Mapping?
-            let mroClassToSpecialize;
-            for (const mroClass of concreteSubtype.shared.mro) {
-                if ((0, types_1.isInstantiableClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'Mapping')) {
-                    mroClassToSpecialize = mroClass;
-                    break;
-                }
+            const mappingType = evaluator.getTypingType(node, 'Mapping');
+            if (!mappingType || !(0, types_1.isInstantiableClass)(mappingType)) {
+                return;
             }
-            if (mroClassToSpecialize) {
-                const specializedMapping = (0, typeUtils_1.partiallySpecializeType)(mroClassToSpecialize, concreteSubtype, evaluator.getTypeClassType());
-                if (specializedMapping.priv.typeArguments && specializedMapping.priv.typeArguments.length >= 2) {
+            const mappingObject = types_1.ClassType.cloneAsInstance(mappingType);
+            // Is it a subtype of Mapping?
+            const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingObject));
+            if (evaluator.assignType(mappingObject, subtype, /* diag */ undefined, typeVarContext)) {
+                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingObject, typeVarContext);
+                if (specializedMapping.priv.typeArgs && specializedMapping.priv.typeArgs.length >= 2) {
                     mappingInfo.push({
                         subtype,
                         isDefinitelyMapping: true,
                         isDefinitelyNotMapping: false,
                         dictTypeArgs: {
-                            key: specializedMapping.priv.typeArguments[0],
-                            value: specializedMapping.priv.typeArguments[1],
+                            key: specializedMapping.priv.typeArgs[0],
+                            value: specializedMapping.priv.typeArgs[1],
                         },
                     });
                 }
                 return;
             }
             // Is it a superclass of Mapping?
-            const mappingType = evaluator.getTypingType(node, 'Mapping');
-            if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                const mappingObject = types_1.ClassType.cloneAsInstance(mappingType);
-                if (evaluator.assignType(subtype, mappingObject)) {
-                    mappingInfo.push({
-                        subtype,
-                        isDefinitelyMapping: false,
-                        isDefinitelyNotMapping: false,
-                        dictTypeArgs: {
-                            key: types_1.UnknownType.create(),
-                            value: types_1.UnknownType.create(),
-                        },
-                    });
-                }
+            if (evaluator.assignType(subtype, mappingObject)) {
+                mappingInfo.push({
+                    subtype,
+                    isDefinitelyMapping: false,
+                    isDefinitelyNotMapping: false,
+                    dictTypeArgs: {
+                        key: types_1.UnknownType.create(),
+                        value: types_1.UnknownType.create(),
+                    },
+                });
+                return;
             }
             mappingInfo.push({
                 subtype,
@@ -861,7 +867,6 @@ function getSequencePatternInfo(evaluator, pattern, type) {
         var _a;
         const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
         let mroClassToSpecialize;
-        let pushedEntry = false;
         if ((0, types_1.isClassInstance)(concreteSubtype)) {
             for (const mroClass of concreteSubtype.shared.mro) {
                 if (!(0, types_1.isInstantiableClass)(mroClass)) {
@@ -892,10 +897,10 @@ function getSequencePatternInfo(evaluator, pattern, type) {
             if (mroClassToSpecialize) {
                 const specializedSequence = (0, typeUtils_1.partiallySpecializeType)(mroClassToSpecialize, concreteSubtype, evaluator.getTypeClassType());
                 if ((0, typeUtils_1.isTupleClass)(specializedSequence)) {
-                    const typeArgs = (_a = specializedSequence.priv.tupleTypeArguments) !== null && _a !== void 0 ? _a : [
+                    const typeArgs = (_a = specializedSequence.priv.tupleTypeArgs) !== null && _a !== void 0 ? _a : [
                         { type: types_1.UnknownType.create(), isUnbounded: true },
                     ];
-                    const tupleIndeterminateIndex = typeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type));
+                    const tupleIndeterminateIndex = typeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
                     let tupleDeterminateEntryCount = typeArgs.length;
                     // If the tuple contains an indeterminate entry, expand or remove that
                     // entry to match the length of the pattern if possible.
@@ -917,7 +922,7 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                         const removedEntries = typeArgs.splice(patternStarEntryIndex, entriesToCombine);
                         typeArgs.splice(patternStarEntryIndex, 0, {
                             type: (0, types_1.combineTypes)(removedEntries.map((t) => t.type)),
-                            isUnbounded: removedEntries.every((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type)),
+                            isUnbounded: removedEntries.every((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type)),
                         });
                     }
                     if (typeArgs.length === patternEntryCount) {
@@ -949,7 +954,7 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                             isDefiniteNoMatch,
                             isPotentialNoMatch,
                         });
-                        pushedEntry = true;
+                        return;
                     }
                     // If the pattern contains a star entry and the pattern associated with
                     // the star entry is unbounded, we can remove it completely under the
@@ -988,7 +993,7 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                                 isTuple: true,
                                 isDefiniteNoMatch,
                             });
-                            pushedEntry = true;
+                            return;
                         }
                     }
                 }
@@ -996,28 +1001,44 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                     sequenceInfo.push({
                         subtype,
                         entryTypes: [
-                            specializedSequence.priv.typeArguments && specializedSequence.priv.typeArguments.length > 0
-                                ? specializedSequence.priv.typeArguments[0]
+                            specializedSequence.priv.typeArgs && specializedSequence.priv.typeArgs.length > 0
+                                ? specializedSequence.priv.typeArgs[0]
                                 : types_1.UnknownType.create(),
                         ],
                         isIndeterminateLength: true,
                         isDefiniteNoMatch: false,
                     });
-                    pushedEntry = true;
+                    return;
                 }
             }
         }
-        if (!pushedEntry) {
-            // If it wasn't a subtype of Sequence, see if it's a supertype.
+        if (!mroClassToSpecialize) {
             const sequenceType = evaluator.getTypingType(pattern, 'Sequence');
             if (sequenceType && (0, types_1.isInstantiableClass)(sequenceType)) {
+                const sequenceObject = types_1.ClassType.cloneAsInstance(sequenceType);
+                // Is it a subtype of Sequence?
+                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(sequenceType));
+                if (evaluator.assignType(sequenceObject, subtype, /* diag */ undefined, typeVarContext)) {
+                    const specializedSequence = (0, typeUtils_1.applySolvedTypeVars)(sequenceObject, typeVarContext);
+                    if (specializedSequence.priv.typeArgs && specializedSequence.priv.typeArgs.length > 0) {
+                        sequenceInfo.push({
+                            subtype,
+                            entryTypes: [specializedSequence.priv.typeArgs[0]],
+                            isIndeterminateLength: true,
+                            isDefiniteNoMatch: false,
+                            isPotentialNoMatch: false,
+                        });
+                        return;
+                    }
+                }
+                // If it wasn't a subtype of Sequence, see if it's a supertype.
                 const sequenceTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(sequenceType));
                 if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(sequenceType), subtype, sequenceTypeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(pattern), pattern.start)) {
                     const specializedSequence = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(sequenceType), sequenceTypeVarContext);
-                    if (specializedSequence.priv.typeArguments && specializedSequence.priv.typeArguments.length > 0) {
+                    if (specializedSequence.priv.typeArgs && specializedSequence.priv.typeArgs.length > 0) {
                         sequenceInfo.push({
                             subtype,
-                            entryTypes: [specializedSequence.priv.typeArguments[0]],
+                            entryTypes: [specializedSequence.priv.typeArgs[0]],
                             isIndeterminateLength: true,
                             isDefiniteNoMatch: false,
                             isPotentialNoMatch: true,
@@ -1025,8 +1046,7 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                         return;
                     }
                 }
-                if (evaluator.assignType(subtype, types_1.ClassType.cloneForSpecialization(types_1.ClassType.cloneAsInstance(sequenceType), [types_1.UnknownType.create()], 
-                /* isTypeArgumentExplicit */ true))) {
+                if (evaluator.assignType(subtype, types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(sequenceType), [types_1.UnknownType.create()]))) {
                     sequenceInfo.push({
                         subtype,
                         entryTypes: [types_1.UnknownType.create()],
@@ -1037,14 +1057,14 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                     return;
                 }
             }
-            // Push an entry that indicates that this is definitely not a match.
-            sequenceInfo.push({
-                subtype,
-                entryTypes: [],
-                isIndeterminateLength: true,
-                isDefiniteNoMatch: true,
-            });
         }
+        // Push an entry that indicates that this is definitely not a match.
+        sequenceInfo.push({
+            subtype,
+            entryTypes: [],
+            isIndeterminateLength: true,
+            isDefiniteNoMatch: true,
+        });
     });
     return sequenceInfo;
 }
@@ -1069,7 +1089,7 @@ function getTypeOfPatternSequenceEntry(evaluator, node, sequenceInfo, entryIndex
             // its type other than it's "Unknown". We could evaluate it as an
             // "object", but that will cause problems given that this type will
             // be wrapped in a "list" below, and lists are invariant.
-            if ((0, types_1.isVariadicTypeVar)(type) && !type.priv.isVariadicInUnion) {
+            if ((0, types_1.isTypeVarTuple)(type) && !type.priv.isVariadicInUnion) {
                 return types_1.UnknownType.create();
             }
             return evaluator.stripLiteralValue(type);
@@ -1189,8 +1209,7 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                     const dictClass = evaluator.getBuiltInType(pattern, 'dict');
                     const strType = evaluator.getBuiltInObject(pattern, 'str');
                     const dictType = dictClass && (0, types_1.isInstantiableClass)(dictClass) && (0, types_1.isClassInstance)(strType)
-                        ? types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictClass, [keyType, valueType], 
-                        /* isTypeArgumentExplicit */ true))
+                        ? types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(dictClass, [keyType, valueType]))
                         : types_1.UnknownType.create();
                     evaluator.assignTypeToExpression(mappingEntry.d.target, { type: dictType, isIncomplete: isTypeIncomplete }, mappingEntry.d.target);
                 }
@@ -1216,7 +1235,7 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                                 positionalArgNames = getPositionalMatchArgNames(evaluator, types_1.ClassType.cloneAsInstantiable(expandedSubtype));
                             }
                             pattern.d.args.forEach((arg, index) => {
-                                const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, arg, index, positionalArgNames, types_1.ClassType.cloneAsInstantiable(expandedSubtype), 
+                                const narrowedArgType = narrowTypeOfClassPatternArg(evaluator, arg, index, positionalArgNames, types_1.ClassType.cloneAsInstantiable(expandedSubtype), 
                                 /* isPositiveTest */ true);
                                 argTypes[index].push(narrowedArgType);
                             });
@@ -1255,7 +1274,7 @@ function wrapTypeInList(evaluator, node, type) {
         // If the type is a union that contains an Any or Unknown, eliminate the other
         // types before wrapping it in a list.
         type = (_a = (0, typeUtils_1.containsAnyOrUnknown)(type, /* recurse */ false)) !== null && _a !== void 0 ? _a : type;
-        return types_1.ClassType.cloneForSpecialization(listObjectType, [type], /* isTypeArgumentExplicit */ true);
+        return types_1.ClassType.specialize(listObjectType, [type]);
     }
     return types_1.UnknownType.create();
 }
@@ -1273,8 +1292,8 @@ function validateClassPattern(evaluator, pattern) {
     // Check for certain uses of type aliases that generate runtime exceptions.
     if (((_b = exprType.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) &&
         (0, types_1.isInstantiableClass)(exprType) &&
-        exprType.priv.typeArguments &&
-        exprType.priv.isTypeArgumentExplicit) {
+        exprType.priv.typeArgs &&
+        exprType.priv.isTypeArgExplicit) {
         evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classPatternTypeAlias().format({ type: evaluator.printType(exprType) }), pattern.d.className);
     }
     else if (!(0, types_1.isInstantiableClass)(exprType)) {
@@ -1324,7 +1343,7 @@ function getPatternSubtypeNarrowingCallback(evaluator, reference, subjectExpress
     if (subjectExpression.nodeType === 27 /* ParseNodeType.Index */ &&
         subjectExpression.d.items.length === 1 &&
         !subjectExpression.d.trailingComma &&
-        subjectExpression.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+        subjectExpression.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
         (0, parseTreeUtils_1.isMatchingExpression)(reference, subjectExpression.d.leftExpr)) {
         const indexTypeResult = evaluator.getTypeOfExpression(subjectExpression.d.items[0].d.valueExpr);
         const indexType = indexTypeResult.type;
@@ -1375,10 +1394,10 @@ function getPatternSubtypeNarrowingCallback(evaluator, reference, subjectExpress
                 (0, typeUtils_1.doForEachSubtype)(narrowedSubjectType, (subtype) => {
                     if ((0, types_1.isClassInstance)(subtype) &&
                         types_1.ClassType.isBuiltIn(subtype, 'tuple') &&
-                        subtype.priv.tupleTypeArguments &&
-                        matchingEntryIndex < subtype.priv.tupleTypeArguments.length &&
-                        subtype.priv.tupleTypeArguments.every((e) => !e.isUnbounded)) {
-                        narrowedSubtypes.push(subtype.priv.tupleTypeArguments[matchingEntryIndex].type);
+                        subtype.priv.tupleTypeArgs &&
+                        matchingEntryIndex < subtype.priv.tupleTypeArgs.length &&
+                        subtype.priv.tupleTypeArgs.every((e) => !e.isUnbounded)) {
+                        narrowedSubtypes.push(subtype.priv.tupleTypeArgs[matchingEntryIndex].type);
                     }
                     else if ((0, types_1.isNever)(narrowedSubjectType)) {
                         narrowedSubtypes.push(narrowedSubjectType);