@zzzen/pyright-internal 1.2.0-dev.20260906 → 1.2.0-dev.20260920

package/dist/analyzer/checker.d.ts

@@ -1,4 +1,4 @@
-import { AssertNode, AssignmentExpressionNode, AssignmentNode, AugmentedAssignmentNode, AwaitNode, BinaryOperationNode, CallNode, CaseNode, ClassNode, ComprehensionIfNode, ComprehensionNode, DelNode, DictionaryNode, ErrorNode, ExceptNode, ForNode, FormatStringNode, FunctionNode, GlobalNode, IfNode, ImportAsNode, ImportFromAsNode, ImportFromNode, IndexNode, LambdaNode, ListNode, MatchNode, MemberAccessNode, ModuleNameNode, NameNode, NonlocalNode, ParseNode, PatternClassNode, RaiseNode, ReturnNode, SetNode, SliceNode, StatementListNode, StringListNode, SuiteNode, TernaryNode, TryNode, TupleNode, TypeAliasNode, TypeAnnotationNode, TypeParameterListNode, TypeParameterNode, UnaryOperationNode, UnpackNode, WhileNode, WithNode, YieldFromNode, YieldNode } from '../parser/parseNodes';
+import { AssertNode, AssignmentExpressionNode, AssignmentNode, AugmentedAssignmentNode, AwaitNode, BinaryOperationNode, CallNode, CaseNode, ClassNode, ComprehensionIfNode, ComprehensionNode, DelNode, DecoratorNode, DictionaryNode, ErrorNode, ExceptNode, ForNode, FormatStringNode, FunctionNode, GlobalNode, IfNode, ImportAsNode, ImportFromAsNode, ImportFromNode, IndexNode, LambdaNode, ListNode, MatchNode, MemberAccessNode, ModuleNameNode, NameNode, NonlocalNode, ParseNode, PatternClassNode, RaiseNode, ReturnNode, SetNode, SliceNode, StatementListNode, StringListNode, SuiteNode, TernaryNode, TryNode, TupleNode, TypeAliasNode, TypeAnnotationNode, TypeParameterListNode, TypeParameterNode, UnaryOperationNode, UnpackNode, WhileNode, WithNode, YieldFromNode, YieldNode } from '../parser/parseNodes';
 import { ParserOutput } from '../parser/parser';
 import * as AnalyzerNodeInfo from './analyzerNodeInfo';
 import { ImportResolver } from './importResolver';
@@ -21,6 +21,7 @@ export declare class Checker extends ParseTreeWalker {
     visitSuite(node: SuiteNode): boolean;
     visitStatementList(node: StatementListNode): boolean;
     visitClass(node: ClassNode): boolean;
+    visitDecorator(node: DecoratorNode): boolean;
     visitFunction(node: FunctionNode): boolean;
     visitLambda(node: LambdaNode): boolean;
     visitCall(node: CallNode): boolean;

package/dist/analyzer/checker.js

@@ -58,6 +58,7 @@ const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const constraintSolution_1 = require("./constraintSolution");
 const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
@@ -79,7 +80,6 @@ const staticExpressions_1 = require("./staticExpressions");
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
 const typedDicts_1 = require("./typedDicts");
-const typeEvaluator_1 = require("./typeEvaluator");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
 const types_1 = require("./types");
@@ -118,7 +118,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (isPrintCodeComplexityEnabled) {
             console.log(`Code complexity of module ${this._fileInfo.fileUri.toUserVisibleString()} is ${codeComplexity.toString()}`);
         }
-        if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
+        if (codeComplexity > this._evaluator.getMaxCodeComplexity()) {
             this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
         }
         this._walkStatementsAndReportUnreachable(this._moduleNode.d.statements);
@@ -219,6 +219,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._scopedNodes.push(node);
         return false;
     }
