@zzzen/pyright-internal 1.2.0-dev.20250420 → 1.2.0-dev.20250802

package/dist/analyzer/checker.js

@@ -1392,8 +1392,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Use the left side of the right expression for comparison purposes.
             rightExpression = rightExpression.d.leftExpr;
         }
-        const leftType = this._evaluator.getType(node.d.leftExpr);
-        const rightType = this._evaluator.getType(rightExpression);
+        let leftType = this._evaluator.getType(node.d.leftExpr);
+        let rightType = this._evaluator.getType(rightExpression);
         if (!leftType || !rightType) {
             return;
         }
@@ -1405,6 +1405,33 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 ? localize_1.LocMessage.comparisonAlwaysFalse()
                 : localize_1.LocMessage.comparisonAlwaysTrue();
         };
+        const replaceEnumTypeWithLiteralValue = (type) => {
+            return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+                if (!(0, types_1.isClassInstance)(subtype) ||
+                    !types_1.ClassType.isEnumClass(subtype) ||
+                    !subtype.shared.mro.some((base) => (0, types_1.isClass)(base) && types_1.ClassType.isBuiltIn(base, ['int', 'str', 'bytes']))) {
+                    return subtype;
+                }
+                // If this is an enum literal, replace it with its literal value.
+                if (subtype.priv.literalValue instanceof types_1.EnumLiteral) {
+                    return subtype.priv.literalValue.itemType;
+                }
+                // If this is an enum class, replace it with the type of its members.
+                const literalValues = (0, typeGuards_1.enumerateLiteralsForType)(this._evaluator, subtype);
+                if (literalValues && literalValues.length > 0) {
+                    return (0, types_1.combineTypes)(literalValues.map((literalClass) => {
+                        const literalValue = literalClass.priv.literalValue;
+                        (0, debug_1.assert)(literalValue instanceof types_1.EnumLiteral);
+                        return literalValue.itemType;
+                    }));
+                }
+                return subtype;
+            });
+        };
+        // Handle enum literals that are assignable to another (non-Enum) literal.
+        // This can happen for IntEnum and StrEnum members.
+        leftType = replaceEnumTypeWithLiteralValue(leftType);
+        rightType = replaceEnumTypeWithLiteralValue(rightType);
         // Check for the special case where the LHS and RHS are both literals.
         if ((0, typeUtils_1.isLiteralTypeOrUnion)(rightType) && (0, typeUtils_1.isLiteralTypeOrUnion)(leftType)) {
             if ((0, staticExpressions_1.evaluateStaticBoolExpression)(node, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants) === undefined) {
@@ -1477,7 +1504,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             types_1.ClassType.isBuiltIn(declaredReturnType, 'AwaitableGenerator')) {
             // Handle the old-style (pre-await) generator case
             // if the return type explicitly uses AwaitableGenerator.
-            generatorType = this._evaluator.getTypingType(node, 'AwaitableGenerator');
+            generatorType =
+                this._evaluator.getTypeCheckerInternalsType(node, 'AwaitableGenerator') ??
+                    this._evaluator.getTypingType(node, 'AwaitableGenerator');
         }
         else {
             generatorType = this._evaluator.getTypingType(node, node.d.isAsync ? 'AsyncGenerator' : 'Generator');
@@ -1805,7 +1834,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.shared.name === '__get__') {
             return false;
         }
-        let flags = 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlap */;
+        let flags = 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
+            16 /* AssignTypeFlags.OverloadOverlap */ |
+            131072 /* AssignTypeFlags.DisallowExtraKwargsForTd */;
         if (partialOverlap) {
             flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
@@ -1844,7 +1875,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overloadBound = (0, typeUtils_1.makeTypeVarsBound)(overload, liveScopeIds);
         }
         // First check the parameters to see if they are assignable.
-        let isConsistent = this._evaluator.assignType(overloadBound, implBound, diag, constraints, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 2 /* AssignTypeFlags.Contravariant */ | 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
+        let isConsistent = this._evaluator.assignType(overloadBound, implBound, diag, constraints, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
+            2 /* AssignTypeFlags.Contravariant */ |
+            512 /* AssignTypeFlags.SkipSelfClsTypeCheck */ |
+            131072 /* AssignTypeFlags.DisallowExtraKwargsForTd */);
         // Now check the return types.
         const overloadReturnType = this._evaluator.solveAndApplyConstraints(types_1.FunctionType.getEffectiveReturnType(overloadBound) ?? this._evaluator.getInferredReturnType(overloadBound), constraints);
         const implReturnType = this._evaluator.solveAndApplyConstraints(types_1.FunctionType.getEffectiveReturnType(implBound) ?? this._evaluator.getInferredReturnType(implBound), constraints);
@@ -1874,7 +1908,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const start = statement.start;
                     const lastStatement = statements[statements.length - 1];
                     const end = textRange_1.TextRange.getEnd(lastStatement);
-                    this._evaluator.addUnreachableCode(statement, reachability, { start, length: end - start });
+                    const textRange = { start, length: end - start };
+                    if (reachability === typeEvaluatorTypes_1.Reachability.UnreachableByAnalysis ||
+                        reachability === typeEvaluatorTypes_1.Reachability.UnreachableStructural) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnreachable, reachability === typeEvaluatorTypes_1.Reachability.UnreachableStructural
+                            ? localize_1.LocMessage.unreachableCodeStructure()
+                            : localize_1.LocMessage.unreachableCodeType(), statement.nodeType === 0 /* ParseNodeType.Error */ ? statement : statement.d.firstToken);
+                    }
+                    this._evaluator.addUnreachableCode(statement, reachability, textRange);
                     reportedUnreachable = true;
                 }
             }
