@zzzen/pyright-internal 1.2.0-dev.20260927 → 1.2.0-dev.20261004

package/dist/analyzer/typeEvaluator.js

@@ -95,6 +95,7 @@ const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
+const typeWalker_1 = require("./typeWalker");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const overloadResultSelector_1 = require("./overloadResultSelector");
@@ -1835,11 +1836,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const argList = [];
         let previousCategory = 0 /* ArgCategory.Simple */;
+        let hasFakeArg = false;
         // Empty arguments do not enter the AST as nodes, but instead are left blank.
         // Instead, we detect when we appear to be between two known arguments or at the
         // end of the argument list and insert a fake argument of an unknown type to have
         // something to match later.
         function addFakeArg() {
+            hasFakeArg = true;
             argList.push({
                 argCategory: previousCategory,
                 typeResult: { type: types_1.UnknownType.create() },
@@ -1876,7 +1879,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* skipUnknownArgCheck */ true, 
                 /* inferenceContext */ undefined);
             });
-            const specializedType = solveAndApplyConstraints(type, constraints);
+            let specializedType = type;
+            if (types_1.FunctionType.getParamSpecFromArgsKwargs(type)) {
+                const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints);
+                // The fake argument is used only to identify the active parameter. Preserve
+                // type variables in that parameter while specializing the forwarded ParamSpec.
+                if (hasFakeArg && callResult?.activeParam) {
+                    const activeParamIndex = type.shared.parameters.indexOf(callResult.activeParam);
+                    if (activeParamIndex >= 0) {
+                        (0, typeUtils_1.getTypeVarArgsRecursive)(types_1.FunctionType.getParamType(type, activeParamIndex)).forEach((typeVar) => {
+                            if (!(0, types_1.isParamSpec)(typeVar)) {
+                                solution.doForEachSolutionSet((solutionSet) => {
+                                    const solvedType = solutionSet.getType(typeVar);
+                                    if (!solvedType || (0, types_1.isUnknown)(solvedType)) {
+                                        solutionSet.setType(typeVar, typeVar);
+                                    }
+                                });
+                            }
+                        });
+                    }
+                }
+                specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, solution);
+            }
             const finalType = (0, types_1.isFunction)(specializedType) ? specializedType : type;
             const hasActiveArg = argList.some((arg) => arg.active);
             // If the type was specialized (e.g. ParamSpec expansion), the activeParam
@@ -2725,6 +2749,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const memberInfo = (0, typeUtils_1.lookUpClassMember)(classType.classType, nameNode.d.value, 1 /* MemberAccessFlags.SkipOriginalClass */);
                     if (memberInfo?.isTypeDeclared) {
                         declaredType = getTypeOfMember(memberInfo);
+                        if ((0, symbolNameUtils_1.isMethodExemptFromLsp)(nameValue) &&
+                            memberInfo.symbol
+                                .getTypedDeclarations()
+                                .some((decl) => decl.type === 5 /* DeclarationType.Function */) &&
+                            (0, types_1.isFunctionOrOverloaded)(typeResult.type) &&
+                            (0, types_1.isFunctionOrOverloaded)(declaredType) &&
+                            !isFinalVariable(memberInfo.symbol)) {
+                            const baseMethods = (0, types_1.isFunction)(declaredType)
+                                ? [declaredType]
+                                : [
+                                    ...types_1.OverloadedType.getOverloads(declaredType),
+                                    types_1.OverloadedType.getImplementation(declaredType),
+                                ];
+                            if (!baseMethods.some((method) => method && (0, types_1.isFunction)(method) && types_1.FunctionType.isFinal(method))) {
+                                // Apply the same override exemptions to aliases and method definitions.
+                                declaredType = undefined;
+                            }
+                        }
                     }
                 }
             }
@@ -4570,6 +4612,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isAccessedThroughObject = types_1.TypeBase.isInstance(classType);
         // Always look for a member with a declared type first.
         let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+        // A class-level method alias retains its inferred signature, unlike an annotated variable.
