Python
/
ruff
mirror of https://github.com/astral-sh/ruff
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Return bool

This commit is contained in:
Charlie Marsh 2025-12-06 10:26:56 -05:00
parent e20d1a837a
commit 8ef82e96fc
5 changed files with 112 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
crates/ty_python_semantic/resources/mdtest/comparison/tuples.md
View File

@ -352,8 +352,8 @@ def f(
c: tuple[str],
):
# Equality comparisons are always valid
reveal_type(a == b) # revealed: Unknown
reveal_type(a != b) # revealed: Unknown
reveal_type(a == b) # revealed: bool
reveal_type(a != b) # revealed: bool
# Ordering comparisons between incompatible types should emit errors
# error: [unsupported-operator] "Operator `<` is not supported between objects of type `tuple[int, ...]` and `tuple[str, ...]`"
@ -400,16 +400,16 @@ Comparisons between homogeneous tuples with compatible element types should work
```py
def _(a: tuple[int, ...], b: tuple[int, ...], c: tuple[bool, ...]):
# Same element types - always valid
reveal_type(a == b) # revealed: Unknown
reveal_type(a != b) # revealed: Unknown
reveal_type(a < b) # revealed: Unknown
reveal_type(a <= b) # revealed: Unknown
reveal_type(a > b) # revealed: Unknown
reveal_type(a >= b) # revealed: Unknown
reveal_type(a == b) # revealed: bool
reveal_type(a != b) # revealed: bool
reveal_type(a < b) # revealed: bool
reveal_type(a <= b) # revealed: bool
reveal_type(a > b) # revealed: bool
reveal_type(a >= b) # revealed: bool
# int and bool are compatible for comparison
reveal_type(a < c) # revealed: Unknown
reveal_type(c < a) # revealed: Unknown
reveal_type(a < c) # revealed: bool
reveal_type(c < a) # revealed: bool
```
### Tuples with Prefixes and Suffixes
@ -441,7 +441,7 @@ def _(
prefix_int_var_bool: tuple[int, *tuple[bool, ...]],
):
# Prefix `int` vs. prefix `int`, variable `int` vs. variable `bool` are all comparable.
reveal_type(prefix_int_var_int < prefix_int_var_bool) # revealed: Unknown
reveal_type(prefix_int_var_int < prefix_int_var_bool) # revealed: bool
```
## Chained comparisons with elements that incorrectly implement `__bool__`

8
crates/ty_python_semantic/resources/mdtest/snapshots/tuples.md_-_Comparison___Tuples_-_Homogeneous_-_Tuples_with_Prefixes…_(c25079c01f6d8eb3).snap
View File

@ -16,15 +16,15 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/comparison/tuples.md
2 | prefix_int_var_str: tuple[int, *tuple[str, ...]],
3 | prefix_str_var_int: tuple[str, *tuple[int, ...]],
4 | ):
5 | # Prefix int vs prefix str - NOT ok
5 | # Prefix `int` vs. prefix `str` are not comparable.
6 | # error: [unsupported-operator]
7 | prefix_int_var_str < prefix_str_var_int
8 | def _(
9 | prefix_int_var_int: tuple[int, *tuple[int, ...]],
10 | prefix_int_var_bool: tuple[int, *tuple[bool, ...]],
11 | ):
12 | # Prefix int vs prefix int, variable int vs variable bool - all ok
13 | reveal_type(prefix_int_var_int < prefix_int_var_bool) # revealed: Unknown
12 | # Prefix `int` vs. prefix `int`, variable `int` vs. variable `bool` are all comparable.
13 | reveal_type(prefix_int_var_int < prefix_int_var_bool) # revealed: bool
```
# Diagnostics
@ -33,7 +33,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/comparison/tuples.md
error[unsupported-operator]: Unsupported `<` operation
--> src/mdtest_snippet.py:7:5
|
5 | # Prefix int vs prefix str - NOT ok
5 | # Prefix `int` vs. prefix `str` are not comparable.
6 | # error: [unsupported-operator]
7 | prefix_int_var_str < prefix_str_var_int
| ------------------^^^------------------

