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

package/dist/analyzer/typeEvaluator.js

@@ -2022,7 +2022,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // Handle the case where the type is synthesized (used for
                         // dataclasses).
                         if (synthesizedType) {
-                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType);
+                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType.type);
                         }
                         else {
                             // Assume that if '__hash__' is declared as a variable, it is
@@ -7310,13 +7310,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
+            var _a, _b;
             (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* ParamCategory.Simple */ && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                paramMap.set(param.name, {
-                    argsNeeded: param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType ? 1 : 0,
-                    argsReceived: 0,
-                });
+                let argsNeeded = (_b = (_a = paramMap.get(param.name)) === null || _a === void 0 ? void 0 : _a.argsNeeded) !== null && _b !== void 0 ? _b : 0;
+                if (param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType) {
+                    argsNeeded += 1;
+                }
+                paramMap.set(param.name, { argsNeeded, argsReceived: 0 });
             }
         });
         let positionalOnlyLimitIndex = paramDetails.positionOnlyParamCount;
@@ -8369,11 +8371,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (paramSpec) {
                 if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */) {
                     if ((0, parameterUtils_1.isParamSpecArgs)(paramSpec, argResult.argType)) {
+                        if (sawParamSpecArgs) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsKwargsDuplicate().format({ type: printType(paramSpec) }), argParam.errorNode);
+                        }
                         sawParamSpecArgs = true;
                     }
                 }
                 if (argParam.argument.argCategory === 2 /* ArgCategory.UnpackedDictionary */) {
                     if ((0, parameterUtils_1.isParamSpecKwargs)(paramSpec, argResult.argType)) {
+                        if (sawParamSpecKwargs) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsKwargsDuplicate().format({ type: printType(paramSpec) }), argParam.errorNode);
+                        }
                         sawParamSpecKwargs = true;
                     }
                 }
