@zzzen/pyright-internal 1.2.0-dev.20241027 → 1.2.0-dev.20241103

package/dist/analyzer/typeUtils.js

@@ -893,6 +893,9 @@ function selfSpecializeClass(type, options) {
         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 types_1.ClassType.specialize(type, typeParams);
@@ -1331,7 +1334,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
         let classFlags = 0 /* ClassIteratorFlags.Default */;
         if (flags & 1 /* MemberAccessFlags.SkipOriginalClass */) {
             if ((0, types_1.isClass)(classType)) {
-                skipMroClass = classType;
+                skipMroClass = (0, types_1.isClassInstance)(classType) ? types_1.ClassType.cloneAsInstantiable(classType) : classType;
             }
         }
         if (flags & 2 /* MemberAccessFlags.SkipBaseClasses */) {
@@ -1418,7 +1421,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                         // Handle the special case of a __call__ class member in a partial class.
                         if (memberName === '__call__' &&
                             classType.priv.partialCallType &&
-                            types_1.ClassType.isSameGenericClass(classType, specializedMroClass)) {
+                            types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(classType) ? types_1.ClassType.cloneAsInstantiable(classType) : classType, specializedMroClass)) {
                             symbol = symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, classType.priv.partialCallType);
                         }
                         const cm = {
@@ -1592,6 +1595,10 @@ function getTypeVarArgsRecursive(type, recursionCount = 0) {
         if (type.shared.recursiveAlias) {
             return [];
         }
+        // Don't return any bound type variables.
+        if (types_1.TypeVarType.isBound(type)) {
+            return [];
+        }
         // Don't return any P.args or P.kwargs types.
         if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
             return [types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined)];
@@ -3300,32 +3307,44 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return getUnknownForTypeVar(typeVar, (_c = this._options.replaceUnsolved) === null || _c === void 0 ? void 0 : _c.tupleClassType);
     }
     transformUnionSubtype(preTransform, postTransform) {
-        var _a, _b;
+        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 ((0, types_1.isTypeVar)(preTransform) &&
-                this._shouldReplaceTypeVar(preTransform) &&
-                this._shouldReplaceUnsolvedTypeVar(preTransform)) {
-                const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
-                const typeVarType = solutionSet.getType(preTransform);
-                // Did the TypeVar remain unsolved?
-                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && types_1.TypeVarType.isUnification(typeVarType))) {
-                    // If the TypeVar was not transformed, then it was unsolved,
-                    // and we'll eliminate it.
-                    if (preTransform === postTransform) {
-                        return undefined;
-                    }
-                    // If useDefaultForUnsolved or useUnknownForUnsolved is true, the postTransform type will
-                    // be Unknown, which we want to eliminate.
-                    if (this._options.replaceUnsolved) {
-                        if ((0, types_1.isUnknown)(postTransform)) {
-                            return undefined;
-                        }
-                    }
+        if (!((_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.eliminateUnsolvedInUnions)) {
+            return postTransform;
+        }
+        const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
+        if ((0, types_1.isTypeVar)(preTransform)) {
+            if (!this._shouldReplaceTypeVar(preTransform) || !this._shouldReplaceUnsolvedTypeVar(preTransform)) {
+                return postTransform;
+            }
+            const typeVarType = solutionSet.getType(preTransform);
+            // Did the TypeVar remain unsolved?
+            if (typeVarType) {
+                if (!(0, types_1.isTypeVar)(typeVarType) || !types_1.TypeVarType.isUnification(typeVarType)) {
+                    return postTransform;
+                }
+            }
+            // If the TypeVar was not transformed, then it was unsolved,
+            // and we'll eliminate it.
+            if (preTransform === postTransform) {
+                return undefined;
+            }
+            // If useDefaultForUnsolved or useUnknownForUnsolved is true, the postTransform type will
+            // be Unknown, which we want to eliminate.
+            if (this._options.replaceUnsolved && (0, types_1.isUnknown)(postTransform)) {
+                return undefined;
+            }
+        }
+        else if ((_c = preTransform.props) === null || _c === void 0 ? void 0 : _c.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) {
+                if (types_1.TypeVarType.isUnification(condition.typeVar) && !solutionSet.getType(condition.typeVar)) {
+                    return undefined;
                 }
             }
         }