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

package/dist/analyzer/typeGuards.js

@@ -90,7 +90,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr) &&
                     leftExpression.d.items.length === 1 &&
                     !leftExpression.d.trailingComma &&
-                    leftExpression.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    leftExpression.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
                     !leftExpression.d.items[0].d.name &&
                     leftExpression.d.items[0].d.valueExpr.nodeType === 40 /* ParseNodeType.Number */ &&
                     leftExpression.d.items[0].d.valueExpr.d.isInteger &&
@@ -126,7 +126,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             // Look for "type(X) is Y", "type(X) is not Y", "type(X) == Y" or "type(X) != Y".
             if (testExpression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */) {
                 if (testExpression.d.leftExpr.d.args.length === 1 &&
-                    testExpression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgumentCategory.Simple */) {
+                    testExpression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgCategory.Simple */) {
                     const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
                     if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                         const callType = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type;
@@ -175,7 +175,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
                     testExpression.d.leftExpr.d.items.length === 1 &&
                     !testExpression.d.leftExpr.d.trailingComma &&
-                    testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
                     const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
                     const indexType = indexTypeResult.type;
@@ -241,7 +241,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
                     testExpression.d.leftExpr.d.items.length === 1 &&
                     !testExpression.d.leftExpr.d.trailingComma &&
-                    testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
                     const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
                     const indexType = indexTypeResult.type;
@@ -489,10 +489,11 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
                     const functionReturnType = functionReturnTypeResult.type;
                     if ((0, types_1.isClassInstance)(functionReturnType) &&
-                        types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
-                        functionReturnType.priv.typeGuardType) {
-                        const isStrictTypeGuard = !!functionReturnType.priv.isStrictTypeGuard;
-                        const typeGuardType = functionReturnType.priv.typeGuardType;
+                        types_1.ClassType.isBuiltIn(functionReturnType, ['TypeGuard', 'TypeIs']) &&
+                        functionReturnType.priv.typeArgs &&
+                        functionReturnType.priv.typeArgs.length > 0) {
+                        const isStrictTypeGuard = types_1.ClassType.isBuiltIn(functionReturnType, 'TypeIs');
+                        const typeGuardType = functionReturnType.priv.typeArgs[0];
                         const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
                         return (type) => {
                             return {
@@ -596,14 +597,14 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
         return undefined;
     }
     if (decls.length === 0 ||
-        decls.some((decl) => decl.type !== 1 /* DeclarationType.Variable */ && decl.type !== 2 /* DeclarationType.Parameter */)) {
+        decls.some((decl) => decl.type !== 1 /* DeclarationType.Variable */ && decl.type !== 2 /* DeclarationType.Param */)) {
         return undefined;
     }
     // If there are any assignments within different scopes (e.g. via a "global" or
     // "nonlocal" reference), don't consider it a local variable.
     let prevDeclScope;
     if (decls.some((decl) => {
-        const nodeToConsider = decl.type === 2 /* DeclarationType.Parameter */ ? decl.node.d.name : decl.node;
+        const nodeToConsider = decl.type === 2 /* DeclarationType.Param */ ? decl.node.d.name : decl.node;
         const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider);
         if (prevDeclScope && declScopeNode !== prevDeclScope) {
             return true;
@@ -624,7 +625,17 @@ function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPos
     // For non-strict type guards, always narrow to the typeGuardType
     // in the positive case and don't narrow in the negative case.
     if (!isStrictTypeGuard) {
-        return isPositiveTest ? typeGuardType : type;
+        let result = type;
+        if (isPositiveTest) {
+            result = typeGuardType;
+            // If the type guard is a non-constrained TypeVar, add a
+            // condition to the resulting type.
+            if ((0, types_1.isTypeVar)(type) && !(0, types_1.isParamSpec)(type) && type.shared.constraints.length === 0) {
+                result = (0, typeUtils_1.addConditionToType)(result, [{ typeVar: type, constraintIndex: 0 }]);
+            }
+            return result;
+        }
+        return result;
     }
     const filterTypes = [];
     (0, typeUtils_1.doForEachSubtype)(typeGuardType, (typeGuardSubtype) => {
@@ -655,14 +666,14 @@ function narrowTypeForTruthiness(evaluator, type, isPositiveTest) {
 function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
     return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
         const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-        if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.priv.tupleTypeArguments) {
+        if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.priv.tupleTypeArgs) {
             return subtype;
         }
-        const tupleLength = tupleType.priv.tupleTypeArguments.length;
+        const tupleLength = tupleType.priv.tupleTypeArgs.length;
         if (indexValue < 0 || indexValue >= tupleLength) {
             return subtype;
         }
-        const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.priv.tupleTypeArguments[indexValue].type);
+        const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.priv.tupleTypeArgs[indexValue].type);
         if (isPositiveTest) {
             if (!evaluator.assignType(typeOfEntry, evaluator.getNoneType())) {
                 return undefined;
@@ -781,8 +792,8 @@ function getIsInstanceClassTypes(evaluator, argType) {
             }
             else if ((0, types_1.isFunction)(subtype) &&
                 subtype.shared.parameters.length === 2 &&
-                subtype.shared.parameters[0].category === 1 /* ParameterCategory.ArgsList */ &&
-                subtype.shared.parameters[1].category === 2 /* ParameterCategory.KwargsDict */) {
+                subtype.shared.parameters[0].category === 1 /* ParamCategory.ArgsList */ &&
+                subtype.shared.parameters[1].category === 2 /* ParamCategory.KwargsDict */) {
                 classTypeList.push(subtype);
             }
             else {
@@ -795,8 +806,8 @@ function getIsInstanceClassTypes(evaluator, argType) {
             return;
         }
         if ((0, types_1.isClass)(type) && types_1.TypeBase.isInstance(type) && (0, typeUtils_1.isTupleClass)(type)) {
-            if (type.priv.tupleTypeArguments) {
-                type.priv.tupleTypeArguments.forEach((tupleEntry) => {
+            if (type.priv.tupleTypeArgs) {
+                type.priv.tupleTypeArgs.forEach((tupleEntry) => {
                     addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
                 });
             }
@@ -826,8 +837,11 @@ function isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filte
         return true;
     }
     if (isInstanceCheck) {
+        // We convert both types to instances in case they are protocol
+        // classes. A protocol class isn't allowed to be assigned to
+        // type[T], so this would otherwise fail.
         if (types_1.ClassType.isProtocolClass(concreteFilterType) &&
-            evaluator.assignType(concreteFilterType, concreteVarType)) {
+            evaluator.assignType(types_1.ClassType.cloneAsInstance(concreteFilterType), types_1.ClassType.cloneAsInstance(concreteVarType))) {
             return true;
         }
     }
@@ -845,7 +859,11 @@ function isIsinstanceFilterSubclass(evaluator, varType, concreteFilterType, isIn
         return true;
     }
     if (isInstanceCheck) {
-        if (types_1.ClassType.isProtocolClass(varType) && evaluator.assignType(varType, concreteFilterType)) {
+        // We convert both types to instances in case they are protocol
+        // classes. A protocol class isn't allowed to be assigned to
+        // type[T], so this would otherwise fail.
+        if (types_1.ClassType.isProtocolClass(varType) &&
+            evaluator.assignType(types_1.ClassType.cloneAsInstance(varType), types_1.ClassType.cloneAsInstance(concreteFilterType))) {
             return true;
         }
     }
@@ -894,10 +912,8 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                     // If the class was implicitly specialized (e.g. because its type
                     // parameters have default values), replace the default type arguments
                     // with Unknown.
-                    if (concreteFilterType.priv.typeArguments && !concreteFilterType.priv.isTypeArgumentExplicit) {
-                        concreteFilterType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(types_1.ClassType.cloneForSpecialization(concreteFilterType, 
-                        /* typeArguments */ undefined, 
-                        /* isTypeArgumentExplicit */ false), evaluator.getTupleClassType());
+                    if (concreteFilterType.priv.typeArgs && !concreteFilterType.priv.isTypeArgExplicit) {
+                        concreteFilterType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(types_1.ClassType.specialize(concreteFilterType, /* typeArgs */ undefined), evaluator.getTupleClassType());
                     }
                     filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck);
                     filterIsSubclass = isIsinstanceFilterSubclass(evaluator, concreteVarType, concreteFilterType, isInstanceCheck);
@@ -933,7 +949,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         }
                     }
                     else if (filterIsSubclass) {
-                        if (evaluator.assignType(concreteVarType, concreteFilterType, 
+                        if (evaluator.assignType((0, typeUtils_1.convertToInstance)(concreteVarType), (0, typeUtils_1.convertToInstance)(concreteFilterType), 
                         /* diag */ undefined, 
                         /* destTypeVarContext */ undefined, 
                         /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */ | 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
@@ -944,15 +960,13 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                             // important because a specialized version of the filter cannot
                             // be passed to isinstance or issubclass.
                             if ((0, types_1.isClass)(filterType)) {
-                                if (types_1.ClassType.isSpecialBuiltIn(filterType) ||
-                                    filterType.shared.typeParameters.length > 0) {
-                                    if (!filterType.priv.isTypeArgumentExplicit &&
+                                if (types_1.ClassType.isSpecialBuiltIn(filterType) || filterType.shared.typeParams.length > 0) {
+                                    if (!filterType.priv.isTypeArgExplicit &&
                                         !types_1.ClassType.isSameGenericClass(concreteVarType, filterType)) {
                                         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
-                                        const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
-                                        /* typeArguments */ undefined, 
-                                        /* isTypeArgumentExplicit */ false);
-                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext, 
+                                        const unspecializedFilterType = types_1.ClassType.specialize(filterType, 
+                                        /* typeArg */ undefined);
+                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, (0, typeUtils_1.convertToInstance)(unspecializedFilterType), (0, typeUtils_1.convertToInstance)(concreteVarType), typeVarContext, 
                                         /* liveTypeVarScopes */ undefined, errorNode.start)) {
                                             specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, {
                                                 unknownIfNotFound: true,
@@ -966,6 +980,16 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                             filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, conditions));
                         }
                     }
+                    else if (types_1.ClassType.isSameGenericClass(concreteVarType, concreteFilterType)) {
+                        // Don't attempt to narrow in this case.
+                        if (((_a = concreteVarType.priv) === null || _a === void 0 ? void 0 : _a.literalValue) === undefined &&
+                            ((_b = concreteFilterType.priv) === null || _b === void 0 ? void 0 : _b.literalValue) === undefined) {
+                            const intersection = intersectSameClassType(evaluator, concreteVarType, concreteFilterType);
+                            filteredTypes.push(intersection !== null && intersection !== void 0 ? intersection : varType);
+                            // Don't attempt to narrow in the negative direction.
+                            isClassRelationshipIndeterminate = true;
+                        }
+                    }
                     else if (allowIntersections &&
                         !types_1.ClassType.isFinal(concreteVarType) &&
                         !types_1.ClassType.isFinal(concreteFilterType)) {
@@ -974,39 +998,16 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         // be a mix-in class used with the other. In this case, we'll
                         // synthesize a new class type that represents an intersection of
                         // the two types.
-                        const className = `<subclass of ${concreteVarType.shared.name} and ${concreteFilterType.shared.name}>`;
-                        const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-                        // The effective metaclass of the intersection is the narrower of the two metaclasses.
-                        let effectiveMetaclass = concreteVarType.shared.effectiveMetaclass;
-                        if (concreteFilterType.shared.effectiveMetaclass) {
-                            if (!effectiveMetaclass ||
-                                evaluator.assignType(effectiveMetaclass, concreteFilterType.shared.effectiveMetaclass)) {
-                                effectiveMetaclass = concreteFilterType.shared.effectiveMetaclass;
-                            }
-                        }
-                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
-                        /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.shared.docString);
-                        newClassType.shared.baseClasses = [
-                            types_1.ClassType.cloneAsInstantiable(concreteVarType),
-                            concreteFilterType,
-                        ];
-                        (0, typeUtils_1.computeMroLinearization)(newClassType);
-                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = concreteFilterType.props) === null || _a === void 0 ? void 0 : _a.condition);
-                        if ((0, types_1.isTypeVar)(varType) &&
-                            !varType.shared.isParamSpec &&
-                            varType.shared.constraints.length === 0) {
-                            newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
-                                { typeVar: varType, constraintIndex: 0 },
-                            ]);
-                        }
-                        let newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
-                        if ((_b = concreteVarType.props) === null || _b === void 0 ? void 0 : _b.condition) {
-                            newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, (_c = concreteVarType.props) === null || _c === void 0 ? void 0 : _c.condition);
+                        let newClassType = evaluator.createSubclass(errorNode, concreteVarType, concreteFilterType);
+                        if ((0, types_1.isTypeVar)(varType) && !(0, types_1.isParamSpec)(varType) && varType.shared.constraints.length === 0) {
+                            newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [{ typeVar: varType, constraintIndex: 0 }]);
                         }
+                        let newClassObjType = types_1.ClassType.cloneAsInstance(newClassType);
+                        newClassObjType = (0, typeUtils_1.addConditionToType)(newClassObjType, (_c = concreteVarType.props) === null || _c === void 0 ? void 0 : _c.condition);
                         // If this is a issubclass check, we do a double conversion from instantiable
                         // to instance back to instantiable to make sure that the includeSubclasses flag
                         // gets cleared.
-                        filteredTypes.push(isInstanceCheck ? newClassInstanceType : types_1.ClassType.cloneAsInstantiable(newClassInstanceType));
+                        filteredTypes.push(isInstanceCheck ? newClassObjType : types_1.ClassType.cloneAsInstantiable(newClassObjType));
                     }
                 }
             }
@@ -1119,7 +1120,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                     // This will normally be treated as type[Any], which is compatible with
                     // any metaclass, but we specifically want to treat type as the class
                     // type[object] in this case.
-                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgumentExplicit) {
+                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgExplicit) {
                         if (!types_1.ClassType.isBuiltIn(metaclassType, 'type')) {
                             isMetaclassOverlap = false;
                         }
@@ -1254,8 +1255,9 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
             if ((0, types_1.isInstantiableClass)(subtype) || isSubtypeMetaclass) {
                 // Handle the special case of isinstance(x, metaclass).
                 const includesMetaclassType = filterTypes.some((classType) => (0, typeUtils_1.isInstantiableMetaclass)(classType));
+                const includesObject = filterTypes.some((classType) => (0, types_1.isInstantiableClass)(classType) && types_1.ClassType.isBuiltIn(classType, 'object'));
                 if (isPositiveTest) {
-                    return includesMetaclassType ? negativeFallback : undefined;
+                    return includesMetaclassType || includesObject ? negativeFallback : undefined;
                 }
                 else {
                     return includesMetaclassType ? undefined : negativeFallback;
@@ -1297,6 +1299,35 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
     }
     return filteredType;
 }
+// This function assumes that the caller has already verified that the two
+// types are the same class and are not literals. It also assumes that the
+// caller has verified that type1 is not assignable to type2 or vice versa.
+// Returns undefined if there is no intersection between the two types.
+function intersectSameClassType(evaluator, type1, type2) {
+    var _a, _b;
+    (0, debug_1.assert)((0, types_1.isInstantiableClass)(type1) && (0, types_1.isInstantiableClass)(type2));
+    (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(type1, type2));
+    (0, debug_1.assert)(((_a = type1.priv) === null || _a === void 0 ? void 0 : _a.literalValue) === undefined);
+    (0, debug_1.assert)(((_b = type2.priv) === null || _b === void 0 ? void 0 : _b.literalValue) === undefined);
+    // Handle tuples specially.
+    if (types_1.ClassType.isBuiltIn(type1, 'tuple')) {
+        return intersectTupleTypes(type1, type1);
+    }
+    // Indicate that there is no intersection.
+    return undefined;
+}
+function intersectTupleTypes(type1, type2) {
+    var _a, _b;
+    if (!type2.priv.tupleTypeArgs || (0, typeUtils_1.isTupleGradualForm)(type2)) {
+        return (0, typeUtils_1.addConditionToType)(type1, (_a = type2.props) === null || _a === void 0 ? void 0 : _a.condition);
+    }
+    if (!type1.priv.tupleTypeArgs || (0, typeUtils_1.isTupleGradualForm)(type1)) {
+        return (0, typeUtils_1.addConditionToType)(type2, (_b = type1.props) === null || _b === void 0 ? void 0 : _b.condition);
+    }
+    // For now, don't attempt to narrow in this case.
+    // TODO - add more sophisticated logic here.
+    return undefined;
+}
 // Attempts to narrow a union of tuples based on their known length.
 function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPositiveTest, isLessThanCheck) {
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
@@ -1304,23 +1335,23 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
         // If it's not a tuple, we can't narrow it.
         if (!(0, types_1.isClassInstance)(concreteSubtype) ||
             !(0, typeUtils_1.isTupleClass)(concreteSubtype) ||
-            !concreteSubtype.priv.tupleTypeArguments) {
+            !concreteSubtype.priv.tupleTypeArgs) {
             return subtype;
         }
         // If the tuple contains a variadic TypeVar, we can't narrow it.
-        if (concreteSubtype.priv.tupleTypeArguments.some((typeArg) => (0, types_1.isUnpackedVariadicTypeVar)(typeArg.type))) {
+        if (concreteSubtype.priv.tupleTypeArgs.some((typeArg) => (0, types_1.isUnpackedTypeVarTuple)(typeArg.type))) {
             return subtype;
         }
         // If the tuple contains no unbounded elements, then we know its length exactly.
-        if (!concreteSubtype.priv.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
+        if (!concreteSubtype.priv.tupleTypeArgs.some((typeArg) => typeArg.isUnbounded)) {
             const tupleLengthMatches = isLessThanCheck
-                ? concreteSubtype.priv.tupleTypeArguments.length < lengthValue
-                : concreteSubtype.priv.tupleTypeArguments.length === lengthValue;
+                ? concreteSubtype.priv.tupleTypeArgs.length < lengthValue
+                : concreteSubtype.priv.tupleTypeArgs.length === lengthValue;
             return tupleLengthMatches === isPositiveTest ? subtype : undefined;
         }
         // The tuple contains a "...". We'll expand this into as many elements as
         // necessary to match the lengthValue.
-        const elementsToAdd = lengthValue - concreteSubtype.priv.tupleTypeArguments.length + 1;
+        const elementsToAdd = lengthValue - concreteSubtype.priv.tupleTypeArgs.length + 1;
         if (!isLessThanCheck) {
             // If the specified length is smaller than the minimum length of this tuple,
             // we can rule it out for a positive test and rule it in for a negative test.
@@ -1360,7 +1391,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
 // to) the unbounded element.
 function expandUnboundedTupleElement(tupleType, elementsToAdd, keepUnbounded) {
     const tupleTypeArgs = [];
-    tupleType.priv.tupleTypeArguments.forEach((typeArg) => {
+    tupleType.priv.tupleTypeArgs.forEach((typeArg) => {
         if (!typeArg.isUnbounded) {
             tupleTypeArgs.push(typeArg);
         }
@@ -1388,13 +1419,13 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     // with a known length.
     if (!(0, types_1.isClassInstance)(containerType) ||
         !types_1.ClassType.isBuiltIn(containerType, 'tuple') ||
-        !containerType.priv.tupleTypeArguments) {
+        !containerType.priv.tupleTypeArgs) {
         return referenceType;
     }
     // Determine which tuple types can be eliminated. Only "None" and
     // literal types can be handled here.
     const typesToEliminate = [];
-    containerType.priv.tupleTypeArguments.forEach((tupleEntry) => {
+    containerType.priv.tupleTypeArgs.forEach((tupleEntry) => {
         if (!tupleEntry.isUnbounded) {
             if ((0, typeUtils_1.isNoneInstance)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
@@ -1429,12 +1460,12 @@ function getElementTypeForContainerNarrowing(containerType) {
     if (!(0, types_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType, supportedContainers)) {
         return undefined;
     }
-    if (!containerType.priv.typeArguments || containerType.priv.typeArguments.length < 1) {
+    if (!containerType.priv.typeArgs || containerType.priv.typeArgs.length < 1) {
         return undefined;
     }
-    let elementType = containerType.priv.typeArguments[0];
-    if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.priv.tupleTypeArguments) {
-        elementType = (0, types_1.combineTypes)(containerType.priv.tupleTypeArguments.map((t) => t.type));
+    let elementType = containerType.priv.typeArgs[0];
+    if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.priv.tupleTypeArgs) {
+        elementType = (0, types_1.combineTypes)(containerType.priv.tupleTypeArgs.map((t) => t.type));
     }
     return elementType;
 }
@@ -1584,10 +1615,8 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
             typeof indexLiteralType.priv.literalValue === 'number' &&
             (0, types_1.isClassInstance)(literalType)) {
             const indexValue = indexLiteralType.priv.literalValue;
-            if (subtype.priv.tupleTypeArguments &&
-                indexValue >= 0 &&
-                indexValue < subtype.priv.tupleTypeArguments.length) {
-                const tupleEntryType = (_a = subtype.priv.tupleTypeArguments[indexValue]) === null || _a === void 0 ? void 0 : _a.type;
+            if (subtype.priv.tupleTypeArgs && indexValue >= 0 && indexValue < subtype.priv.tupleTypeArgs.length) {
+                const tupleEntryType = (_a = subtype.priv.tupleTypeArgs[indexValue]) === null || _a === void 0 ? void 0 : _a.type;
                 if (tupleEntryType && (0, typeUtils_1.isLiteralTypeOrUnion)(tupleEntryType)) {
                     if (isPositiveTest) {
                         return evaluator.assignType(tupleEntryType, literalType) ? subtype : undefined;
@@ -1733,8 +1762,8 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
                 types_1.TypeBase.isInstance(subtype) &&
                 types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
                 concreteSubtype =
-                    concreteSubtype.priv.typeArguments && concreteSubtype.priv.typeArguments.length > 0
-                        ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.priv.typeArguments[0])
+                    concreteSubtype.priv.typeArgs && concreteSubtype.priv.typeArgs.length > 0
+                        ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.priv.typeArgs[0])
                         : types_1.UnknownType.create();
             }
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
@@ -1894,9 +1923,9 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                         newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
                         // Add a __call__ method to the new class.
                         const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
-                        const selfParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(newClassType), types_1.FunctionParamFlags.TypeDeclared, 'self');
-                        types_1.FunctionType.addParameter(callMethod, selfParam);
-                        types_1.FunctionType.addDefaultParameters(callMethod);
+                        const selfParam = types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.ClassType.cloneAsInstance(newClassType), types_1.FunctionParamFlags.TypeDeclared, 'self');
+                        types_1.FunctionType.addParam(callMethod, selfParam);
+                        types_1.FunctionType.addDefaultParams(callMethod);
                         callMethod.shared.declaredReturnType = types_1.UnknownType.create();
                         types_1.ClassType.getSymbolTable(newClassType).set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, callMethod));
                         return types_1.ClassType.cloneAsInstance(newClassType);