@@ -4625,22 +4666,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideType = (0, typeUtils_1.makeTypeVarsBound)(overrideType, [childClassType.shared.typeVarScopeId]);
             baseType = (0, typeUtils_1.makeTypeVarsBound)(baseType, [childClassType.shared.typeVarScopeId]);
         }
-        if ((0, types_1.isFunctionOrOverloaded)(baseType)) {
-            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            // Determine whether this is an attempt to override a method marked @final.
-            if (this._isFinalFunction(memberName, baseType)) {
-                const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
-                if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
-                        name: memberName,
-                        className: baseClass.shared.name,
-                    }), decl.node.d.name);
-                    const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                    if (diag && origDecl) {
-                        diag.addRelatedInfo(localize_1.LocAddendum.finalMethod(), origDecl.uri, origDecl.range);
-                    }
+        // Determine whether this is an attempt to override a method marked @final.
+        if (this._isFinalFunction(memberName, baseClassAndSymbol.symbol, baseType)) {
+            const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
+            if (decl && decl.type === 5 /* DeclarationType.Function */) {
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
+                    name: memberName,
+                    className: baseClass.shared.name,
+                }), decl.node.d.name);
+                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+                if (diag && origDecl) {
+                    diag.addRelatedInfo(localize_1.LocAddendum.finalMethod(), origDecl.uri, origDecl.range);
                 }
             }
+        }
+        if ((0, types_1.isFunctionOrOverloaded)(baseType)) {
+            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Don't check certain magic functions or private symbols.
             // Also, skip this check if the class is a TypedDict. The methods for a TypedDict
             // are synthesized, and they can result in many overloads. We assume they
@@ -4676,7 +4717,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Special-case overrides of methods in '_TypedDict', since
                 // TypedDict attributes aren't manifest as attributes but rather
                 // as named keys.
-                if (types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
+                if (types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'TypedDictFallback'])) {
                     return;
                 }
                 const decls = overrideSymbol.getDeclarations();
@@ -4844,24 +4885,26 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _isFinalFunction(name, type) {
+    _isFinalFunction(name, symbol, type) {
         if (SymbolNameUtils.isPrivateName(name)) {
             return false;
         }
-        if ((0, types_1.isFunction)(type) && types_1.FunctionType.isFinal(type)) {
-            return true;
-        }
-        if ((0, types_1.isOverloaded)(type)) {
-            const overloads = types_1.OverloadedType.getOverloads(type);
-            const impl = types_1.OverloadedType.getImplementation(type);
-            if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
-                return true;
+        // Was this declared with a "def" statement?
+        const defDecls = [];
+        symbol.getDeclarations().forEach((decl) => {
+            if (decl.type === 5 /* DeclarationType.Function */ && decl.node.nodeType === 31 /* ParseNodeType.Function */) {
+                defDecls.push(decl.node);
             }
-            if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
-                return true;
+        });
+        // Locate all final function declarations.
+        const finalDefDecls = defDecls.filter((decl) => {
+            const undecoratedFuncType = this._evaluator.getTypeOfFunction(decl)?.functionType;
+            if (!undecoratedFuncType) {
+                return false;
             }
-        }
-        return false;
+            return types_1.FunctionType.isFinal(undecoratedFuncType);
+        });
+        return finalDefDecls.length > 0;
     }
     _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
@@ -4899,15 +4942,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     return;
                 }
-                else if (this._isFinalFunction(methodName, baseClassPropMethod)) {
-                    const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
-                    if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
-                            name: memberName,
-                            className: baseClassType.shared.name,
-                        }), decl.node.d.name);
-                    }
-                }
                 const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
                 if (!(0, types_1.isFunction)(subclassMethodType)) {
                     return;
@@ -5185,7 +5219,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             types_1.ClassType.isBuiltIn(declaredReturnType, 'AwaitableGenerator')) {
             // Handle the old-style (pre-await) generator case
             // if the return type explicitly uses AwaitableGenerator.
-            generatorType = this._evaluator.getTypingType(node, 'AwaitableGenerator');
+            generatorType =
+                this._evaluator.getTypeCheckerInternalsType(node, 'AwaitableGenerator') ??
+                    this._evaluator.getTypingType(node, 'AwaitableGenerator');
         }
         else {
             generatorType = this._evaluator.getTypingType(node, enclosingFunctionNode.d.isAsync ? 'AsyncGenerator' : 'Generator');
@@ -5274,6 +5310,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Were all of the exception types overridden?
                 if (typesOfThisExcept.length > 0 && typesOfThisExcept.length === overriddenExceptionCount) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExcept, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.d.typeExpr);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnreachable, localize_1.LocMessage.unreachableCodeType(), except.d.exceptSuite, except.d.exceptToken);
                     this._evaluator.addUnreachableCode(except, typeEvaluatorTypes_1.Reachability.UnreachableByAnalysis, except.d.exceptSuite);
                 }
             }