@@ -15088,15 +15096,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Filter the declarations based on flow reachability.
             const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* DeclarationType.Alias */ && decl.type !== 0 /* DeclarationType.Intrinsic */) {
-                    // Is the declaration in the same execution scope as the "usageNode" node?
-                    const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
+                    // Determine if the declaration is in the same execution scope as the "usageNode" node.
+                    let usageScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
                     const declNode = decl.type === 6 /* DeclarationType.Class */ ||
                         decl.type === 5 /* DeclarationType.Function */ ||
                         decl.type === 4 /* DeclarationType.TypeAlias */
                         ? decl.node.d.name
                         : decl.node;
-                    const declScope = ParseTreeUtils.getExecutionScopeNode(declNode);
-                    if (usageScope === declScope) {
+                    const declScopeNode = ParseTreeUtils.getExecutionScopeNode(declNode);
+                    // If this is a type parameter scope, it will be a proxy for its
+                    // containing scope, so we need to use that instead.
+                    const usageScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                    if (usageScope === null || usageScope === void 0 ? void 0 : usageScope.proxy) {
+                        const typeParamScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                        if (!(typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.has(name)) && usageScopeNode.parent) {
+                            usageScopeNode = ParseTreeUtils.getExecutionScopeNode(usageScopeNode.parent);
+                        }
+                    }
+                    if (usageScopeNode === declScopeNode) {
                         if (!isFlowPathBetweenNodes(declNode, node)) {
                             // If there was no control flow path from the usage back
                             // to the source, see if the usage node is reachable by
@@ -15303,7 +15320,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // dictionary expression where those keys are associated with a known TypedDict.
     function getDeclInfoForStringNode(node) {
         var _a;
-        const declarations = [];
+        const decls = [];
+        const synthesizedTypes = [];
         const expectedType = (_a = getExpectedType(node)) === null || _a === void 0 ? void 0 : _a.type;
         if (expectedType) {
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
@@ -15317,13 +15335,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (entry) {
                         const symbol = (_b = (0, typeUtils_1.lookUpObjectMember)(subtype, node.d.value)) === null || _b === void 0 ? void 0 : _b.symbol;
                         if (symbol) {
-                            (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
+                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
+                            const synthTypeInfo = symbol.getSynthesizedType();
+                            if (synthTypeInfo) {
+                                synthesizedTypes.push(synthTypeInfo);
+                            }
                         }
                     }
                 }
             });
         }
-        return declarations.length === 0 ? undefined : { decls: declarations, synthesizedTypes: [] };
+        return decls.length === 0 ? undefined : { decls, synthesizedTypes };
     }
     function getAliasFromImport(node) {
         if (node.parent &&
@@ -15339,7 +15361,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
-        const declarations = [];
+        const decls = [];
         const synthesizedTypes = [];
         // If the node is part of a "from X import Y as Z" statement and the node
         // is the "Y" (non-aliased) name, we need to look up the alias symbol
@@ -15356,7 +15378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const declsForThisImport = symbolInScope.symbol.getDeclarations().filter((decl) => {
                         return decl.type === 8 /* DeclarationType.Alias */ && decl.node === node.parent;
                     });
-                    (0, collectionUtils_1.appendArray)(declarations, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
+                    (0, collectionUtils_1.appendArray)(decls, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
                 }
             }
         }
@@ -15407,16 +15429,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // which includes every assignment of that symbol.
                         const typedDecls = symbol.getTypedDeclarations();
                         if (typedDecls.length > 0) {
-                            (0, collectionUtils_1.appendArray)(declarations, typedDecls);
+                            (0, collectionUtils_1.appendArray)(decls, typedDecls);
                         }
                         else {
-                            const synthesizedType = symbol.getSynthesizedType();
-                            if (synthesizedType) {
-                                synthesizedTypes.push({ type: synthesizedType, node });
-                            }
-                            else {
-                                (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
-                            }
+                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
+                        }
+                        const synthTypeInfo = symbol.getSynthesizedType();
+                        if (synthTypeInfo) {
+                            synthesizedTypes.push(synthTypeInfo);
                         }
                     }
                 });
@@ -15434,7 +15454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
+                    decls.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -15449,14 +15469,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isFunction)(baseType) && baseType.shared.declaration) {
                         const paramDecl = getDeclarationFromKeywordParam(baseType, paramName);
                         if (paramDecl) {
-                            declarations.push(paramDecl);
+                            decls.push(paramDecl);
                         }
                     }
                     else if ((0, types_1.isOverloaded)(baseType)) {
                         types_1.OverloadedType.getOverloads(baseType).forEach((f) => {
                             const paramDecl = getDeclarationFromKeywordParam(f, paramName);
                             if (paramDecl) {
-                                declarations.push(paramDecl);
+                                decls.push(paramDecl);
                             }
                         });
                     }
@@ -15465,14 +15485,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromKeywordParam(initMethodType, paramName);
                             if (paramDecl) {
-                                declarations.push(paramDecl);
+                                decls.push(paramDecl);
                             }
                             else if (types_1.ClassType.isDataClass(baseType) ||
                                 types_1.ClassType.isTypedDictClass(baseType) ||
                                 types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
                                 const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                                 if (lookupResults) {
-                                    (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
+                                    (0, collectionUtils_1.appendArray)(decls, lookupResults.symbol.getDeclarations());
+                                    const synthTypeInfo = lookupResults.symbol.getSynthesizedType();
+                                    if (synthTypeInfo) {
+                                        synthesizedTypes.push(synthTypeInfo);
+                                    }
                                 }
                             }
                         }
@@ -15497,10 +15521,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
             const symbolWithScope = lookUpSymbolRecursive(node, node.d.value, !allowForwardReferences, isWithinTypeAnnotation);
             if (symbolWithScope) {
-                (0, collectionUtils_1.appendArray)(declarations, symbolWithScope.symbol.getDeclarations());
+                (0, collectionUtils_1.appendArray)(decls, symbolWithScope.symbol.getDeclarations());
+                const synthTypeInfo = symbolWithScope.symbol.getSynthesizedType();
+                if (synthTypeInfo) {
+                    synthesizedTypes.push(synthTypeInfo);
+                }
             }
         }