4
crates/ty_python_semantic/resources/mdtest/snapshots/tuples.md_-_Comparison___Tuples_-_Homogeneous_-_Unsupported_Comparis…_(400a427b33d53e00).snap
View File

@ -18,8 +18,8 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/comparison/tuples.md
4 | c: tuple[str],
5 | ):
6 | # Equality comparisons are always valid
7 | reveal_type(a == b) # revealed: Unknown
8 | reveal_type(a != b) # revealed: Unknown
7 | reveal_type(a == b) # revealed: bool
8 | reveal_type(a != b) # revealed: bool
9 |
10 | # Ordering comparisons between incompatible types should emit errors
11 | # error: [unsupported-operator] "Operator `<` is not supported between objects of type `tuple[int, ...]` and `tuple[str, ...]`"

1
crates/ty_python_semantic/src/types.rs
View File

@ -10478,7 +10478,6 @@ impl<'db> TypeVarBoundOrConstraints<'db> {
.zip(prev_elements.iter())
.map(|(ty, prev_ty)| ty.cycle_normalized(db, *prev_ty, cycle))
.collect::<Box<_>>(),
RecursivelyDefined::No,
))
}
// The choice of whether it's an upper bound or constraints is purely syntactic and

128
crates/ty_python_semantic/src/types/infer/builder.rs
View File

