[ty] Fix unary and comparison operators for TypeVars with union bounds

This fixes an issue where comparison and unary operators were incorrectly
flagged as unsupported for TypeVars with union bounds (e.g., `bound=float`
which becomes `int | float`).

Fixes astral-sh/ty#2652

Author: carljm

crates/ty_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md

@@ -412,3 +412,95 @@ import b
 # error: [unsupported-operator] "Operator `<` is not supported between objects of type `a.Foo` and `b.Foo`"
 a.Foo() < b.Foo()
 ```
+
+## TypeVar Comparisons
+
+TypeVars with bounds support comparison operations if the bound type supports them.
+
+### TypeVar with `float` bound
+
+Since `float` is treated as `int | float` in type annotations, TypeVars bounded by `float` should
+support all comparison operations that both `int` and `float` support:
+
+```py
+from typing import TypeVar, Generic
+
+T = TypeVar("T", bound=float)
+
+class Range(Generic[T]):
+    min: T
+    max: T
+
+    def __init__(self, min: T, max: T) -> None:
+        self.min = min
+        self.max = max
+
+    def __contains__(self, value: T) -> bool:
+        return self.min <= value <= self.max
+
+def compare_float_bound(a: T, b: T) -> bool:
+    return a <= b
+
+def compare_with_literal(a: T) -> bool:
+    return a <= 1.0
+```
+
+### TypeVar with `int` bound
+
+TypeVars bounded by `int` should support comparison operations:
+
+```py
+from typing import TypeVar
+
+U = TypeVar("U", bound=int)
+
+def compare_int_bound(a: U, b: U) -> bool:
+    return a <= b
+```
+
+### TypeVar with `str` bound
+
+TypeVars bounded by `str` should support comparison operations:
+
+```py
+from typing import TypeVar
+
+V = TypeVar("V", bound=str)
+
+def compare_str_bound(a: V, b: V) -> bool:
+    return a <= b
+```
+
+### Constrained TypeVar comparisons
+
+Constrained TypeVars support comparisons if all constraints support the operation:
+
+```py
+from typing import TypeVar
+
+W = TypeVar("W", int, str)
+
+def compare_constrained(a: W, b: W) -> bool:
+    # Both int and str support ==
+    return a == b
+
+X = TypeVar("X", int, str)
+
+def compare_constrained_lt(a: X, b: X) -> bool:
+    # Both int and str support <
+    return a < b
+```
+
+### TypeVar with `complex` bound
+
+`complex` is treated as `int | float | complex`. Since `complex` doesn't support ordering
+comparisons like `<` and `<=`, only equality comparisons should work:
+
+```py
+from typing import TypeVar
+
+Y = TypeVar("Y", bound=complex)
+
+def compare_complex_eq(a: Y, b: Y) -> bool:
+    return a == b
+```

crates/ty_python_semantic/resources/mdtest/unary/invert_add_usub.md

@@ -31,3 +31,59 @@ b = NoDunder()
 -b  # error: [unsupported-operator] "Unary operator `-` is not supported for object of type `NoDunder`"
 ~b  # error: [unsupported-operator] "Unary operator `~` is not supported for object of type `NoDunder`"
 ```
+
+## TypeVar with bounds
+
+TypeVars with bounds support unary operators if the bound type supports them.
+
+### TypeVar with `float` bound
+
+Since `float` is treated as `int | float` in type annotations, TypeVars bounded by `float` should
+support unary `+` and `-` operators:
+
+```py
+from typing import TypeVar
+
+T = TypeVar("T", bound=float)
+
+def neg_float_bound(a: T) -> float:
+    reveal_type(-a)  # revealed: int | float
+    return -a
+
+def pos_float_bound(a: T) -> float:
+    reveal_type(+a)  # revealed: int | float
+    return +a
+```
+
+### TypeVar with `int` bound
+
+TypeVars bounded by `int` should support all unary numeric operators:
+
+```py
+from typing import TypeVar
+
+U = TypeVar("U", bound=int)
+
+def neg_int_bound(a: U) -> int:
+    reveal_type(-a)  # revealed: int
+    return -a
+
+def invert_int_bound(a: U) -> int:
+    reveal_type(~a)  # revealed: int
+    return ~a
+```
+
+### Constrained TypeVar
+
+Constrained TypeVars support unary operators if all constraints support them. When the operator
+returns the same type for each constraint (e.g., `-int -> int`), the TypeVar is preserved:
+
+```py
+from typing import TypeVar
+
+V = TypeVar("V", int, float)
+
+def neg_constrained(a: V) -> V:
+    reveal_type(-a)  # revealed: V@neg_constrained
+    return -a
+```

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -12573,8 +12573,15 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             }
                         }
                     }