-        return { decls: declarations, synthesizedTypes };
+        return { decls, synthesizedTypes };
     }
     function getTypeForDeclaration(declaration) {
         var _a, _b, _c;
@@ -16270,7 +16298,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // provided, but type inference is still required. In such cases, the attributes
     // are returned as flags.
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
-        const synthesizedType = symbol.getSynthesizedType();
+        var _a;
+        const synthesizedType = (_a = symbol.getSynthesizedType()) === null || _a === void 0 ? void 0 : _a.type;
         if (synthesizedType) {
             return { type: synthesizedType };
         }
@@ -16884,41 +16913,49 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Now handle generic base classes.
             destType.shared.baseClasses.forEach((baseClass) => {
-                if ((0, types_1.isInstantiableClass)(baseClass) &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'object') &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'Protocol') &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
-                    baseClass.shared.typeParams.length > 0) {
-                    const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
-                    const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
-                    if (!ignoreBaseClassVariance) {
-                        specializedDestBaseClass.shared.typeParams.forEach((param, index) => {
-                            if (!(0, types_1.isParamSpec)(param) &&
-                                !(0, types_1.isTypeVarTuple)(param) &&
-                                !param.shared.isSynthesized &&
-                                specializedSrcBaseClass.priv.typeArgs &&
-                                index < specializedSrcBaseClass.priv.typeArgs.length &&
-                                specializedDestBaseClass.priv.typeArgs &&
-                                index < specializedDestBaseClass.priv.typeArgs.length) {
-                                const paramVariance = param.shared.declaredVariance;
-                                if ((0, types_1.isTypeVar)(specializedSrcBaseClass.priv.typeArgs[index])) {
-                                    if (paramVariance === 2 /* Variance.Invariant */ ||
-                                        paramVariance === 4 /* Variance.Contravariant */) {
-                                        isAssignable = false;
-                                    }
-                                }
-                                else if ((0, types_1.isTypeVar)(specializedDestBaseClass.priv.typeArgs[index])) {
-                                    if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
-                                        isAssignable = false;
-                                    }
-                                }
+                if (!isAssignable ||
+                    !(0, types_1.isInstantiableClass)(baseClass) ||
+                    types_1.ClassType.isBuiltIn(baseClass, ['object', 'Protocol', 'Generic']) ||
+                    baseClass.shared.typeParams.length === 0) {
+                    return;
+                }
+                const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
+                const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
+                if (!ignoreBaseClassVariance) {
+                    specializedDestBaseClass.shared.typeParams.forEach((param, index) => {
+                        if ((0, types_1.isParamSpec)(param) || (0, types_1.isTypeVarTuple)(param) || param.shared.isSynthesized) {
+                            return;
+                        }
+                        if (!specializedSrcBaseClass.priv.typeArgs ||
+                            index >= specializedSrcBaseClass.priv.typeArgs.length ||
+                            !specializedDestBaseClass.priv.typeArgs ||
+                            index >= specializedDestBaseClass.priv.typeArgs.length) {
+                            return;
+                        }
+                        const paramVariance = param.shared.declaredVariance;
+                        if ((0, types_1.isTypeVar)(specializedSrcBaseClass.priv.typeArgs[index])) {
+                            if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 4 /* Variance.Contravariant */) {
+                                isAssignable = false;
+                                return;
                             }
-                        });
-                    }
-                    if (isAssignable &&
-                        !assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
-                        isAssignable = false;
-                    }
+                        }
+                        if ((0, types_1.isTypeVar)(specializedDestBaseClass.priv.typeArgs[index])) {
+                            if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
+                                isAssignable = false;
+                                return;
+                            }
+                        }
+                    });
+                }
+                if (!isAssignable) {
+                    return;
+                }
+                // Handle tuples specially since their type arguments are variadic.
+                if (types_1.ClassType.isTupleClass(specializedDestBaseClass)) {
+                    return;
+                }
+                if (!assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
+                    isAssignable = false;
                 }
             });
             return isAssignable;