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

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)];
@@ -1631,15 +1638,13 @@ function getTypeVarArgsRecursive(type, recursionCount = 0) {
 // Creates a specialized version of the class, filling in any unspecified
 // type arguments with Unknown or default value.
 function specializeWithDefaultTypeArgs(type) {
-    if (type.shared.typeParams.length === 0 || type.priv.typeArgs) {
+    if (type.shared.typeParams.length === 0 || type.priv.typeArgs || !type.shared.typeVarScopeId) {
         return type;
     }
     const solution = new constraintSolution_1.ConstraintSolution();
-    const typeParams = types_1.ClassType.getTypeParams(type);
-    typeParams.forEach((typeParam) => {
-        solution.setType(typeParam, applySolvedTypeVars(typeParam.shared.defaultType, solution));
+    return applySolvedTypeVars(type, solution, {
+        replaceUnsolved: { scopeIds: [type.shared.typeVarScopeId], tupleClassType: undefined },
     });
-    return applySolvedTypeVars(type, solution);
 }
 // Builds a mapping between type parameters and their specialized
 // types. For example, if the generic type is Dict[_T1, _T2] and the
@@ -2871,6 +2876,7 @@ class TypeVarTransformer {
         let newTypeArgs;
         let newTupleTypeArgs;
         let specializationNeeded = false;
+        let isTypeArgExplicit = true;
         // If type args were previously provided, specialize them.
         // Handle tuples specially.
         if (types_1.ClassType.isTupleClass(classType)) {
@@ -2916,6 +2922,7 @@ class TypeVarTransformer {
                     const newTypeArgType = this.apply(typeParams[0], recursionCount);
                     newTupleTypeArgs = [{ type: newTypeArgType, isUnbounded: true }];
                     specializationNeeded = true;
+                    isTypeArgExplicit = false;
                 }
             }
             // If this is an empty tuple, don't recompute the non-tuple type argument.
@@ -2926,6 +2933,9 @@ class TypeVarTransformer {
         }
         if (!newTypeArgs) {
             const typeArgs = (_a = classType.priv.typeArgs) !== null && _a !== void 0 ? _a : typeParams;
+            if (!classType.priv.typeArgs) {
+                isTypeArgExplicit = false;
+            }
             newTypeArgs = typeArgs.map((oldTypeArgType) => {
                 let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
                 if (newTypeArgType !== oldTypeArgType) {
@@ -2943,8 +2953,7 @@ class TypeVarTransformer {
         if (!specializationNeeded) {
             return classType;
         }
-        return types_1.ClassType.specialize(classType, newTypeArgs, 
-        /* isTypeArgExplicit */ true, 
+        return types_1.ClassType.specialize(classType, newTypeArgs, isTypeArgExplicit, 
         /* includeSubclasses */ undefined, newTupleTypeArgs);
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
@@ -3300,32 +3309,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;
                 }
             }
         }