@zzzen/pyright-internal 1.2.0-dev.20250202 → 1.2.0-dev.20250216

package/dist/analyzer/checker.js

@@ -475,7 +475,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
                         type: this._evaluator.printType(returnType),
                     }), node);
-                    if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'Coroutine')) {
+                    if ((0, types_1.isClassInstance)(returnType) &&
+                        types_1.ClassType.isBuiltIn(returnType, ['Coroutine', 'CoroutineType'])) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine, localize_1.LocMessage.unusedCoroutine(), node);
                     }
                 }
@@ -643,7 +644,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const yieldFromType = this._evaluator.getType(node.d.expr) || types_1.UnknownType.create();
         let yieldType;
         let sendType;
-        if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
+        if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, ['Coroutine', 'CoroutineType'])) {
             // Handle the case of old-style (pre-await) coroutines.
             yieldType = types_1.UnknownType.create();
         }
@@ -911,6 +912,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             node.d.targets.forEach((name) => {
                 this._evaluator.getType(name);
                 this.walk(name);
+                this._validateNonlocalTypeParam(name);
             });
         });
         return false;
@@ -1188,7 +1190,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype)) {
                 isExprFunction = false;
             }
-            if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, 'Coroutine')) {
+            if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ['Coroutine', 'CoroutineType'])) {
                 isCoroutine = false;
             }
         });
@@ -1237,6 +1239,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExpression, localize_1.LocMessage.unusedExpression(), node);
         }
     }
+    // Verifies that the target of a nonlocal statement is not a PEP 695-style
+    // TypeParameter. This situation results in a runtime exception.
+    _validateNonlocalTypeParam(node) {
+        // Look up the symbol to see if it's a type parameter.
+        const symbolWithScope = this._evaluator.lookUpSymbolRecursive(node, node.d.value, /* honorCodeFlow */ false);
+        if (!symbolWithScope || symbolWithScope.scope.type !== 0 /* ScopeType.TypeParameter */) {
+            return;
+        }
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.nonlocalTypeParam().format({ name: node.d.value }), node);
+    }
     _validateExhaustiveMatch(node) {
         // This check can be expensive, so skip it if it's disabled.
         if (this._fileInfo.diagnosticRuleSet.reportMatchNotExhaustive === 'none') {
@@ -1370,7 +1382,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (isComparable) {
                         return;
                     }
-                    if (this._isTypeComparable(leftSubtype, rightSubtype)) {
+                    if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype)) {
                         isComparable = true;
                     }
                     return rightSubtype;
@@ -1387,71 +1399,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    // Determines whether the two types are potentially comparable -- i.e.
-    // their types overlap in such a way that it makes sense for them to
-    // be compared with an == or != operator.
-    _isTypeComparable(leftType, rightType) {
-        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
-            return true;
-        }
-        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-            return false;
-        }
-        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
-            return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
-        }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
-        if (isLeftCallable !== isRightCallable) {
-            return false;
-        }
-        if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
-            if ((0, types_1.isInstantiableClass)(rightType) ||
-                ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
-                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
-                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
-                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
-                    this._evaluator.assignType(genericRightType, genericLeftType)) {
-                    return true;
-                }
-            }
-            // Does the class have an operator overload for eq?
-            const metaclass = leftType.shared.effectiveMetaclass;
-            if (metaclass && (0, types_1.isClass)(metaclass)) {
-                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        if ((0, types_1.isClassInstance)(leftType)) {
-            if ((0, types_1.isClass)(rightType)) {
-                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
-                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
-                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
-                    this._evaluator.assignType(genericRightType, genericLeftType)) {
-                    return true;
-                }
-                // Assume that if the types are disjoint and built-in classes that they
-                // will never be comparable.
-                if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
-                    return false;
-                }
-            }
-            // Does the class have an operator overload for eq?
-            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
-            if (eqMethod) {
-                // If this is a synthesized method for a dataclass, we can assume
-                // that other dataclass types will not be comparable.
-                if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
-                    return false;
-                }
-                return true;
-            }
-            return false;
-        }
-        return true;
-    }
     // If the function is a generator, validates that its annotated return type
     // is appropriate for a generator.
     _validateGeneratorReturnType(node, functionType) {
@@ -2113,6 +2060,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             implementation = type;
         }
         if (!implementation) {
+            // If this is a method within a protocol class, don't require that
+            // there is an implementation.
             const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
             if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
                 const classType = this._evaluator.getTypeOfClass(containingClassNode);
@@ -2128,8 +2077,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
-            // If this is a method within a protocol class, don't require that
-            // there is an implementation.
+            // If the declaration isn't associated with any of the overloads in the
+            // type, the overloads came from a decorator that captured the overload
+            // from somewhere else.
+            if (!overloads.find((overload) => overload.shared.declaration === primaryDecl)) {
+                return;
+            }
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportNoOverloadImplementation, localize_1.LocMessage.overloadWithoutImplementation().format({
                 name: primaryDecl.node.d.name.d.value,
             }), primaryDecl.node.d.name);
@@ -4613,24 +4566,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Determine whether this is an attempt to override a method marked @final.
-            let reportFinalMethodOverride = false;
-            // Private names (starting with double underscore) are exempt from this check.
-            if (!SymbolNameUtils.isPrivateName(memberName)) {
-                if ((0, types_1.isFunction)(baseType) && types_1.FunctionType.isFinal(baseType)) {
-                    reportFinalMethodOverride = true;
-                }
-                else if ((0, types_1.isOverloaded)(baseType)) {
-                    const overloads = types_1.OverloadedType.getOverloads(baseType);
-                    const impl = types_1.OverloadedType.getImplementation(baseType);
-                    if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
-                        reportFinalMethodOverride = true;
-                    }
-                    if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
-                        reportFinalMethodOverride = true;
-                    }
-                }
-            }
-            if (reportFinalMethodOverride) {
+            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({
@@ -4839,6 +4775,25 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    _isFinalFunction(name, 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;
+            }
+            if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
+                return true;
+            }
+        }
+        return false;
+    }
     _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
             ['fget', (c) => c.priv.fgetInfo?.methodType],
@@ -4875,6 +4830,15 @@ 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;