@zzzen/pyright-internal 1.2.0-dev.20241208 → 1.2.0-dev.20241222

package/dist/analyzer/types.js

@@ -130,8 +130,7 @@ var TypeBase;
     }
     TypeBase.addProps = addProps;
     function getInstantiableDepth(type) {
-        var _a, _b;
-        return (_b = (_a = type.props) === null || _a === void 0 ? void 0 : _a.instantiableDepth) !== null && _b !== void 0 ? _b : 0;
+        return type.props?.instantiableDepth ?? 0;
     }
     TypeBase.getInstantiableDepth = getInstantiableDepth;
     function setSpecialForm(type, specialForm) {
@@ -173,14 +172,13 @@ var TypeBase;
     }
     TypeBase.cloneAsSpecialForm = cloneAsSpecialForm;
     function cloneTypeAsInstance(type, cache) {
-        var _a, _b;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
         const newInstance = TypeBase.cloneType(type);
         // Remove type form information from the type.
-        if ((_a = newInstance.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+        if (newInstance.props?.typeForm) {
             TypeBase.setTypeForm(newInstance, undefined);
         }
-        const depth = (_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.instantiableDepth;
+        const depth = newInstance.props?.instantiableDepth;
         if (depth === undefined) {
             newInstance.flags &= ~1 /* TypeFlags.Instantiable */;
             newInstance.flags |= 2 /* TypeFlags.Instance */;
@@ -202,23 +200,22 @@ var TypeBase;
     }
     TypeBase.cloneTypeAsInstance = cloneTypeAsInstance;
     function cloneTypeAsInstantiable(type, cache) {
-        var _a, _b, _c;
         const newInstance = TypeBase.cloneType(type);
         if (TypeBase.isInstance(type)) {
             newInstance.flags &= ~2 /* TypeFlags.Instance */;
             newInstance.flags |= 1 /* TypeFlags.Instantiable */;
         }
         else {
-            const oldDepth = (_a = type.props) === null || _a === void 0 ? void 0 : _a.instantiableDepth;
+            const oldDepth = type.props?.instantiableDepth;
             TypeBase.setInstantiableDepth(newInstance, oldDepth === undefined ? 1 : oldDepth + 1);
         }
         // Remove type alias information because the type will no longer match
         // that of the type alias definition.
-        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) {
+        if (newInstance.props?.typeAliasInfo) {
             TypeBase.setTypeAliasInfo(newInstance, undefined);
         }
         // Remove type form information from the type.
-        if ((_c = newInstance.props) === null || _c === void 0 ? void 0 : _c.typeForm) {
+        if (newInstance.props?.typeForm) {
             TypeBase.setTypeForm(newInstance, undefined);
         }
         // Should we cache it for next time?
@@ -244,10 +241,9 @@ var TypeBase;
     }
     TypeBase.cloneWithTypeForm = cloneWithTypeForm;
     function cloneForCondition(type, condition) {
-        var _a;
         // Handle the common case where there are no conditions. In this case,
         // cloning isn't necessary.
-        if (((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition) === undefined && condition === undefined) {
+        if (type.props?.condition === undefined && condition === undefined) {
             return type;
         }
         const typeClone = cloneType(type);
@@ -281,9 +277,8 @@ var UnboundType;
     }
     UnboundType.create = create;
     function convertToInstance(type) {
-        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        return ((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) ? UnboundType.create() : type;
+        return type.props?.specialForm ? UnboundType.create() : type;
     }
     UnboundType.convertToInstance = convertToInstance;
 })(UnboundType || (exports.UnboundType = UnboundType = {}));
@@ -331,9 +326,8 @@ var UnknownType;
     }
     UnknownType.createPossibleType = createPossibleType;
     function convertToInstance(type) {
-        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        return ((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) ? UnknownType.create(type.priv.isIncomplete) : type;
+        return type.props?.specialForm ? UnknownType.create(type.priv.isIncomplete) : type;
     }
     UnknownType.convertToInstance = convertToInstance;
 })(UnknownType || (exports.UnknownType = UnknownType = {}));
@@ -488,15 +482,14 @@ var ClassType;
     }
     ClassType.createInstantiable = createInstantiable;
     function cloneAsInstance(type, includeSubclasses = true) {
-        var _a, _b;
         if (TypeBase.isInstance(type)) {
             return type;
         }
-        if (includeSubclasses && ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType)) {
+        if (includeSubclasses && type.cached?.typeBaseInstanceType) {
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ includeSubclasses);
-        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+        if (newInstance.props?.specialForm) {
             TypeBase.setSpecialForm(newInstance, undefined);
         }
         if (includeSubclasses) {
@@ -506,8 +499,7 @@ var ClassType;
     }
     ClassType.cloneAsInstance = cloneAsInstance;
     function cloneAsInstantiable(type, includeSubclasses = true) {
-        var _a;
-        if (includeSubclasses && ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstantiableType)) {
+        if (includeSubclasses && type.cached?.typeBaseInstantiableType) {
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, includeSubclasses);
@@ -519,7 +511,7 @@ var ClassType;
     ClassType.cloneAsInstantiable = cloneAsInstantiable;
     function specialize(classType, typeArgs, isTypeArgExplicit, includeSubclasses = false, tupleTypeArgs, isEmptyContainer) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.priv.typeArgs = (typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) === 0 ? undefined : typeArgs;
+        newClassType.priv.typeArgs = typeArgs?.length === 0 ? undefined : typeArgs;
         // If the user passed undefined for this argument, infer it
         // based on whether typeArgs was provided.
         if (isTypeArgExplicit === undefined) {
@@ -546,12 +538,11 @@ var ClassType;
     }
     ClassType.cloneIncludeSubclasses = cloneIncludeSubclasses;
     function cloneWithLiteral(classType, value) {
-        var _a;
         const newClassType = TypeBase.cloneType(classType);
         newClassType.priv.literalValue = value;
         // Remove type alias information because the type will no longer match
         // that of the type alias definition if we change the literal type.
-        if ((_a = newClassType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+        if (newClassType.props?.typeAliasInfo) {
             TypeBase.setTypeAliasInfo(newClassType, undefined);
         }
         return newClassType;
@@ -674,18 +665,17 @@ var ClassType;
     // i.e. all of the "narrowed entries" found within type2 are also found
     // within type1.
     function isTypedDictNarrower(type1, type2) {
-        var _a;
         const tdEntries2 = type2.priv.typedDictNarrowedEntries;
         if (!tdEntries2) {
             return true;
         }
-        const tdEntries1 = (_a = type1.priv.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : new Map();
+        const tdEntries1 = type1.priv.typedDictNarrowedEntries ?? new Map();
         let key;
         let entry2;
         for ([key, entry2] of tdEntries2.entries()) {
             if (entry2.isProvided) {
                 const entry1 = tdEntries1.get(key);
-                if (!(entry1 === null || entry1 === void 0 ? void 0 : entry1.isProvided)) {
+                if (!entry1?.isProvided) {
                     return false;
                 }
             }
@@ -730,38 +720,31 @@ var ClassType;
     }
     ClassType.isDataClass = isDataClass;
     function isDataClassSkipGenerateInit(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateInit);
+        return !!classType.shared.dataClassBehaviors?.skipGenerateInit;
     }
     ClassType.isDataClassSkipGenerateInit = isDataClassSkipGenerateInit;
     function isDataClassSkipGenerateEq(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateEq);
+        return !!classType.shared.dataClassBehaviors?.skipGenerateEq;
     }
     ClassType.isDataClassSkipGenerateEq = isDataClassSkipGenerateEq;
     function isDataClassFrozen(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.frozen);
+        return !!classType.shared.dataClassBehaviors?.frozen;
     }
     ClassType.isDataClassFrozen = isDataClassFrozen;
     function isDataClassGenerateOrder(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateOrder);
+        return !!classType.shared.dataClassBehaviors?.generateOrder;
     }
     ClassType.isDataClassGenerateOrder = isDataClassGenerateOrder;
     function isDataClassKeywordOnly(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.keywordOnly);
+        return !!classType.shared.dataClassBehaviors?.keywordOnly;
     }
     ClassType.isDataClassKeywordOnly = isDataClassKeywordOnly;
     function isDataClassGenerateSlots(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateSlots);
+        return !!classType.shared.dataClassBehaviors?.generateSlots;
     }
     ClassType.isDataClassGenerateSlots = isDataClassGenerateSlots;
     function isDataClassGenerateHash(classType) {
-        var _a;
-        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateHash);
+        return !!classType.shared.dataClassBehaviors?.generateHash;
     }
     ClassType.isDataClassGenerateHash = isDataClassGenerateHash;
     function isTypeCheckOnly(classType) {
@@ -829,8 +812,7 @@ var ClassType;
     }
     ClassType.isPseudoGenericClass = isPseudoGenericClass;
     function getDataClassEntries(classType) {
-        var _a, _b;
-        (_b = (_a = classType.shared).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
+        classType.shared.synthesizeMethodsDeferred?.();
         return classType.shared.dataClassEntries || [];
     }
     ClassType.getDataClassEntries = getDataClassEntries;
@@ -863,17 +845,15 @@ var ClassType;
     }
     ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
     function getSymbolTable(classType) {
-        var _a, _b;
-        (_b = (_a = classType.shared).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
+        classType.shared.synthesizeMethodsDeferred?.();
         return classType.shared.fields;
     }
     ClassType.getSymbolTable = getSymbolTable;
     function getInheritedSlotsNames(classType) {
-        var _a, _b, _c, _d;
         // First synthesize methods if needed. The slots entries
         // can depend on synthesized methods.
-        (_b = (_a = classType.shared).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
-        (_d = (_c = classType.shared).calculateInheritedSlotsNamesDeferred) === null || _d === void 0 ? void 0 : _d.call(_c);
+        classType.shared.synthesizeMethodsDeferred?.();
+        classType.shared.calculateInheritedSlotsNamesDeferred?.();
         return classType.shared.inheritedSlotsNamesCached;
     }
     ClassType.getInheritedSlotsNames = getInheritedSlotsNames;
@@ -1147,7 +1127,6 @@ var FunctionType;
     // Creates a deep copy of the function type, including a fresh
     // version of _functionDetails.
     function clone(type, stripFirstParam = false, boundToType) {
-        var _a, _b;
         const newFunction = TypeBase.cloneType(type);
         newFunction.shared = { ...type.shared };
         newFunction.priv.preBoundFlags = newFunction.shared.flags;
@@ -1176,7 +1155,7 @@ var FunctionType;
             newFunction.shared.flags &= ~(1 /* FunctionTypeFlags.ConstructorMethod */ | 2 /* FunctionTypeFlags.ClassMethod */);
             newFunction.shared.flags |= 4 /* FunctionTypeFlags.StaticMethod */;
         }
-        if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+        if (type.props?.typeAliasInfo) {
             TypeBase.setTypeAliasInfo(newFunction, type.props.typeAliasInfo);
         }
         if (type.priv.specializedTypes) {
@@ -1185,7 +1164,7 @@ var FunctionType;
                     ? type.priv.specializedTypes.parameterTypes.slice(1)
                     : type.priv.specializedTypes.parameterTypes,
                 parameterDefaultTypes: stripFirstParam
-                    ? (_b = type.priv.specializedTypes.parameterDefaultTypes) === null || _b === void 0 ? void 0 : _b.slice(1)
+                    ? type.priv.specializedTypes.parameterDefaultTypes?.slice(1)
                     : type.priv.specializedTypes.parameterDefaultTypes,
                 returnType: type.priv.specializedTypes.returnType,
             };
@@ -1195,20 +1174,18 @@ var FunctionType;
     }
     FunctionType.clone = clone;
     function cloneAsInstance(type) {
-        var _a, _b;
-        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType) {
+        if (type.cached?.typeBaseInstanceType) {
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ true);
-        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+        if (newInstance.props?.specialForm) {
             TypeBase.setSpecialForm(newInstance, undefined);
         }
         return newInstance;
     }
     FunctionType.cloneAsInstance = cloneAsInstance;
     function cloneAsInstantiable(type) {
-        var _a;
-        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstantiableType) {
+        if (type.cached?.typeBaseInstantiableType) {
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, /* cache */ true);
@@ -1273,10 +1250,9 @@ var FunctionType;
         const specializedTypes = newFunction.priv.specializedTypes;
         if (specializedTypes) {
             paramSpecValue.shared.parameters.forEach((_, index) => {
-                var _a;
                 specializedTypes.parameterTypes.push(FunctionType.getParamType(paramSpecValue, index));
                 if (specializedTypes.parameterDefaultTypes) {
-                    (_a = specializedTypes.parameterDefaultTypes) === null || _a === void 0 ? void 0 : _a.push(FunctionType.getParamDefaultType(paramSpecValue, index));
+                    specializedTypes.parameterDefaultTypes?.push(FunctionType.getParamDefaultType(paramSpecValue, index));
                 }
             });
         }
@@ -1538,9 +1514,8 @@ var FunctionType;
     }
     FunctionType.getParamType = getParamType;
     function getParamDefaultType(type, index) {
-        var _a;
         (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
-        if (((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultTypes) &&
+        if (type.priv.specializedTypes?.parameterDefaultTypes &&
             index < type.priv.specializedTypes.parameterDefaultTypes.length) {
             const defaultArgType = type.priv.specializedTypes.parameterDefaultTypes[index];
             if (defaultArgType) {
@@ -1566,8 +1541,7 @@ var FunctionType;
     }
     FunctionType.addKeywordOnlyParamSeparator = addKeywordOnlyParamSeparator;
     function getEffectiveReturnType(type, includeInferred = true) {
-        var _a;
-        if ((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.returnType) {
+        if (type.priv.specializedTypes?.returnType) {
             return type.priv.specializedTypes.returnType;
         }
         if (type.shared.declaredReturnType) {
@@ -1645,9 +1619,8 @@ var NeverType;
     }
     NeverType.createNoReturn = createNoReturn;
     function convertToInstance(type) {
-        var _a, _b;
         // Remove the specialForm or typeForm if present. Otherwise return the existing type.
-        if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) && !((_b = type.props) === null || _b === void 0 ? void 0 : _b.typeForm)) {
+        if (!type.props?.specialForm && !type.props?.typeForm) {
             return type;
         }
         return type.priv.isNoReturn ? NeverType.createNoReturn() : NeverType.createNever();
@@ -1691,9 +1664,8 @@ var AnyType;
 })(AnyType || (exports.AnyType = AnyType = {}));
 (function (AnyType) {
     function convertToInstance(type) {
-        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        return ((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) ? AnyType.create() : type;
+        return type.props?.specialForm ? AnyType.create() : type;
     }
     AnyType.convertToInstance = convertToInstance;
 })(AnyType || (exports.AnyType = AnyType = {}));
@@ -1797,11 +1769,10 @@ var UnionType;
     }
     UnionType.create = create;
     function addType(unionType, newType) {
-        var _a, _b;
         // If we're adding a string, integer or enum literal, add it to the
         // corresponding literal map to speed up some operations. It's not
         // uncommon for unions to contain hundreds of literals.
-        if (isClass(newType) && newType.priv.literalValue !== undefined && !((_a = newType.props) === null || _a === void 0 ? void 0 : _a.condition)) {
+        if (isClass(newType) && newType.priv.literalValue !== undefined && !newType.props?.condition) {
             const literalMaps = isClassInstance(newType)
                 ? unionType.priv.literalInstances
                 : unionType.priv.literalClasses;
@@ -1827,7 +1798,7 @@ var UnionType;
         }
         unionType.flags &= newType.flags;
         unionType.priv.subtypes.push(newType);
-        if (isTypeVar(newType) && ((_b = newType.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name)) {
+        if (isTypeVar(newType) && newType.shared.recursiveAlias?.name) {
             // Note that at least one recursive type alias was included in
             // this union. We'll need to expand it before the union is used.
             unionType.priv.includesRecursiveTypeAlias = true;
@@ -1838,10 +1809,9 @@ var UnionType;
     // the method skips any subtype indexes that are in the set and adds a found index to
     // the exclusion set. This speeds up union type comparisons.
     function containsType(unionType, subtype, options = {}, exclusionSet, recursionCount = 0) {
-        var _a;
         // Handle string literals as a special case because unions can sometimes
         // contain hundreds of string literal types.
-        if (isClass(subtype) && ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) === undefined && subtype.priv.literalValue !== undefined) {
+        if (isClass(subtype) && subtype.props?.condition === undefined && subtype.priv.literalValue !== undefined) {
             const literalMaps = isClassInstance(subtype)
                 ? unionType.priv.literalInstances
                 : unionType.priv.literalClasses;
@@ -1857,7 +1827,7 @@ var UnionType;
             }
         }
         const foundIndex = unionType.priv.subtypes.findIndex((t, i) => {
-            if (exclusionSet === null || exclusionSet === void 0 ? void 0 : exclusionSet.has(i)) {
+            if (exclusionSet?.has(i)) {
                 return false;
             }
             return isTypeSame(t, subtype, options, recursionCount);
@@ -1865,14 +1835,13 @@ var UnionType;
         if (foundIndex < 0) {
             return false;
         }
-        exclusionSet === null || exclusionSet === void 0 ? void 0 : exclusionSet.add(foundIndex);
+        exclusionSet?.add(foundIndex);
         return true;
     }
     UnionType.containsType = containsType;
     function addTypeAliasSource(unionType, typeAliasSource) {
-        var _a;
         if (typeAliasSource.category === 8 /* TypeCategory.Union */) {
-            const sourcesToAdd = ((_a = typeAliasSource.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)
+            const sourcesToAdd = typeAliasSource.props?.typeAliasInfo
                 ? [typeAliasSource]
                 : typeAliasSource.priv.typeAliasSources;
             if (sourcesToAdd) {
@@ -1928,13 +1897,12 @@ var TypeVarType;
     }
     TypeVarType.createInstantiable = createInstantiable;
     function cloneAsInstance(type) {
-        var _a, _b;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
-        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType) {
+        if (type.cached?.typeBaseInstanceType) {
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ true);
-        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+        if (newInstance.props?.specialForm) {
             TypeBase.setSpecialForm(newInstance, undefined);
         }
         if (newInstance.priv.freeTypeVar) {
@@ -1944,8 +1912,7 @@ var TypeVarType;
     }
     TypeVarType.cloneAsInstance = cloneAsInstance;
     function cloneAsInstantiable(type) {
-        var _a;
-        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstantiableType) {
+        if (type.cached?.typeBaseInstantiableType) {
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, /* cache */ true);
@@ -1956,19 +1923,18 @@ var TypeVarType;
     }
     TypeVarType.cloneAsInstantiable = cloneAsInstantiable;
     function cloneForNewName(type, name) {
-        var _a;
         const newInstance = TypeBase.cloneType(type);
         newInstance.shared = { ...type.shared };
         newInstance.shared.name = name;
         if (newInstance.priv.scopeId) {
-            newInstance.priv.nameWithScope = makeNameWithScope(name, newInstance.priv.scopeId, (_a = newInstance.priv.scopeName) !== null && _a !== void 0 ? _a : '');
+            newInstance.priv.nameWithScope = makeNameWithScope(name, newInstance.priv.scopeId, newInstance.priv.scopeName ?? '');
         }
         return newInstance;
     }
     TypeVarType.cloneForNewName = cloneForNewName;
     function cloneForScopeId(type, scopeId, scopeName, scopeType) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.nameWithScope = makeNameWithScope(type.shared.name, scopeId, scopeName !== null && scopeName !== void 0 ? scopeName : '');
+        newInstance.priv.nameWithScope = makeNameWithScope(type.shared.name, scopeId, scopeName ?? '');
         newInstance.priv.scopeId = scopeId;
         newInstance.priv.scopeName = scopeName;
         newInstance.priv.scopeType = scopeType;
@@ -2142,8 +2108,7 @@ var TypeVarType;
     }
     TypeVarType.getReadableName = getReadableName;
     function getVariance(type) {
-        var _a;
-        const variance = (_a = type.priv.computedVariance) !== null && _a !== void 0 ? _a : type.shared.declaredVariance;
+        const variance = type.priv.computedVariance ?? type.shared.declaredVariance;
         // By this point, the variance should have been inferred.
         (0, debug_1.assert)(variance !== 0 /* Variance.Auto */, 'Expected variance to be inferred');
         // If we're in the process of computing variance, it will still be
@@ -2249,14 +2214,13 @@ function isOverloaded(type) {
     return type.category === 5 /* TypeCategory.Overloaded */;
 }
 function getTypeAliasInfo(type) {
-    var _a, _b;
-    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+    if (type.props?.typeAliasInfo) {
         return type.props.typeAliasInfo;
     }
     if (isTypeVar(type) &&
         type.shared.recursiveAlias &&
         type.shared.boundType &&
-        ((_b = type.shared.boundType.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo)) {
+        type.shared.boundType.props?.typeAliasInfo) {
         return type.shared.boundType.props.typeAliasInfo;
     }
     return undefined;
@@ -2265,7 +2229,6 @@ function getTypeAliasInfo(type) {
 // type arguments for "pseudo-generic" classes (non-generic classes whose init
 // methods are not annotated and are therefore treated as generic) are ignored.
 function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
     if (type1 === type2) {
         return true;
     }
@@ -2290,8 +2253,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
     }
     recursionCount++;
     if (options.honorTypeForm) {
-        const typeForm1 = (_a = type1.props) === null || _a === void 0 ? void 0 : _a.typeForm;
-        const typeForm2 = (_b = type2.props) === null || _b === void 0 ? void 0 : _b.typeForm;
+        const typeForm1 = type1.props?.typeForm;
+        const typeForm2 = type2.props?.typeForm;
         if (typeForm1) {
             if (!typeForm2) {
                 return false;
@@ -2311,7 +2274,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (!ClassType.isSameGenericClass(type1, classType2, recursionCount)) {
                 return false;
             }
-            if (!options.ignoreConditions && !TypeCondition.isSame((_c = type1.props) === null || _c === void 0 ? void 0 : _c.condition, (_d = type2.props) === null || _d === void 0 ? void 0 : _d.condition)) {
+            if (!options.ignoreConditions && !TypeCondition.isSame(type1.props?.condition, type2.props?.condition)) {
                 return false;
             }
             if (!options.ignorePseudoGeneric || !ClassType.isPseudoGenericClass(type1)) {
@@ -2469,8 +2432,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             // Handle the case where this is a generic recursive type alias. Make
             // sure that the type argument types match.
             if (type1.shared.recursiveAlias && type2TypeVar.shared.recursiveAlias) {
-                const type1TypeArgs = ((_f = (_e = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArgs) || [];
-                const type2TypeArgs = ((_h = (_g = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _g === void 0 ? void 0 : _g.typeAliasInfo) === null || _h === void 0 ? void 0 : _h.typeArgs) || [];
+                const type1TypeArgs = type1?.props?.typeAliasInfo?.typeArgs || [];
+                const type2TypeArgs = type2?.props?.typeAliasInfo?.typeArgs || [];
                 const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
                 for (let i = 0; i < typeArgCount; i++) {
                     // Assume that missing type args are "Any".
@@ -2589,7 +2552,6 @@ function findSubtype(type, filter) {
 // are combined into a UnionType. NeverTypes are filtered out.
 // If no types remain in the end, a NeverType is returned.
 function combineTypes(subtypes, options) {
-    var _a, _b;
     let neverTypes;
     // Filter out any Never or NoReturn types.
     [neverTypes, subtypes] = (0, collectionUtils_1.partition)(subtypes, isNever);
@@ -2597,7 +2559,7 @@ function combineTypes(subtypes, options) {
         if (neverTypes.length > 0) {
             // Prefer NoReturn over Never. This approach preserves type alias
             // information if present.
-            return (_a = neverTypes.find((t) => t.priv.isNoReturn)) !== null && _a !== void 0 ? _a : neverTypes[0];
+            return neverTypes.find((t) => t.priv.isNoReturn) ?? neverTypes[0];
         }
         return NeverType.createNever();
     }
@@ -2625,7 +2587,7 @@ function combineTypes(subtypes, options) {
                 expandedTypes = subtypes.slice(0, i);
             }
             expandedTypes = expandedTypes.concat(subtype.priv.subtypes);
-            if ((_b = subtype.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) {
+            if (subtype.props?.typeAliasInfo) {
                 typeAliasSources.add(subtype);
             }
             else if (subtype.priv.typeAliasSources) {
@@ -2638,7 +2600,7 @@ function combineTypes(subtypes, options) {
             expandedTypes.push(subtype);
         }
     }
-    expandedTypes = expandedTypes !== null && expandedTypes !== void 0 ? expandedTypes : subtypes;
+    expandedTypes = expandedTypes ?? subtypes;
     // Sort all of the literal and empty types to the end.
     expandedTypes = expandedTypes.sort((type1, type2) => {
         if (isClass(type1) && type1.priv.literalValue !== undefined) {
@@ -2670,8 +2632,8 @@ function combineTypes(subtypes, options) {
             UnionType.addType(newUnionType, subtype);
         }
         else {
-            if ((options === null || options === void 0 ? void 0 : options.maxSubtypeCount) === undefined || newUnionType.priv.subtypes.length < options.maxSubtypeCount) {
-                _addTypeIfUnique(newUnionType, subtype, !(options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals));
+            if (options?.maxSubtypeCount === undefined || newUnionType.priv.subtypes.length < options.maxSubtypeCount) {
+                _addTypeIfUnique(newUnionType, subtype, !options?.skipElideRedundantLiterals);
             }
             else {
                 hitMaxSubtypeCount = true;
@@ -2708,11 +2670,10 @@ function isSameWithoutLiteralValue(destType, srcType) {
     return false;
 }
 function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
-    var _a, _b, _c;
     // Handle the addition of a string literal in a special manner to
     // avoid n^2 behavior in unions that contain hundreds of string
     // literal types. Skip this for constrained types.
-    if (isClass(typeToAdd) && !((_a = typeToAdd.props) === null || _a === void 0 ? void 0 : _a.condition)) {
+    if (isClass(typeToAdd) && !typeToAdd.props?.condition) {
         const literalMaps = isClassInstance(typeToAdd)
             ? unionType.priv.literalInstances
             : unionType.priv.literalClasses;
@@ -2772,9 +2733,9 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
             // If we're adding Literal[False] or Literal[True] to its
             // opposite, combine them into a non-literal 'bool' type.
             if (ClassType.isBuiltIn(type, 'bool') &&
-                !((_b = type.props) === null || _b === void 0 ? void 0 : _b.condition) &&
+                !type.props?.condition &&
                 ClassType.isBuiltIn(typeToAdd, 'bool') &&
-                !((_c = typeToAdd.props) === null || _c === void 0 ? void 0 : _c.condition)) {
+                !typeToAdd.props?.condition) {
                 if (typeToAdd.priv.literalValue !== undefined &&
                     !typeToAdd.priv.literalValue === type.priv.literalValue) {
                     unionType.priv.subtypes[i] = ClassType.cloneWithLiteral(type, /* value */ undefined);