@zzzen/pyright-internal 1.2.0-dev.20241215 → 1.2.0-dev.20241229

package/dist/analyzer/typeUtils.js

@@ -214,9 +214,8 @@ class UniqueSignatureTracker {
         });
     }
     addSignature(signature, offset) {
-        var _a;
         // If this function is part of a broader overload, use the overload instead.
-        const effectiveSignature = (0, types_1.isFunction)(signature) ? (_a = signature.priv.overloaded) !== null && _a !== void 0 ? _a : signature : signature;
+        const effectiveSignature = (0, types_1.isFunction)(signature) ? signature.priv.overloaded ?? signature : signature;
         const existingSignature = this.findSignature(effectiveSignature);
         if (existingSignature) {
             if (!existingSignature.expressionOffsets.some((o) => o === offset)) {
@@ -289,9 +288,8 @@ function makeInferenceContext(expectedType, isTypeIncomplete, returnTypeOverride
 // into a final type. It performs no memory allocations if the
 // transformed type is the same as the original.
 function mapSubtypes(type, callback, options) {
-    var _a;
     if ((0, types_1.isUnion)(type)) {
-        const subtypes = (options === null || options === void 0 ? void 0 : options.sortSubtypes) ? sortTypes(type.priv.subtypes) : type.priv.subtypes;
+        const subtypes = options?.sortSubtypes ? sortTypes(type.priv.subtypes) : type.priv.subtypes;
         for (let i = 0; i < subtypes.length; i++) {
             const subtype = subtypes[i];
             const transformedType = callback(subtype);
@@ -309,10 +307,10 @@ function mapSubtypes(type, callback, options) {
                     accumulateSubtype(callback(subtypes[i]));
                 }
                 let newType = (0, types_1.combineTypes)(typesToCombine, {
-                    skipElideRedundantLiterals: options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals,
+                    skipElideRedundantLiterals: options?.skipElideRedundantLiterals,
                 });
-                if (options === null || options === void 0 ? void 0 : options.retainTypeAlias) {
-                    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+                if (options?.retainTypeAlias) {
+                    if (type.props?.typeAliasInfo) {
                         newType = types_1.TypeBase.cloneForTypeAlias(newType, type.props.typeAliasInfo);
                     }
                 }
@@ -430,7 +428,6 @@ function sortTypes(types) {
     });
 }
 function compareTypes(a, b, recursionCount = 0) {
-    var _a, _b;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return 0;
     }
@@ -464,7 +461,7 @@ function compareTypes(a, b, recursionCount = 0) {
                     return typeComparison;
                 }
             }
-            const returnTypeComparison = compareTypes((_a = types_1.FunctionType.getEffectiveReturnType(a)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), (_b = types_1.FunctionType.getEffectiveReturnType(bFunc)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
+            const returnTypeComparison = compareTypes(types_1.FunctionType.getEffectiveReturnType(a) ?? types_1.UnknownType.create(), types_1.FunctionType.getEffectiveReturnType(bFunc) ?? types_1.UnknownType.create());
             if (returnTypeComparison !== 0) {
                 return returnTypeComparison;
             }
@@ -658,7 +655,7 @@ function preserveUnknown(type1, type2) {
 function isUnionableType(subtypes) {
     // If all of the subtypes are TypeForm types, we know that they
     // are unionable.
-    if (subtypes.every((t) => { var _a; return ((_a = t.props) === null || _a === void 0 ? void 0 : _a.typeForm) !== undefined; })) {
+    if (subtypes.every((t) => t.props?.typeForm !== undefined)) {
         return true;
     }
     let typeFlags = 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */;
@@ -691,8 +688,7 @@ function derivesFromAnyOrUnknown(type) {
     return anyOrUnknown;
 }
 function getFullNameOfType(type) {
-    var _a, _b;
-    if ((_b = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.shared.fullName) {
+    if (type.props?.typeAliasInfo?.shared.fullName) {
         return type.props.typeAliasInfo.shared.fullName;
     }
     switch (type.category) {
@@ -719,17 +715,16 @@ function getFullNameOfType(type) {
     return undefined;
 }
 function addConditionToType(type, condition, options) {
-    var _a, _b;
     if (!condition) {
         return type;
     }
-    if (options === null || options === void 0 ? void 0 : options.skipSelfCondition) {
+    if (options?.skipSelfCondition) {
         condition = condition.filter((c) => !types_1.TypeVarType.isSelf(c.typeVar));
         if (condition.length === 0) {
             return type;
         }
     }
-    if (options === null || options === void 0 ? void 0 : options.skipBoundTypeVars) {
+    if (options?.skipBoundTypeVars) {
         condition = condition.filter((c) => c.typeVar.shared.constraints.length > 0);
         if (condition.length === 0) {
             return type;
@@ -744,17 +739,16 @@ function addConditionToType(type, condition, options) {
         case 9 /* TypeCategory.TypeVar */:
             return type;
         case 4 /* TypeCategory.Function */:
-            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition, condition));
+            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.props?.condition, condition));
         case 5 /* TypeCategory.Overloaded */:
             return types_1.OverloadedType.create(types_1.OverloadedType.getOverloads(type).map((t) => addConditionToType(t, condition)));
         case 6 /* TypeCategory.Class */:
-            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine((_b = type.props) === null || _b === void 0 ? void 0 : _b.condition, condition));
+            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.props?.condition, condition));
         case 8 /* TypeCategory.Union */:
             return (0, types_1.combineTypes)(type.priv.subtypes.map((t) => addConditionToType(t, condition)));
     }
 }
 function getTypeCondition(type) {
-    var _a;
     switch (type.category) {
         case 0 /* TypeCategory.Unbound */:
         case 1 /* TypeCategory.Unknown */:
@@ -767,7 +761,7 @@ function getTypeCondition(type) {
             return undefined;
         case 6 /* TypeCategory.Class */:
         case 4 /* TypeCategory.Function */:
-            return (_a = type.props) === null || _a === void 0 ? void 0 : _a.condition;
+            return type.props?.condition;
     }
 }
 // Indicates whether the specified type is a recursive type alias
@@ -779,7 +773,6 @@ function isTypeAliasPlaceholder(type) {
 // within the specified type. It's OK if it's used indirectly as
 // a type argument.
 function isTypeAliasRecursive(typeAliasPlaceholder, type) {
-    var _a, _b;
     if (type.category !== 8 /* TypeCategory.Union */) {
         if (type === typeAliasPlaceholder) {
             return true;
@@ -787,25 +780,24 @@ function isTypeAliasRecursive(typeAliasPlaceholder, type) {
         // Handle the specific case where the type alias directly refers to itself.
         // In this case, the type will be unbound because it could not be resolved.
         return ((0, types_1.isUnbound)(type) &&
-            ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) &&
-            type.props.typeAliasInfo.shared.name === ((_b = typeAliasPlaceholder.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name));
+            type.props?.typeAliasInfo &&
+            type.props.typeAliasInfo.shared.name === typeAliasPlaceholder.shared.recursiveAlias?.name);
     }
     return ((0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared === typeAliasPlaceholder.shared) !==
         undefined);
 }
 function transformPossibleRecursiveTypeAlias(type, recursionCount = 0) {
-    var _a, _b;
     if (recursionCount >= types_1.maxTypeRecursionCount) {
         return type;
     }
     recursionCount++;
     if (type) {
-        const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-        if ((0, types_1.isTypeVar)(type) && ((_b = type.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name) && type.shared.boundType) {
+        const aliasInfo = type.props?.typeAliasInfo;
+        if ((0, types_1.isTypeVar)(type) && type.shared.recursiveAlias?.name && type.shared.boundType) {
             const unspecializedType = types_1.TypeBase.isInstance(type)
                 ? convertToInstance(type.shared.boundType)
                 : type.shared.boundType;
-            if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) || !type.shared.recursiveAlias.typeParams) {
+            if (!aliasInfo?.typeArgs || !type.shared.recursiveAlias.typeParams) {
                 return transformPossibleRecursiveTypeAlias(unspecializedType, recursionCount);
             }
             const solution = buildSolution(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs);
@@ -895,14 +887,14 @@ function selfSpecializeClass(type, options) {
     if (type.shared.typeParams.length === 0) {
         return type;
     }
-    if (type.priv.typeArgs && !(options === null || options === void 0 ? void 0 : options.overrideTypeArgs)) {
+    if (type.priv.typeArgs && !options?.overrideTypeArgs) {
         return type;
     }
     const typeParams = type.shared.typeParams.map((typeParam) => {
         if ((0, types_1.isTypeVarTuple)(typeParam)) {
             typeParam = types_1.TypeVarType.cloneForUnpacked(typeParam);
         }
-        return (options === null || options === void 0 ? void 0 : options.useBoundTypeVars) ? types_1.TypeVarType.cloneAsBound(typeParam) : typeParam;
+        return options?.useBoundTypeVars ? types_1.TypeVarType.cloneAsBound(typeParam) : typeParam;
     });
     return types_1.ClassType.specialize(type, typeParams);
 }
@@ -1014,19 +1006,17 @@ function getLiteralTypeClassName(type) {
     return undefined;
 }
 function stripTypeForm(type) {
-    var _a;
-    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+    if (type.props?.typeForm) {
         return types_1.TypeBase.cloneWithTypeForm(type, undefined);
     }
     return type;
 }
 function stripTypeFormRecursive(type, recursionCount = 0) {
-    var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return type;
     }
     recursionCount++;
-    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+    if (type.props?.typeForm) {
         type = types_1.TypeBase.cloneWithTypeForm(type, undefined);
     }
     return mapSubtypes(type, (subtype) => stripTypeFormRecursive(subtype, recursionCount));
@@ -1098,8 +1088,7 @@ function isTupleClass(type) {
 // the form tuple[x, ...] where the number of elements
 // in the tuple is unknown.
 function isUnboundedTupleClass(type) {
-    var _a;
-    return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
+    return type.priv.tupleTypeArgs?.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
 }
 // Indicates whether the specified index is within range and its type is unambiguous
 // in that it doesn't involve any element ranges that are of indeterminate length.
@@ -1303,14 +1292,13 @@ function lookUpObjectMember(objectType, memberName, flags = 0 /* MemberAccessFla
 // Looks up a member in a class using the multiple-inheritance rules
 // defined by Python.
 function lookUpClassMember(classType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
-    var _a, _b;
     // Look in the metaclass first.
     const metaclass = classType.shared.effectiveMetaclass;
     // Skip the "type" class as an optimization because it is known to not
     // define any instance variables, and it's by far the most common metaclass.
     if (metaclass && (0, types_1.isClass)(metaclass) && !types_1.ClassType.isBuiltIn(metaclass, 'type')) {
         const metaMemberItr = getClassMemberIterator(metaclass, memberName, 32 /* MemberAccessFlags.SkipClassMembers */);
-        const metaMember = (_a = metaMemberItr.next()) === null || _a === void 0 ? void 0 : _a.value;
+        const metaMember = metaMemberItr.next()?.value;
         // If the metaclass defines the member and we didn't hit an Unknown
         // class in the metaclass MRO, use the metaclass member.
         if (metaMember && !(0, types_1.isAnyOrUnknown)(metaMember.classType)) {
@@ -1321,7 +1309,7 @@ function lookUpClassMember(classType, memberName, flags = 0 /* MemberAccessFlags
         }
     }
     const memberItr = getClassMemberIterator(classType, memberName, flags, skipMroClass);
-    return (_b = memberItr.next()) === null || _b === void 0 ? void 0 : _b.value;
+    return memberItr.next()?.value;
 }
 // Iterates members in a class matching memberName using the multiple-inheritance rules.
 // For more details, see this note on method resolution
@@ -1471,13 +1459,12 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
 // Checks for whether the member is effectively read only because it
 // belongs to a frozen dataclass or a named tuple.
 function isMemberReadOnly(classType, name) {
-    var _a;
     if (types_1.ClassType.hasNamedTupleEntry(classType, name)) {
         return true;
     }
     if (types_1.ClassType.isDataClassFrozen(classType)) {
-        const dcEntries = (_a = classType.shared) === null || _a === void 0 ? void 0 : _a.dataClassEntries;
-        if (dcEntries === null || dcEntries === void 0 ? void 0 : dcEntries.some((entry) => entry.name === name)) {
+        const dcEntries = classType.shared?.dataClassEntries;
+        if (dcEntries?.some((entry) => entry.name === name)) {
             return true;
         }
     }
@@ -1575,16 +1562,15 @@ function addTypeVarsToListIfUnique(list1, list2, typeVarScopeId) {
 // Union[List[Dict[_T1, _T2]], _T1, _T3], the result would be
 // [_T1, _T2, _T3].
 function getTypeVarArgsRecursive(type, recursionCount = 0) {
-    var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return [];
     }
     recursionCount++;
-    const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+    const aliasInfo = type.props?.typeAliasInfo;
     if (aliasInfo) {
         const combinedList = [];
         if (aliasInfo.typeArgs) {
-            aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs.forEach((typeArg) => {
+            aliasInfo?.typeArgs.forEach((typeArg) => {
                 addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(typeArg, recursionCount));
             });
             return combinedList;
@@ -1719,9 +1705,8 @@ function derivesFromClassRecursive(classType, baseClassToFind, ignoreUnknown) {
     return false;
 }
 function synthesizeTypeVarForSelfCls(classType, isClsParam) {
-    var _a;
     const selfType = types_1.TypeVarType.createInstance(`__type_of_self__`);
-    const scopeId = (_a = getTypeVarScopeId(classType)) !== null && _a !== void 0 ? _a : '';
+    const scopeId = getTypeVarScopeId(classType) ?? '';
     selfType.shared.isSynthesized = true;
     selfType.shared.isSynthesizedSelf = true;
     selfType.priv.scopeId = scopeId;
@@ -1790,7 +1775,7 @@ function isEffectivelyInstantiable(type, options, recursionCount = 0) {
     if (types_1.TypeBase.isInstantiable(type)) {
         return true;
     }
-    if ((options === null || options === void 0 ? void 0 : options.honorTypeVarBounds) && (0, types_1.isTypeVar)(type) && type.shared.boundType) {
+    if (options?.honorTypeVarBounds && (0, types_1.isTypeVar)(type) && type.shared.boundType) {
         if (isEffectivelyInstantiable(type.shared.boundType, options, recursionCount)) {
             return true;
         }
@@ -1806,9 +1791,8 @@ function isEffectivelyInstantiable(type, options, recursionCount = 0) {
     return false;
 }
 function convertToInstance(type, includeSubclasses = true) {
-    var _a, _b;
     // See if we've already performed this conversion and cached it.
-    if (((_a = type.cached) === null || _a === void 0 ? void 0 : _a.instanceType) && includeSubclasses) {
+    if (type.cached?.instanceType && includeSubclasses) {
         return type.cached.instanceType;
     }
     let result = mapSubtypes(type, (subtype) => {
@@ -1864,7 +1848,7 @@ function convertToInstance(type, includeSubclasses = true) {
         skipElideRedundantLiterals: true,
     });
     // Copy over any type alias information.
-    const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
+    const aliasInfo = type.props?.typeAliasInfo;
     if (aliasInfo && type !== result) {
         result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo);
     }
@@ -1878,9 +1862,8 @@ function convertToInstance(type, includeSubclasses = true) {
     return result;
 }
 function convertToInstantiable(type, includeSubclasses = true) {
-    var _a;
     // See if we've already performed this conversion and cached it.
-    if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.instantiableType) {
+    if (type.cached?.instantiableType) {
         return type.cached.instantiableType;
     }
     const result = mapSubtypes(type, (subtype) => {
@@ -2036,7 +2019,6 @@ function containsAnyOrUnknown(type, recurse) {
 // and allocating a memory walker object for every call significantly increases
 // peak memory usage.
 function isPartlyUnknown(type, recursionCount = 0) {
-    var _a, _b;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return false;
     }
@@ -2046,8 +2028,8 @@ function isPartlyUnknown(type, recursionCount = 0) {
     }
     // If this is a generic type alias, see if any of its type arguments
     // are either unspecified or are partially known.
-    const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) {
+    const aliasInfo = type.props?.typeAliasInfo;
+    if (aliasInfo?.typeArgs) {
         if (aliasInfo.typeArgs.some((typeArg) => isPartlyUnknown(typeArg, recursionCount))) {
             return true;
         }
@@ -2065,7 +2047,7 @@ function isPartlyUnknown(type, recursionCount = 0) {
             return false;
         }
         if (!types_1.ClassType.isPseudoGenericClass(type)) {
-            const typeArgs = ((_b = type.priv.tupleTypeArgs) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.priv.typeArgs;
+            const typeArgs = type.priv.tupleTypeArgs?.map((t) => t.type) || type.priv.typeArgs;
             if (typeArgs) {
                 for (const argType of typeArgs) {
                     if (isPartlyUnknown(argType, recursionCount)) {
@@ -2229,7 +2211,6 @@ function makeUnpacked(type) {
 // If the declared return type for the function is a Generator or AsyncGenerator,
 // returns the type arguments for the type.
 function getGeneratorTypeArgs(returnType) {
-    var _a;
     if ((0, types_1.isClassInstance)(returnType)) {
         if (types_1.ClassType.isBuiltIn(returnType, ['Generator', 'AsyncGenerator'])) {
             return returnType.priv.typeArgs;
@@ -2237,7 +2218,7 @@ function getGeneratorTypeArgs(returnType) {
         else if (types_1.ClassType.isBuiltIn(returnType, 'AwaitableGenerator')) {
             // AwaitableGenerator has four type arguments, and the first 3
             // correspond to the generator.
-            return (_a = returnType.priv.typeArgs) === null || _a === void 0 ? void 0 : _a.slice(0, 3);
+            return returnType.priv.typeArgs?.slice(0, 3);
         }
     }
     return undefined;
@@ -2280,14 +2261,13 @@ function requiresTypeArgs(classType) {
     return false;
 }
 function requiresSpecialization(type, options, recursionCount = 0) {
-    var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return false;
     }
     recursionCount++;
     // Is the answer cached?
-    const canUseCache = !(options === null || options === void 0 ? void 0 : options.ignorePseudoGeneric) && !(options === null || options === void 0 ? void 0 : options.ignoreSelf);
-    if (canUseCache && ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.requiresSpecialization) !== undefined) {
+    const canUseCache = !options?.ignorePseudoGeneric && !options?.ignoreSelf;
+    if (canUseCache && type.cached?.requiresSpecialization !== undefined) {
         return type.cached.requiresSpecialization;
     }
     const result = _requiresSpecialization(type, options, recursionCount);
@@ -2300,17 +2280,16 @@ function requiresSpecialization(type, options, recursionCount = 0) {
     return result;
 }
 function _requiresSpecialization(type, options, recursionCount = 0) {
-    var _a, _b;
     // If the type is conditioned on a TypeVar, it may need to be specialized.
-    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition) {
+    if (type.props?.condition) {
         return true;
     }
     switch (type.category) {
         case 6 /* TypeCategory.Class */: {
-            if (types_1.ClassType.isPseudoGenericClass(type) && (options === null || options === void 0 ? void 0 : options.ignorePseudoGeneric)) {
+            if (types_1.ClassType.isPseudoGenericClass(type) && options?.ignorePseudoGeneric) {
                 return false;
             }
-            if (!type.priv.isTypeArgExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
+            if (!type.priv.isTypeArgExplicit && options?.ignoreImplicitTypeArgs) {
                 return false;
             }
             if (type.priv.tupleTypeArgs) {
@@ -2361,15 +2340,15 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
         case 9 /* TypeCategory.TypeVar */: {
             // Most TypeVar types need to be specialized.
             if (!type.shared.recursiveAlias) {
-                if (types_1.TypeVarType.isSelf(type) && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
+                if (types_1.TypeVarType.isSelf(type) && options?.ignoreSelf) {
                     return false;
                 }
                 return true;
             }
             // If this is a recursive type alias, it may need to be specialized
             // if it has generic type arguments.
-            const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
-            if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) {
+            const aliasInfo = type.props?.typeAliasInfo;
+            if (aliasInfo?.typeArgs) {
                 return aliasInfo.typeArgs.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
             }
         }
@@ -2441,7 +2420,7 @@ function isVarianceOfTypeArgCompatible(type, typeParamVariance) {
                         effectiveVariance = 3 /* Variance.Covariant */;
                     }
                 }
-                return isVarianceOfTypeArgCompatible(typeArgType !== null && typeArgType !== void 0 ? typeArgType : types_1.UnknownType.create(), effectiveVariance);
+                return isVarianceOfTypeArgCompatible(typeArgType ?? types_1.UnknownType.create(), effectiveVariance);
             });
         }
     }
@@ -2683,7 +2662,6 @@ class TypeVarTransformer {
         return this._pendingTypeVarTransformations;
     }
     apply(type, recursionCount) {
-        var _a, _b, _c;
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return type;
         }
@@ -2691,7 +2669,7 @@ class TypeVarTransformer {
         type = this.transformGenericTypeAlias(type, recursionCount);
         // If the type is conditioned on a type variable, see if the condition
         // still applies.
-        if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition) {
+        if (type.props?.condition) {
             type = this.transformConditionalType(type, recursionCount);
         }
         // Shortcut the operation if possible.
@@ -2708,9 +2686,9 @@ class TypeVarTransformer {
             // Handle recursive type aliases specially. In particular,
             // we need to specialize type arguments for generic recursive
             // type aliases.
-            const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
+            const aliasInfo = type.props?.typeAliasInfo;
             if (type.shared.recursiveAlias) {
-                if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs)) {
+                if (!aliasInfo?.typeArgs) {
                     return type;
                 }
                 let requiresUpdate = false;
@@ -2738,7 +2716,7 @@ class TypeVarTransformer {
                     paramSpecAccess = type.priv.paramSpecAccess;
                     type = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
                 }
-                replacementType = (_c = this.transformTypeVar(type, recursionCount)) !== null && _c !== void 0 ? _c : type;
+                replacementType = this.transformTypeVar(type, recursionCount) ?? type;
                 if ((0, types_1.isParamSpec)(type) && replacementType !== type) {
                     replacementType = simplifyFunctionToParamSpec(convertTypeToParamSpecValue(replacementType));
                 }
@@ -2851,8 +2829,7 @@ class TypeVarTransformer {
         return callback();
     }
     transformGenericTypeAlias(type, recursionCount) {
-        var _a;
-        const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        const aliasInfo = type.props?.typeAliasInfo;
         if (!aliasInfo || !aliasInfo.shared.typeParams || !aliasInfo.typeArgs) {
             return type;
         }
@@ -2871,7 +2848,6 @@ class TypeVarTransformer {
         return type;
     }
     transformTypeVarsInClassType(classType, recursionCount) {
-        var _a;
         const typeParams = types_1.ClassType.getTypeParams(classType);
         // Handle the common case where the class has no type parameters.
         if (typeParams.length === 0 &&
@@ -2941,7 +2917,7 @@ class TypeVarTransformer {
             }
         }
         if (!newTypeArgs) {
-            const typeArgs = (_a = classType.priv.typeArgs) !== null && _a !== void 0 ? _a : typeParams;
+            const typeArgs = classType.priv.typeArgs ?? typeParams;
             if (!classType.priv.typeArgs) {
                 isTypeArgExplicit = false;
             }
@@ -3227,8 +3203,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         this._isSolvingDefaultType = false;
     }
     transformTypeVar(typeVar, recursionCount) {
-        var _a, _b, _c;
-        const solutionSet = this._solution.getSolutionSet((_a = this._activeConstraintSetIndex) !== null && _a !== void 0 ? _a : 0);
+        const solutionSet = this._solution.getSolutionSet(this._activeConstraintSetIndex ?? 0);
         // If we're solving a default type, handle type variables with no scope ID.
         if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
             const replacement = this._getReplacementForDefaultByName(typeVar, solutionSet);
@@ -3312,22 +3287,21 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             return undefined;
         }
         // Use the default value if there is one.
-        if (typeVar.shared.isDefaultExplicit && !((_b = this._options.replaceUnsolved) === null || _b === void 0 ? void 0 : _b.useUnknown)) {
+        if (typeVar.shared.isDefaultExplicit && !this._options.replaceUnsolved?.useUnknown) {
             return this._solveDefaultType(typeVar, recursionCount);
         }
-        return getUnknownForTypeVar(typeVar, (_c = this._options.replaceUnsolved) === null || _c === void 0 ? void 0 : _c.tupleClassType);
+        return getUnknownForTypeVar(typeVar, this._options.replaceUnsolved?.tupleClassType);
     }
     transformUnionSubtype(preTransform, postTransform) {
-        var _a, _b, _c;
         // If a union contains unsolved TypeVars within scope, eliminate them
         // unless this results in an empty union. This elimination is needed
         // in cases where TypeVars can go unsolved due to unions in parameter
         // annotations, like this:
         //   def test(x: Union[str, T]) -> Union[str, T]
-        if (!((_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.eliminateUnsolvedInUnions)) {
+        if (!this._options.replaceUnsolved?.eliminateUnsolvedInUnions) {
             return postTransform;
         }
-        const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
+        const solutionSet = this._solution.getSolutionSet(this._activeConstraintSetIndex ?? 0);
         if ((0, types_1.isTypeVar)(preTransform)) {
             if (!this._shouldReplaceTypeVar(preTransform) || !this._shouldReplaceUnsolvedTypeVar(preTransform)) {
                 return postTransform;
@@ -3350,7 +3324,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                 return undefined;
             }
         }
-        else if ((_c = preTransform.props) === null || _c === void 0 ? void 0 : _c.condition) {
+        else if (preTransform.props?.condition) {
             // If this is a type that is conditioned on a unification TypeVar,
             // see if TypeVar was solved. If not, eliminate the type.
             for (const condition of preTransform.props.condition) {
@@ -3362,7 +3336,6 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return postTransform;
     }
     transformTupleTypeVar(typeVar) {
-        var _a;
         if (!this._shouldReplaceTypeVar(typeVar)) {
             const defaultType = typeVar.shared.defaultType;
             if (typeVar.shared.isDefaultExplicit && (0, types_1.isClassInstance)(defaultType) && defaultType.priv.tupleTypeArgs) {
@@ -3370,7 +3343,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             }
             return undefined;
         }
-        const solutionSet = this._solution.getSolutionSet((_a = this._activeConstraintSetIndex) !== null && _a !== void 0 ? _a : 0);
+        const solutionSet = this._solution.getSolutionSet(this._activeConstraintSetIndex ?? 0);
         const value = solutionSet.getType(typeVar);
         if (value && (0, types_1.isClassInstance)(value) && value.priv.tupleTypeArgs && (0, types_1.isUnpackedClass)(value)) {
             return value.priv.tupleTypeArgs;
@@ -3378,17 +3351,16 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return undefined;
     }
     transformConditionalType(type, recursionCount) {
-        var _a, _b, _c, _d;
-        if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition)) {
+        if (!type.props?.condition) {
             return type;
         }
-        const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
+        const solutionSet = this._solution.getSolutionSet(this._activeConstraintSetIndex ?? 0);
         for (const condition of type.props.condition) {
             // This doesn't apply to bound type variables.
             if (!types_1.TypeVarType.hasConstraints(condition.typeVar)) {
                 continue;
             }
-            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.freeTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
+            const conditionTypeVar = condition.typeVar.priv?.freeTypeVar ?? condition.typeVar;
             const replacement = solutionSet.getType(conditionTypeVar);
             if (!replacement || condition.constraintIndex >= conditionTypeVar.shared.constraints.length) {
                 continue;
@@ -3456,7 +3428,6 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return true;
     }
     _shouldReplaceUnsolvedTypeVar(typeVar) {
-        var _a;
         // Never replace nested TypeVars with unknown.
         if (this.pendingTypeVarTransformations.size > 0) {
             return false;
@@ -3470,7 +3441,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         if (!this._options.replaceUnsolved.scopeIds.includes(typeVar.priv.scopeId)) {
             return false;
         }
-        const exemptTypeVars = (_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.unsolvedExemptTypeVars;
+        const exemptTypeVars = this._options.replaceUnsolved?.unsolvedExemptTypeVars;
         if (exemptTypeVars) {
             if (exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeVar, { ignoreTypeFlags: true }))) {
                 return false;
@@ -3500,7 +3471,7 @@ class UnificationTypeTransformer extends TypeVarTransformer {
         return undefined;
     }
     _isTypeVarLive(typeVar) {
-        return this._liveTypeVarScopes.some((scopeId) => { var _a; return typeVar.priv.scopeId === scopeId || ((_a = typeVar.priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) === scopeId; });
+        return this._liveTypeVarScopes.some((scopeId) => typeVar.priv.scopeId === scopeId || typeVar.priv.freeTypeVar?.priv.scopeId === scopeId);
     }
 }
 //# sourceMappingURL=typeUtils.js.map