+        if (usage.method === 'get' &&
+            memberInfo?.skippedUndeclaredType &&
+            memberInfo.symbol.getTypedDeclarations().some((decl) => decl.type === 5 /* DeclarationType.Function */)) {
+            const inferredMember = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags);
+            if (inferredMember?.isClassMember &&
+                !inferredMember.isInstanceMember &&
+                (0, types_1.isFunctionOrOverloaded)(getTypeOfMember(inferredMember))) {
+                memberInfo = inferredMember;
+            }
+        }
         // If we couldn't find a symbol with a declared type, use
         // a symbol with an inferred type.
         if (!memberInfo) {
@@ -4818,7 +4871,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const subDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
         /* usage */ undefined, subDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
-        if (!methodTypeResult || methodTypeResult.typeErrors) {
+        const deferredMethodType = usage.method === 'get'
+            ? getDescriptorGetMethodWithDeferredSelfSpecialization(concreteMemberType, subDiag)
+            : undefined;
+        if ((!methodTypeResult || methodTypeResult.typeErrors) && !deferredMethodType) {
             // Provide special error messages for properties.
             if (types_1.ClassType.isPropertyClass(concreteMemberType) && usage.method !== 'get') {
                 const message = usage.method === 'set' ? localize_1.LocAddendum.propertyMissingSetter() : localize_1.LocAddendum.propertyMissingDeleter();
@@ -4830,9 +4886,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return { type: memberType };
         }
-        const methodClassType = methodTypeResult.classType;
-        let methodType = methodTypeResult.type;
-        if (methodTypeResult.typeErrors || !methodClassType) {
+        const methodClassType = methodTypeResult?.classType ?? concreteMemberType;
+        let methodType = deferredMethodType ?? methodTypeResult.type;
+        if (!methodClassType) {
             if (diag && subDiag) {
                 diag.addAddendum(subDiag);
             }
@@ -4993,6 +5049,65 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             memberAccessDeprecationInfo: deprecationInfo,
         };
     }
+    function getDescriptorGetMethodWithDeferredSelfSpecialization(concreteMemberType, diag) {
+        const member = (0, typeUtils_1.lookUpClassMember)(concreteMemberType, '__get__');
+        if (!member || !(0, types_1.isInstantiableClass)(member.unspecializedClassType)) {
+            return undefined;
+        }
+        const unspecializedClassType = member.unspecializedClassType;
+        const declaringClassType = member.classType;
+        if (!(0, types_1.isInstantiableClass)(declaringClassType)) {
+            return undefined;
+        }
+        const declaringObjectType = types_1.ClassType.cloneAsInstance(declaringClassType);
+        const unspecializedMethodType = getEffectiveTypeOfSymbol(member.symbol);
+        if (!(0, types_1.isFunctionOrOverloaded)(unspecializedMethodType)) {
+            return undefined;
+        }
+        // A class ParamSpec used in Concatenate within the self annotation needs to be
+        // solved from the concrete descriptor, rather than specialized before self is bound.
+        const classParamSpecs = types_1.ClassType.getTypeParams(unspecializedClassType).filter(types_1.isParamSpec);
+        if (classParamSpecs.length === 0) {
+            return undefined;
+        }
+        const signatures = (0, types_1.isFunction)(unspecializedMethodType)
+            ? [unspecializedMethodType]
+            : types_1.OverloadedType.getOverloads(unspecializedMethodType);
+        const shouldDefer = signatures.some((signature) => {
+            if (signature.shared.parameters.length === 0) {
+                return false;
+            }
+            const selfParamType = types_1.FunctionType.getParamType(signature, 0);
+            if (!(0, types_1.isClassInstance)(selfParamType) || !types_1.ClassType.isSameGenericClass(selfParamType, declaringObjectType)) {
+                return false;
+            }
+            class ConcatenateParamSpecWalker extends typeWalker_1.TypeWalker {
+                constructor() {
+                    super(...arguments);
+                    this.found = false;
+                }
+                visitFunction(type) {
+                    const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
+                    if (paramSpec &&
+                        types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type).shared.parameters.length > 0 &&
+                        classParamSpecs.some((classParamSpec) => (0, types_1.isTypeSame)(paramSpec, classParamSpec))) {
+                        this.found = true;
+                        this.cancelWalk();
+                        return;
+                    }
+                    super.visitFunction(type);
+                }
+            }
+            const walker = new ConcatenateParamSpecWalker();
+            selfParamType.priv.typeArgs?.forEach((typeArg) => walker.walk(typeArg));
+            return walker.found;
+        });
+        if (!shouldDefer) {
+            return undefined;
+        }
+        return bindFunctionToClassOrObject(declaringObjectType, unspecializedMethodType, declaringClassType, 
+        /* treatConstructorAsClassMethod */ false, concreteMemberType, diag);
+    }
     function bindMethodForMemberAccess(type, concreteType, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount = 0) {
         // Check for an attempt to overwrite a final method.
         if (usage.method === 'set') {
@@ -13442,6 +13557,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Determine the effective metaclass.
             if (metaclassNode) {
                 let metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
+                if ((0, types_1.isAny)(metaclassType)) {
+                    metaclassType = types_1.UnknownType.create();
+                }
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
                     if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassIsGeneric(), metaclassNode);
@@ -21198,7 +21316,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (functionType.priv.strippedFirstParamType) {
                 return functionType;
             }
-            if (types_1.FunctionType.isInstanceMethod(functionType)) {
+            if (types_1.FunctionType.isInstanceMethod(functionType) && !treatConstructorAsClassMethod) {
                 // If the baseType is a metaclass, don't specialize the function.
                 if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
                     return functionType;
@@ -21215,8 +21333,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 return partiallySpecializeBoundMethod(baseType, functionType, diag, recursionCount, selfType ?? baseObj, stripFirstParam);
             }
-            if (types_1.FunctionType.isClassMethod(functionType) ||
-                (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
+            if (types_1.FunctionType.isClassMethod(functionType) || treatConstructorAsClassMethod) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
                 return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, clsType ?? baseClass, 
@@ -21580,6 +21697,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         validateInitSubclassArgs,
         isNodeReachable,
         isAfterNodeReachable,
+        isKeyPresentInTypedDict: (node) => codeFlowEngine.isKeyPresentInTypedDict(node),
         getNodeReachability,
         getAfterNodeReachability,
         isAsymmetricAccessorAssignment,