@zzzen/pyright-internal 1.2.0-dev.20240602 → 1.2.0-dev.20240609

package/dist/analyzer/checker.js

@@ -102,7 +102,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             console.log(`Code complexity of module ${this._fileInfo.fileUri.toUserVisibleString()} is ${codeComplexity.toString()}`);
         }
         if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
         }
         this._walkStatementsAndReportUnreachable(this._moduleNode.statements);
         // Mark symbols accessed by __all__ as accessed.
@@ -493,7 +493,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitFor(node) {
         this._evaluator.evaluateTypesForStatement(node);
         if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidTypeForm, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -533,7 +533,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.evaluateTypesForStatement(item);
         });
         if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidTypeForm, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -701,7 +701,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.evaluateTypesForStatement(node);
             const exceptionType = this._evaluator.getType(node.typeExpression);
             if (exceptionType) {
-                this._validateExceptionType(exceptionType, node.typeExpression);
+                this._validateExceptionType(exceptionType, node.typeExpression, node.isExceptGroup);
             }
         }
         return true;
@@ -719,7 +719,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, typeUtils_1.isTupleClass)(type) && type.tupleTypeArguments) {
                 if (type.tupleTypeArguments.length > 0) {
                     if (!(0, typeUtils_1.isUnboundedTupleClass)(type)) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportAssertAlwaysTrue, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.testExpression);
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.testExpression);
                     }
                 }
             }
@@ -877,14 +877,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 unescapedResult.unescapeErrors.forEach((error) => {
                     if (error.errorType === 0 /* UnescapeErrorType.InvalidEscapeSequence */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.LocMessage.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.LocMessage.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
                     }
                 });
                 // Prior to Python 3.12, it was not allowed to include a slash in an f-string.
                 if (fStringContainers.length > 0) {
                     const escapeOffset = token.escapedValue.indexOf('\\');
                     if (escapeOffset >= 0) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringEscape(), { start, length: 1 });
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringEscape(), { start, length: 1 });
                     }
                 }
             });
@@ -901,7 +901,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.getType(node);
         }
         if (node.strings.length > 1 && !node.isParenthesized) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportImplicitStringConcatenation, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.LocMessage.implicitStringConcat(), node);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.LocMessage.implicitStringConcat(), node);
         }
         return true;
     }
@@ -992,7 +992,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 importInfo.isImportFound &&
                 importInfo.importType !== 2 /* ImportType.Local */ &&
                 !this._fileInfo.isStubFile) {
-                this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.wildcardToken || node);
+                this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.wildcardToken || node);
             }
         }
         return true;
@@ -1799,8 +1799,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
             if (this._isOverlappingOverload(prevOverload, functionType, /* partialOverlap */ true)) {
-                const prevReturnType = types_1.FunctionType.getSpecializedReturnType(prevOverload);
-                const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+                const prevReturnType = types_1.FunctionType.getEffectiveReturnType(prevOverload);
+                const returnType = types_1.FunctionType.getEffectiveReturnType(functionType);
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
@@ -1978,13 +1978,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _validateExceptionTypeRecursive(exceptionType, diag, baseExceptionType, allowTuple) {
+    _validateExceptionTypeRecursive(exceptionType, diag, baseExceptionType, baseExceptionGroupType, allowTuple, isExceptGroup) {
         const derivesFromBaseException = (classType) => {
             if (!baseExceptionType || !(0, types_1.isInstantiableClass)(baseExceptionType)) {
                 return true;
             }
             return (0, typeUtils_1.derivesFromClassRecursive)(classType, baseExceptionType, /* ignoreUnknown */ false);
         };
+        const derivesFromBaseExceptionGroup = (classType) => {
+            if (!baseExceptionGroupType || !(0, types_1.isInstantiableClass)(baseExceptionGroupType)) {
+                return true;
+            }
+            return (0, typeUtils_1.derivesFromClassRecursive)(classType, baseExceptionGroupType, /* ignoreUnknown */ false);
+        };
         (0, typeUtils_1.doForEachSubtype)(exceptionType, (exceptionSubtype) => {
             if ((0, types_1.isAnyOrUnknown)(exceptionSubtype)) {
                 return;
@@ -1996,12 +2002,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             type: this._evaluator.printType(exceptionSubtype),
                         }));
                     }
+                    if (isExceptGroup && derivesFromBaseExceptionGroup(exceptionSubtype)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionGroupTypeIncorrect());
+                    }
                     return;
                 }
                 if (allowTuple && exceptionSubtype.tupleTypeArguments) {
                     exceptionSubtype.tupleTypeArguments.forEach((typeArg) => {
-                        this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, 
-                        /* allowTuple */ false);
+                        this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, baseExceptionGroupType, 
+                        /* allowTuple */ false, isExceptGroup);
                     });
                     return;
                 }