+    visitDecorator(node) {
+        // Class type evaluation can defer identity-factory arguments, so full checking must validate the expression.
+        this._evaluator.getTypeOfExpression(node.d.expr);
+        return true;
+    }
     visitFunction(node) {
         if (node.d.typeParams) {
             this.walk(node.d.typeParams);
@@ -400,7 +405,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         const codeComplexity = this._nodeInfo.getCodeFlowComplexity(node);
-        const isTooComplexToAnalyze = codeComplexity > typeEvaluator_1.maxCodeComplexity;
+        const isTooComplexToAnalyze = codeComplexity > this._evaluator.getMaxCodeComplexity();
         if (isPrintCodeComplexityEnabled) {
             console.log(`Code complexity of function ${node.d.name.d.value} is ${codeComplexity.toString()}`);
         }
@@ -2506,8 +2511,78 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // If both declarations are functions, it's OK if they
                 // both have the same signatures.
-                if (!isInSameStatementList && primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
-                    duplicateIsOk = true;
+                if (!isInSameStatementList && primaryType && otherType) {
+                    let adjustedOtherType = otherType;
+                    let typeParamsMatch = true;
+                    if ((0, types_1.isFunction)(primaryType) &&
+                        (0, types_1.isFunction)(otherType) &&
+                        primaryType.shared.typeVarScopeId &&
+                        otherType.shared.typeVarScopeId) {
+                        const primaryTypeParams = primaryType.shared.typeParams.filter((typeParam) => typeParam.priv.scopeId === primaryType.shared.typeVarScopeId);
+                        const otherTypeParams = otherType.shared.typeParams.filter((typeParam) => typeParam.priv.scopeId === otherType.shared.typeVarScopeId);
+                        typeParamsMatch = primaryTypeParams.length === otherTypeParams.length;
+                        if (typeParamsMatch && otherTypeParams.length > 0) {
+                            // Local type parameter names are not part of a generic function signature.
+                            // Align parameters by position, but verify their metadata before substitution.
+                            const solution = new constraintSolution_1.ConstraintSolution();
+                            otherTypeParams.forEach((typeParam, index) => {
+                                solution.setType(typeParam, primaryTypeParams[index]);
+                            });
+                            for (let index = 0; index < primaryTypeParams.length; index++) {
+                                const primaryTypeParam = primaryTypeParams[index];
+                                const otherTypeParam = otherTypeParams[index];
+                                if (primaryTypeParam.shared.kind !== otherTypeParam.shared.kind ||
+                                    primaryTypeParam.shared.isSynthesized !== otherTypeParam.shared.isSynthesized ||
+                                    primaryTypeParam.shared.declaredVariance !== otherTypeParam.shared.declaredVariance) {
+                                    typeParamsMatch = false;
+                                    break;
+                                }
+                                const primaryBound = primaryTypeParam.shared.boundType;
+                                const otherBound = otherTypeParam.shared.boundType
+                                    ? (0, typeUtils_1.applySolvedTypeVars)(otherTypeParam.shared.boundType, solution)
+                                    : undefined;
+                                if (!!primaryBound !== !!otherBound ||
+                                    (primaryBound && otherBound && !(0, types_1.isTypeSame)(primaryBound, otherBound))) {
+                                    typeParamsMatch = false;
+                                    break;
+                                }
+                                if (primaryTypeParam.shared.constraints.length !==
+                                    otherTypeParam.shared.constraints.length) {
+                                    typeParamsMatch = false;
+                                    break;
+                                }
+                                if (primaryTypeParam.shared.constraints.some((constraint, constraintIndex) => !(0, types_1.isTypeSame)(constraint, (0, typeUtils_1.applySolvedTypeVars)(otherTypeParam.shared.constraints[constraintIndex], solution)))) {
+                                    typeParamsMatch = false;
+                                    break;
+                                }
+                                if (primaryTypeParam.shared.isDefaultExplicit !==
+                                    otherTypeParam.shared.isDefaultExplicit) {
+                                    typeParamsMatch = false;
+                                    break;
+                                }
+                                if (primaryTypeParam.shared.isDefaultExplicit &&
+                                    !(0, types_1.isTypeSame)(primaryTypeParam.shared.defaultType, (0, typeUtils_1.applySolvedTypeVars)(otherTypeParam.shared.defaultType, solution))) {
+                                    typeParamsMatch = false;
+                                    break;
+                                }
+                            }
+                            if (typeParamsMatch) {
+                                adjustedOtherType = (0, typeUtils_1.applySolvedTypeVars)(otherType, solution);
+                            }
+                        }
+                    }
+                    let parameterOptionalityMatches = true;
+                    if ((0, types_1.isFunction)(primaryType) && (0, types_1.isFunction)(adjustedOtherType)) {
+                        const primaryParameters = primaryType.shared.parameters;
+                        const otherParameters = adjustedOtherType.shared.parameters;
+                        parameterOptionalityMatches =
+                            primaryParameters.length === otherParameters.length &&
+                                primaryParameters.every((_param, index) => !!types_1.FunctionType.getParamDefaultType(primaryType, index) ===
+                                    !!types_1.FunctionType.getParamDefaultType(adjustedOtherType, index));
+                    }
+                    if (typeParamsMatch && parameterOptionalityMatches && (0, types_1.isTypeSame)(primaryType, adjustedOtherType)) {
+                        duplicateIsOk = true;
+                    }
                 }
                 if (primaryDecl.type === 3 /* DeclarationType.TypeParam */) {
                     // The error will be reported elsewhere if a type parameter is