-                    // For bounded TypeVars or unconstrained TypeVars, fall through to default handling.
-                    _ => match operand_type.try_call_dunder(
+                    // For bounded TypeVars with union bounds (like `bound=float` which becomes
+                    // `int | float`), we need to delegate to the bound type. The `self` types of
+                    // the dunder methods in typeshed don't match because they don't get the same
+                    // `int | float` special treatment.
+                    Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
+                        self.infer_unary_expression_type(op, bound, unary)
+                    }
+                    // For unconstrained TypeVars, fall through to default handling.
+                    None => match operand_type.try_call_dunder(
                         self.db(),
                         unary_dunder_method,
                         CallArguments::none(),
@@ -13786,6 +13793,89 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 }),
             ),
 
+            // Similar to `NewType`s, `TypeVar`s with union bounds (like `bound=float` which becomes
+            // `int | float`) need to delegate to the bound type. The `self` types of the dunder
+            // methods in typeshed don't match because they don't get the same `int | float` special
+            // treatment. In those cases we need to explicitly delegate to the bound type, so that
+            // it hits the `Type::Union` branches above.
+            //
+            // When both operands are the same bounded TypeVar, we check the comparison on the bound
+            // type paired with itself.
+            (Type::TypeVar(left_tvar), Type::TypeVar(right_tvar))
+                if left_tvar.identity(self.db()) == right_tvar.identity(self.db()) =>
+            {
+                match left_tvar.typevar(self.db()).bound_or_constraints(self.db()) {
+                    Some(TypeVarBoundOrConstraints::UpperBound(bound)) => Some(
+                        try_dunder(self, MemberLookupPolicy::default()).or_else(|_| {
+                            visitor.visit((left, op, right), || {
+                                self.infer_binary_type_comparison(bound, op, bound, range, visitor)
+                            })
+                        }),
+                    ),
+                    Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
+                        // For constrained TypeVars, check each constraint paired with itself.
+                        let mut builder = UnionBuilder::new(self.db());
+                        for &constraint in constraints.elements(self.db()) {
+                            builder = builder.add(self.infer_binary_type_comparison(
+                                constraint,
+                                op,
+                                constraint,
+                                range,
+                                visitor,
+                            )?);
+                        }
+                        Some(Ok(builder.build()))
+                    }
+                    None => None, // Fall through to default handling
+                }
+            }
+            // When the left operand is a bounded TypeVar and the right is not a TypeVar,
+            // delegate to the bound type.
+            (Type::TypeVar(left_tvar), right) if !right.is_type_var() => {
+                match left_tvar.typevar(self.db()).bound_or_constraints(self.db()) {
+                    Some(TypeVarBoundOrConstraints::UpperBound(bound)) => Some(
+                        try_dunder(self, MemberLookupPolicy::default()).or_else(|_| {
+                            visitor.visit((left, op, right), || {
+                                self.infer_binary_type_comparison(bound, op, right, range, visitor)
+                            })
+                        }),
+                    ),
+                    Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
+                        let mut builder = UnionBuilder::new(self.db());
+                        for &constraint in constraints.elements(self.db()) {
+                            builder = builder.add(self.infer_binary_type_comparison(
+                                constraint, op, right, range, visitor,
+                            )?);
+                        }
+                        Some(Ok(builder.build()))
+                    }
+                    None => None,
+                }
+            }
+            // When the right operand is a bounded TypeVar and the left is not a TypeVar,
+            // delegate to the bound type.
+            (left, Type::TypeVar(right_tvar)) if !left.is_type_var() => {
+                match right_tvar.typevar(self.db()).bound_or_constraints(self.db()) {
+                    Some(TypeVarBoundOrConstraints::UpperBound(bound)) => Some(
+                        try_dunder(self, MemberLookupPolicy::default()).or_else(|_| {
+                            visitor.visit((left, op, right), || {
+                                self.infer_binary_type_comparison(left, op, bound, range, visitor)
+                            })
+                        }),
+                    ),
+                    Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
+                        let mut builder = UnionBuilder::new(self.db());
+                        for &constraint in constraints.elements(self.db()) {
+                            builder = builder.add(self.infer_binary_type_comparison(
+                                left, op, constraint, range, visitor,
+                            )?);
+                        }
+                        Some(Ok(builder.build()))
+                    }
+                    None => None,
+                }
+            }
+
             (Type::IntLiteral(n), Type::IntLiteral(m)) => Some(match op {
                 ast::CmpOp::Eq => Ok(Type::BooleanLiteral(n == m)),
                 ast::CmpOp::NotEq => Ok(Type::BooleanLiteral(n != m)),