@ -11060,12 +11060,14 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
"infer_binary_type_comparison should never return None for `CmpOp::Eq`",
);
match pairwise_eq_result.try_bool(self.db()).unwrap_or_else(|err| {
// TODO: We should, whenever possible, pass the range of the left and right elements
// instead of the range of the whole tuple.
err.report_diagnostic(&self.context, range);
err.fallback_truthiness()
}) {
match pairwise_eq_result
.try_bool(self.db())
.unwrap_or_else(|err| {
// TODO: We should, whenever possible, pass the range of the left and right elements
// instead of the range of the whole tuple.
err.report_diagnostic(&self.context, range);
err.fallback_truthiness()
}) {
// - AlwaysTrue : Continue to the next pair for lexicographic comparison
Truthiness::AlwaysTrue => continue,
// - AlwaysFalse:
@ -11125,71 +11127,88 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
// compare lexicographically. However, we still need to verify that the
// element types are comparable for ordering comparisons.
// For equality comparisons (==, !=), any two objects can be compared.
// For equality comparisons (==, !=), any two objects can be compared,
// and tuple equality always returns bool regardless of element __eq__ return types.
(TupleSpec::Variable(_), _) | (_, TupleSpec::Variable(_))
if matches!(op, RichCompareOperator::Eq | RichCompareOperator::Ne) =>
{
Ok(Type::unknown())
Ok(KnownClass::Bool.to_instance(self.db()))
}
// Both variable: check all elements that could potentially be compared.
(TupleSpec::Variable(left_var), TupleSpec::Variable(right_var)) => {
let mut builder = UnionBuilder::new(self.db());
// 1. Compare prefix elements at matching positions.
for (l_el, r_el) in left_var.prefix_elements().zip(right_var.prefix_elements()) {
self.infer_binary_type_comparison(*l_el, op.into(), *r_el, range, visitor)?;
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
*r_el,
range,
visitor,
)?);
}
// 2. Left's extra prefix elements are compared with right's variable.
for l_el in left_var.prefix_elements().skip(right_var.prefix.len()) {
self.infer_binary_type_comparison(
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
right_var.variable,
range,
visitor,
)?;
)?);
}
// 3. Right's extra prefix elements are compared with left's variable.
for r_el in right_var.prefix_elements().skip(left_var.prefix.len()) {
self.infer_binary_type_comparison(
builder = builder.add(self.infer_binary_type_comparison(
left_var.variable,
op.into(),
*r_el,
range,
visitor,
)?;
)?);
}
// 4. Variable elements can be compared at any overlapping position.
self.infer_binary_type_comparison(
builder = builder.add(self.infer_binary_type_comparison(
left_var.variable,
op.into(),
right_var.variable,
range,
visitor,
)?;
)?);
// 5. Left's extra suffix elements are compared with right's variable.
for l_el in left_var.suffix_elements().rev().skip(right_var.suffix.len()) {
self.infer_binary_type_comparison(
for l_el in left_var
.suffix_elements()
.rev()
.skip(right_var.suffix.len())
{
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
right_var.variable,
range,
visitor,
)?;
)?);
}
// 6. Right's extra suffix elements are compared with left's variable.
for r_el in right_var.suffix_elements().rev().skip(left_var.suffix.len()) {
self.infer_binary_type_comparison(
for r_el in right_var
.suffix_elements()
.rev()
.skip(left_var.suffix.len())
{
builder = builder.add(self.infer_binary_type_comparison(
left_var.variable,
op.into(),
*r_el,
range,
visitor,
)?;
)?);
}
// 7. Compare suffix elements at matching positions (from the end).
@ -11198,17 +11217,34 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
.rev()
.zip(right_var.suffix_elements().rev())
{
self.infer_binary_type_comparison(*l_el, op.into(), *r_el, range, visitor)?;
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
*r_el,
range,
visitor,
)?);
}
Ok(Type::unknown())
// Length comparison (when all elements are equal) returns bool.
builder = builder.add(KnownClass::Bool.to_instance(self.db()));
Ok(builder.build())
}
// Left variable, right fixed: check which elements could be compared.
(TupleSpec::Variable(left_var), TupleSpec::Fixed(right_fixed)) => {
let mut builder = UnionBuilder::new(self.db());
// Compare left's prefix with right's corresponding elements.
for (l_el, r_el) in left_var.prefix_elements().zip(right_fixed.elements()) {
self.infer_binary_type_comparison(*l_el, op.into(), *r_el, range, visitor)?;
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
*r_el,
range,
visitor,
)?);
}
// Compare left's suffix with right's corresponding elements (from end).
@ -11217,7 +11253,13 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
.rev()
.zip(right_fixed.elements().rev())
{
self.infer_binary_type_comparison(*l_el, op.into(), *r_el, range, visitor)?;
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
*r_el,
range,
visitor,
)?);
}
// Compare left's variable with right's "middle" elements
@ -11229,23 +11271,34 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
.skip(middle_start)
.take(middle_end.saturating_sub(middle_start))
{
self.infer_binary_type_comparison(
builder = builder.add(self.infer_binary_type_comparison(
left_var.variable,
op.into(),
*r_el,
range,
visitor,
)?;
)?);
}
Ok(Type::unknown())
// Length comparison (when all elements are equal) returns bool.
builder = builder.add(KnownClass::Bool.to_instance(self.db()));
Ok(builder.build())
}
// Left fixed, right variable: check which elements could be compared.
(TupleSpec::Fixed(left_fixed), TupleSpec::Variable(right_var)) => {
let mut builder = UnionBuilder::new(self.db());
// Compare left's elements with right's prefix.
for (l_el, r_el) in left_fixed.elements().zip(right_var.prefix_elements()) {
self.infer_binary_type_comparison(*l_el, op.into(), *r_el, range, visitor)?;
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
*r_el,
range,
visitor,
)?);
}
// Compare left's elements (from end) with right's suffix.
@ -11254,7 +11307,13 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
.rev()
.zip(right_var.suffix_elements().rev())
{
self.infer_binary_type_comparison(*l_el, op.into(), *r_el, range, visitor)?;
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
*r_el,
range,
visitor,
)?);
}
// Compare left's "middle" elements with right's variable.
@ -11265,16 +11324,19 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
.skip(middle_start)
.take(middle_end.saturating_sub(middle_start))
{
self.infer_binary_type_comparison(
builder = builder.add(self.infer_binary_type_comparison(
*l_el,
op.into(),
right_var.variable,
range,
visitor,
)?;
)?);
}
Ok(Type::unknown())
// Length comparison (when all elements are equal) returns bool.
builder = builder.add(KnownClass::Bool.to_instance(self.db()));
Ok(builder.build())
}
}
}