@@ -2011,10 +2020,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    _validateExceptionType(exceptionType, errorNode) {
+    _validateExceptionType(exceptionType, errorNode, isExceptGroup) {
         const baseExceptionType = this._evaluator.getBuiltInType(errorNode, 'BaseException');
+        const baseExceptionGroupType = this._evaluator.getBuiltInType(errorNode, 'BaseExceptionGroup');
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-        this._validateExceptionTypeRecursive(exceptionType, diagAddendum, baseExceptionType, /* allowTuple */ true);
+        this._validateExceptionTypeRecursive(exceptionType, diagAddendum, baseExceptionType, baseExceptionGroupType, 
+        /* allowTuple */ true, isExceptGroup);
         if (!diagAddendum.isEmpty()) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.exceptionTypeNotClass().format({
                 type: this._evaluator.printType(exceptionType),
@@ -2471,7 +2482,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             let textRange = { start: nameParts[0].start, length: nameParts[0].length };
                             textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
                             this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* Commands.unusedImport */ });
-                            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportUnusedImport, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
+                            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
                             return;
                         }
                     }
@@ -3134,7 +3145,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._importResolver.isStdlibModule(desc, this._fileInfo.executionEnvironment) &&
             this._sourceMapper.isUserCode(this._fileInfo.fileUri)) {
             // This means the user has a module that is overwriting the stdlib module.
-            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.LocMessage.stdlibModuleOverridden().format({
+            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.LocMessage.stdlibModuleOverridden().format({
                 name: moduleName,
                 path: this._fileInfo.fileUri.toUserVisibleString(),
             }), this._moduleNode);
@@ -3540,11 +3551,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         types_1.ClassType.getSymbolTable(classType).forEach((symbol, name) => {
             var _a;
-            // Enum members don't have type annotations.
-            if (symbol.getTypedDeclarations().length > 0) {
-                return;
-            }
-            const symbolType = (0, enums_1.transformTypeForEnumMember)(this._evaluator, classType, name);
+            // Determine whether this is an enum member. We ignore the presence
+            // of an annotation in this case because the runtime does. From a
+            // type checking perspective, if the runtime treats the assignment
+            // as an enum member but there is a type annotation present, it is
+            // considered a type checking error.
+            const symbolType = (0, enums_1.transformTypeForEnumMember)(this._evaluator, classType, name, 
+            /* ignoreAnnotation */ true);
             // Is this symbol a literal instance of the enum class?
             if (!symbolType ||
                 !(0, types_1.isClassInstance)(symbolType) ||
@@ -3552,6 +3565,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 !(symbolType.literalValue instanceof types_1.EnumLiteral)) {
                 return;
             }
+            // Enum members should not have type annotations.
+            const typedDecls = symbol.getTypedDeclarations();
+            if (typedDecls.length > 0) {
+                if (typedDecls[0].type === 1 /* DeclarationType.Variable */ && typedDecls[0].inferredTypeSource) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumMemberTypeAnnotation(), typedDecls[0].node);
+                }
+                return;
+            }
             // Look for a duplicate assignment.
             const decls = symbol.getDeclarations();
             if (decls.length >= 2 && decls[0].type === 1 /* DeclarationType.Variable */) {
@@ -3978,12 +3999,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // We'll set the "SkipArgsKwargs" flag for pragmatic reasons since __new__
         // often has an *args and/or **kwargs. We'll also set the ParamSpecValue
         // because we don't care about the return type for this check.
-        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.details.flags |
-            32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ |
-            65536 /* FunctionTypeFlags.ParamSpecValue */);
-        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags |
-            32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ |
-            65536 /* FunctionTypeFlags.ParamSpecValue */);
+        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.details.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
+        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
@@ -5068,7 +5085,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!functionTypeResult) {
             return;
         }
-        const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionTypeResult.functionType);
+        const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
         if (!declaredReturnType) {
             return;
         }