mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-09-29 21:34:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

[ty] Remove special casing for string-literal-in-tuple __contains__ (#19642)

Browse source
This commit is contained in:
Alex Waygood 2025-07-31 11:28:03 +01:00 • committed by GitHub
parent 32c454bb56
commit 27b03a9d7b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 156 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

49
crates/ty_python_semantic/resources/mdtest/binary/in.md
View file

@ -1,49 +0,0 @@
# Static binary operations using `in`
## Basic functionality
This demonstrates type inference support for `<str-literal> in <tuple>`:
```py
from ty_extensions import static_assert
static_assert("foo" in ("quux", "foo", "baz"))
static_assert("foo" not in ("quux", "bar", "baz"))
```
## With variables
```py
from ty_extensions import static_assert
x = ("quux", "foo", "baz")
static_assert("foo" in x)
x = ("quux", "bar", "baz")
static_assert("foo" not in x)
```
## Statically unknown results in a `bool`
```py
def _(a: str, b: str):
reveal_type("foo" in (a, b)) # revealed: bool
```
## Values being unknown doesn't mean the result is unknown
For example, when the types are completely disjoint:
```py
from ty_extensions import static_assert
def _(a: int, b: int):
static_assert("foo" not in (a, b))
```
## Failure cases
```py
# We don't support byte strings.
reveal_type(b"foo" not in (b"quux", b"foo", b"baz")) # revealed: bool
```

238
crates/ty_python_semantic/resources/mdtest/ide_support/all_members.md
View file

@ -1,60 +1,65 @@
# List all members # List all members
This test suite acts as a set of unit tests for our `ide_support::all_members` routine, which lists
all members available on a given type. This routine is used for autocomplete suggestions.
## Basic functionality ## Basic functionality
<!-- snapshot-diagnostics --> <!-- snapshot-diagnostics -->
The `ty_extensions.all_members` function allows access to a tuple of accessible members/attributes The `ty_extensions.all_members` and `ty_extensions.has_member` functions expose a Python-level API
on a given object. For example, all member functions of `str` are available on `"a"`: that can be used to query which attributes `ide_support::all_members` understands as being available
on a given object. For example, all member functions of `str` are available on `"a"`. The Python API
`all_members` returns a tuple of all available members; `has_member` returns `Literal[True]` if a
given member is present in that tuple, and `Literal[False]` if not:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import static_assert, has_member
members_of_str = all_members("a") static_assert(has_member("a", "replace"))
static_assert(has_member("a", "startswith"))
static_assert("replace" in members_of_str) static_assert(has_member("a", "isupper"))
static_assert("startswith" in members_of_str)
static_assert("isupper" in members_of_str)
``` ```
Similarly, special members such as `__add__` are also available: Similarly, special members such as `__add__` are also available:
```py ```py
static_assert("__add__" in members_of_str) static_assert(has_member("a", "__add__"))
static_assert("__gt__" in members_of_str) static_assert(has_member("a", "__gt__"))
``` ```
Members of base classes are also included (these dunder methods are defined on `object`): Members of base classes are also included (these dunder methods are defined on `object`):
```py ```py
static_assert("__doc__" in members_of_str) static_assert(has_member("a", "__doc__"))
static_assert("__repr__" in members_of_str) static_assert(has_member("a", "__repr__"))
``` ```
Non-existent members are not included: Non-existent members are not included:
```py ```py
static_assert("non_existent" not in members_of_str) static_assert(not has_member("a", "non_existent"))
``` ```
Note: The full list of all members is relatively long, but `reveal_type` can theoretically be used The full list of all members is relatively long, but `reveal_type` can be used in combination with
to see them all: `all_members` to see them all:
```py ```py
from typing_extensions import reveal_type from typing_extensions import reveal_type
from ty_extensions import all_members
reveal_type(members_of_str) # error: [revealed-type] reveal_type(all_members("a")) # error: [revealed-type]
``` ```
## Kinds of types ## Kinds of types
### Class instances ### Class instances
For instances of classes, `all_members` returns class members and implicit instance members of all For instances of classes, class members and implicit instance members of all superclasses are
classes in the MRO: understood as being available:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
class Base: class Base:
base_class_attr: int = 1 base_class_attr: int = 1
@ -86,25 +91,23 @@ class C(Intermediate):
def static_method() -> int: def static_method() -> int:
return 1 return 1
members_of_instance = all_members(C()) static_assert(has_member(C(), "base_class_attr"))
static_assert(has_member(C(), "intermediate_attr"))
static_assert(has_member(C(), "class_attr"))
static_assert("base_class_attr" in members_of_instance) static_assert(has_member(C(), "base_instance_attr"))
static_assert("intermediate_attr" in members_of_instance) static_assert(has_member(C(), "intermediate_instance_attr"))
static_assert("class_attr" in members_of_instance) static_assert(has_member(C(), "instance_attr"))
static_assert("base_instance_attr" in members_of_instance) static_assert(has_member(C(), "f_base"))
static_assert("intermediate_instance_attr" in members_of_instance) static_assert(has_member(C(), "f_intermediate"))
static_assert("instance_attr" in members_of_instance) static_assert(has_member(C(), "f_c"))
static_assert("f_base" in members_of_instance) static_assert(has_member(C(), "property_attr"))
static_assert("f_intermediate" in members_of_instance) static_assert(has_member(C(), "class_method"))
static_assert("f_c" in members_of_instance) static_assert(has_member(C(), "static_method"))
static_assert("property_attr" in members_of_instance) static_assert(not has_member(C(), "non_existent"))
static_assert("class_method" in members_of_instance)
static_assert("static_method" in members_of_instance)
static_assert("non_existent" not in members_of_instance)
``` ```
### Class objects ### Class objects
@ -112,7 +115,7 @@ static_assert("non_existent" not in members_of_instance)
Class-level attributes can also be accessed through the class itself: Class-level attributes can also be accessed through the class itself:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
class Base: class Base:
base_attr: int = 1 base_attr: int = 1
@ -123,18 +126,16 @@ class C(Base):
def f(self): def f(self):
self.instance_attr = True self.instance_attr = True
members_of_class = all_members(C) static_assert(has_member(C, "class_attr"))
static_assert(has_member(C, "base_attr"))
static_assert("class_attr" in members_of_class) static_assert(not has_member(C, "non_existent"))
static_assert("base_attr" in members_of_class)
static_assert("non_existent" not in members_of_class)
``` ```
But instance attributes can not be accessed this way: But instance attributes can not be accessed this way:
```py ```py
static_assert("instance_attr" not in members_of_class) static_assert(not has_member(C, "instance_attr"))
``` ```
When a class has a metaclass, members of that metaclass (and bases of that metaclass) are also When a class has a metaclass, members of that metaclass (and bases of that metaclass) are also
@ -150,16 +151,16 @@ class Meta(MetaBase):
class D(Base, metaclass=Meta): class D(Base, metaclass=Meta):
class_attr = 3 class_attr = 3
static_assert("meta_base_attr" in all_members(D)) static_assert(has_member(D, "meta_base_attr"))
static_assert("meta_attr" in all_members(D)) static_assert(has_member(D, "meta_attr"))
static_assert("base_attr" in all_members(D)) static_assert(has_member(D, "base_attr"))
static_assert("class_attr" in all_members(D)) static_assert(has_member(D, "class_attr"))
``` ```
### Generic classes ### Generic classes
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
from typing import Generic, TypeVar from typing import Generic, TypeVar
T = TypeVar("T") T = TypeVar("T")
@ -167,52 +168,53 @@ T = TypeVar("T")
class C(Generic[T]): class C(Generic[T]):
base_attr: T base_attr: T
static_assert("base_attr" in all_members(C[int])) static_assert(has_member(C[int], "base_attr"))
static_assert("base_attr" in all_members(C[int]())) static_assert(has_member(C[int](), "base_attr"))
``` ```
### Other instance-like types ### Other instance-like types
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
from typing_extensions import LiteralString from typing_extensions import LiteralString
static_assert("__xor__" in all_members(True)) static_assert(has_member(True, "__xor__"))
static_assert("bit_length" in all_members(1)) static_assert(has_member(1, "bit_length"))
static_assert("startswith" in all_members("a")) static_assert(has_member("a", "startswith"))
static_assert("__buffer__" in all_members(b"a")) static_assert(has_member(b"a", "__buffer__"))
static_assert("is_integer" in all_members(3.14)) static_assert(has_member(3.14, "is_integer"))
def _(literal_string: LiteralString): def _(literal_string: LiteralString):
static_assert("startswith" in all_members(literal_string)) static_assert(has_member(literal_string, "startswith"))
static_assert("count" in all_members(("some", "tuple", 1, 2))) static_assert(has_member(("some", "tuple", 1, 2), "count"))
static_assert("__doc__" in all_members(len)) static_assert(has_member(len, "__doc__"))
static_assert("__doc__" in all_members("a".startswith)) static_assert(has_member("a".startswith, "__doc__"))
``` ```
### Enums ### Enums
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
from enum import Enum from enum import Enum
class Answer(Enum): class Answer(Enum):
NO = 0 NO = 0
YES = 1 YES = 1
static_assert("NO" in all_members(Answer)) static_assert(has_member(Answer, "NO"))
static_assert("YES" in all_members(Answer)) static_assert(has_member(Answer, "YES"))
static_assert("__members__" in all_members(Answer)) static_assert(has_member(Answer, "__members__"))
``` ```
### Unions ### Unions
For unions, `all_members` will only return members that are available on all elements of the union. For unions, `ide_support::all_members` only returns members that are available on all elements of
the union.
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
class A: class A:
on_both: int = 1 on_both: int = 1
@ -223,20 +225,20 @@ class B:
only_on_b: str = "b" only_on_b: str = "b"
def f(union: A | B): def f(union: A | B):
static_assert("on_both" in all_members(union)) static_assert(has_member(union, "on_both"))
static_assert("only_on_a" not in all_members(union)) static_assert(not has_member(union, "only_on_a"))
static_assert("only_on_b" not in all_members(union)) static_assert(not has_member(union, "only_on_b"))
``` ```
### Intersections ### Intersections
#### Only positive types #### Only positive types
Conversely, for intersections, `all_members` will list members that are available on any of the Conversely, for intersections, `ide_support::all_members` lists members that are available on any of
elements: the elements:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
class A: class A:
on_both: int = 1 on_both: int = 1
@ -249,9 +251,9 @@ class B:
def f(intersection: object): def f(intersection: object):
if isinstance(intersection, A): if isinstance(intersection, A):
if isinstance(intersection, B): if isinstance(intersection, B):
static_assert("on_both" in all_members(intersection)) static_assert(has_member(intersection, "on_both"))
static_assert("only_on_a" in all_members(intersection)) static_assert(has_member(intersection, "only_on_a"))
static_assert("only_on_b" in all_members(intersection)) static_assert(has_member(intersection, "only_on_b"))
``` ```
#### With negative types #### With negative types
@ -259,7 +261,7 @@ def f(intersection: object):
It also works when negative types are introduced: It also works when negative types are introduced:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
class A: class A:
on_all: int = 1 on_all: int = 1
@ -284,27 +286,27 @@ def f(intersection: object):
if isinstance(intersection, B): if isinstance(intersection, B):
if not isinstance(intersection, C): if not isinstance(intersection, C):
reveal_type(intersection) # revealed: A & B & ~C reveal_type(intersection) # revealed: A & B & ~C
static_assert("on_all" in all_members(intersection)) static_assert(has_member(intersection, "on_all"))
static_assert("only_on_a" in all_members(intersection)) static_assert(has_member(intersection, "only_on_a"))
static_assert("only_on_b" in all_members(intersection)) static_assert(has_member(intersection, "only_on_b"))
static_assert("only_on_c" not in all_members(intersection)) static_assert(not has_member(intersection, "only_on_c"))
static_assert("only_on_ab" in all_members(intersection)) static_assert(has_member(intersection, "only_on_ab"))
static_assert("only_on_ac" in all_members(intersection)) static_assert(has_member(intersection, "only_on_ac"))
static_assert("only_on_bc" in all_members(intersection)) static_assert(has_member(intersection, "only_on_bc"))
``` ```
## Modules ## Modules
### Basic support with sub-modules ### Basic support with sub-modules
`all_members` can also list attributes on modules: `ide_support::all_members` can also list attributes on modules:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
import math import math
static_assert("pi" in all_members(math)) static_assert(has_member(math, "pi"))
static_assert("cos" in all_members(math)) static_assert(has_member(math, "cos"))
``` ```
This also works for submodules: This also works for submodules:
@ -312,18 +314,18 @@ This also works for submodules:
```py ```py
import os import os
static_assert("path" in all_members(os)) static_assert(has_member(os, "path"))
import os.path import os.path
static_assert("join" in all_members(os.path)) static_assert(has_member(os.path, "join"))
``` ```
Special members available on all modules are also included: Special members available on all modules are also included:
```py ```py
static_assert("__name__" in all_members(math)) static_assert(has_member(math, "__name__"))
static_assert("__doc__" in all_members(math)) static_assert(has_member(math, "__doc__"))
``` ```
### `__all__` is not respected for direct module access ### `__all__` is not respected for direct module access
@ -331,12 +333,12 @@ static_assert("__doc__" in all_members(math))
`foo.py`: `foo.py`:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
import bar import bar
static_assert("lion" in all_members(bar)) static_assert(has_member(bar, "lion"))
static_assert("tiger" in all_members(bar)) static_assert(has_member(bar, "tiger"))
``` ```
`bar.py`: `bar.py`:
@ -348,17 +350,17 @@ lion = 1
tiger = 1 tiger = 1
``` ```
### `__all__` is respected for glob imports ### `__all__` is respected for `*` imports
`foo.py`: `foo.py`:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
import bar import bar
static_assert("lion" in all_members(bar)) static_assert(has_member(bar, "lion"))
static_assert("tiger" not in all_members(bar)) static_assert(not has_member(bar, "tiger"))
``` ```
`bar.py`: `bar.py`:
@ -400,12 +402,12 @@ def evaluate(x: Optional[int] = None) -> int: ...
`play.py`: `play.py`:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
import module import module
static_assert("evaluate" in all_members(module)) static_assert(has_member(module, "evaluate"))
static_assert("Optional" not in all_members(module)) static_assert(not has_member(module, "Optional"))
``` ```
## Conditionally available members ## Conditionally available members
@ -421,9 +423,9 @@ python-version = "3.9"
``` ```
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
static_assert("bit_count" not in all_members(42)) static_assert(not has_member(42, "bit_count"))
``` ```
### 3.10 ### 3.10
@ -434,19 +436,19 @@ python-version = "3.10"
``` ```
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
static_assert("bit_count" in all_members(42)) static_assert(has_member(42, "bit_count"))
``` ```
## Failures cases ## Failure cases
### Dynamically added members ### Dynamically added members
Dynamically added members can not be accessed: Dynamically added members cannot be accessed:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
class C: class C:
static_attr = 1 static_attr = 1
@ -460,8 +462,8 @@ class C:
c = C() c = C()
c.dynamic_attr = "a" c.dynamic_attr = "a"
static_assert("static_attr" in all_members(c)) static_assert(has_member(c, "static_attr"))
static_assert("dynamic_attr" not in all_members(c)) static_assert(not has_member(c, "dynamic_attr"))
``` ```
### Dataclasses ### Dataclasses
@ -469,24 +471,24 @@ static_assert("dynamic_attr" not in all_members(c))
So far, we do not include synthetic members of dataclasses. So far, we do not include synthetic members of dataclasses.
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
from dataclasses import dataclass from dataclasses import dataclass
@dataclass(order=True) @dataclass(order=True)
class Person: class Person:
name: str
age: int age: int
name: str
static_assert("name" in all_members(Person)) static_assert(has_member(Person, "name"))
static_assert("age" in all_members(Person)) static_assert(has_member(Person, "age"))
# These are always available, since they are also defined on `object`: # These are always available, since they are also defined on `object`:
static_assert("__init__" in all_members(Person)) static_assert(has_member(Person, "__init__"))
static_assert("__repr__" in all_members(Person)) static_assert(has_member(Person, "__repr__"))
static_assert("__eq__" in all_members(Person)) static_assert(has_member(Person, "__eq__"))
# TODO: this should ideally be available: # TODO: this should ideally be available:
static_assert("__lt__" in all_members(Person)) # error: [static-assert-error] static_assert(has_member(Person, "__lt__")) # error: [static-assert-error]
``` ```
### Attributes not available at runtime ### Attributes not available at runtime
@ -496,8 +498,8 @@ example, `__annotations__` does not exist on `int` at runtime, but it is availab
on `object` in typeshed: on `object` in typeshed:
```py ```py
from ty_extensions import all_members, static_assert from ty_extensions import has_member, static_assert
# TODO: this should ideally not be available: # TODO: this should ideally not be available:
static_assert("__annotations__" not in all_members(3)) # error: [static-assert-error] static_assert(not has_member(3, "__annotations__")) # error: [static-assert-error]
``` ```

37
crates/ty_python_semantic/resources/mdtest/snapshots/all_members.md_-_List_all_members_-_Basic_functionality_(6b9531a70334bfad).snap
View file

@ -12,33 +12,32 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/ide_support/all_members.
## mdtest_snippet.py ## mdtest_snippet.py
``` ```
1 | from ty_extensions import all_members, static_assert 1 | from ty_extensions import static_assert, has_member
2 | 2 |
3 | members_of_str = all_members("a") 3 | static_assert(has_member("a", "replace"))
4 | 4 | static_assert(has_member("a", "startswith"))
5 | static_assert("replace" in members_of_str) 5 | static_assert(has_member("a", "isupper"))
6 | static_assert("startswith" in members_of_str) 6 | static_assert(has_member("a", "__add__"))
7 | static_assert("isupper" in members_of_str) 7 | static_assert(has_member("a", "__gt__"))
8 | static_assert("__add__" in members_of_str) 8 | static_assert(has_member("a", "__doc__"))
9 | static_assert("__gt__" in members_of_str) 9 | static_assert(has_member("a", "__repr__"))
10 | static_assert("__doc__" in members_of_str) 10 | static_assert(not has_member("a", "non_existent"))
11 | static_assert("__repr__" in members_of_str) 11 | from typing_extensions import reveal_type
12 | static_assert("non_existent" not in members_of_str) 12 | from ty_extensions import all_members
13 | from typing_extensions import reveal_type 13 |
14 | 14 | reveal_type(all_members("a")) # error: [revealed-type]
15 | reveal_type(members_of_str) # error: [revealed-type]
``` ```
# Diagnostics # Diagnostics
``` ```
info[revealed-type]: Revealed type info[revealed-type]: Revealed type
--> src/mdtest_snippet.py:15:13 --> src/mdtest_snippet.py:14:13
| |
13 | from typing_extensions import reveal_type 12 | from ty_extensions import all_members
14 | 13 |
15 | reveal_type(members_of_str) # error: [revealed-type] 14 | reveal_type(all_members("a")) # error: [revealed-type]
| ^^^^^^^^^^^^^^ `tuple[Literal["__add__"], Literal["__annotations__"], Literal["__class__"], Literal["__contains__"], Literal["__delattr__"], Literal["__dict__"], Literal["__dir__"], Literal["__doc__"], Literal["__eq__"], Literal["__format__"], Literal["__ge__"], Literal["__getattribute__"], Literal["__getitem__"], Literal["__getnewargs__"], Literal["__gt__"], Literal["__hash__"], Literal["__init__"], Literal["__init_subclass__"], Literal["__iter__"], Literal["__le__"], Literal["__len__"], Literal["__lt__"], Literal["__mod__"], Literal["__module__"], Literal["__mul__"], Literal["__ne__"], Literal["__new__"], Literal["__reduce__"], Literal["__reduce_ex__"], Literal["__repr__"], Literal["__reversed__"], Literal["__rmul__"], Literal["__setattr__"], Literal["__sizeof__"], Literal["__str__"], Literal["__subclasshook__"], Literal["capitalize"], Literal["casefold"], Literal["center"], Literal["count"], Literal["encode"], Literal["endswith"], Literal["expandtabs"], Literal["find"], Literal["format"], Literal["format_map"], Literal["index"], Literal["isalnum"], Literal["isalpha"], Literal["isascii"], Literal["isdecimal"], Literal["isdigit"], Literal["isidentifier"], Literal["islower"], Literal["isnumeric"], Literal["isprintable"], Literal["isspace"], Literal["istitle"], Literal["isupper"], Literal["join"], Literal["ljust"], Literal["lower"], Literal["lstrip"], Literal["maketrans"], Literal["partition"], Literal["removeprefix"], Literal["removesuffix"], Literal["replace"], Literal["rfind"], Literal["rindex"], Literal["rjust"], Literal["rpartition"], Literal["rsplit"], Literal["rstrip"], Literal["split"], Literal["splitlines"], Literal["startswith"], Literal["strip"], Literal["swapcase"], Literal["title"], Literal["translate"], Literal["upper"], Literal["zfill"]]` | ^^^^^^^^^^^^^^^^ `tuple[Literal["__add__"], Literal["__annotations__"], Literal["__class__"], Literal["__contains__"], Literal["__delattr__"], Literal["__dict__"], Literal["__dir__"], Literal["__doc__"], Literal["__eq__"], Literal["__format__"], Literal["__ge__"], Literal["__getattribute__"], Literal["__getitem__"], Literal["__getnewargs__"], Literal["__gt__"], Literal["__hash__"], Literal["__init__"], Literal["__init_subclass__"], Literal["__iter__"], Literal["__le__"], Literal["__len__"], Literal["__lt__"], Literal["__mod__"], Literal["__module__"], Literal["__mul__"], Literal["__ne__"], Literal["__new__"], Literal["__reduce__"], Literal["__reduce_ex__"], Literal["__repr__"], Literal["__reversed__"], Literal["__rmul__"], Literal["__setattr__"], Literal["__sizeof__"], Literal["__str__"], Literal["__subclasshook__"], Literal["capitalize"], Literal["casefold"], Literal["center"], Literal["count"], Literal["encode"], Literal["endswith"], Literal["expandtabs"], Literal["find"], Literal["format"], Literal["format_map"], Literal["index"], Literal["isalnum"], Literal["isalpha"], Literal["isascii"], Literal["isdecimal"], Literal["isdigit"], Literal["isidentifier"], Literal["islower"], Literal["isnumeric"], Literal["isprintable"], Literal["isspace"], Literal["istitle"], Literal["isupper"], Literal["join"], Literal["ljust"], Literal["lower"], Literal["lstrip"], Literal["maketrans"], Literal["partition"], Literal["removeprefix"], Literal["removesuffix"], Literal["replace"], Literal["rfind"], Literal["rindex"], Literal["rjust"], Literal["rpartition"], Literal["rsplit"], Literal["rstrip"], Literal["split"], Literal["splitlines"], Literal["startswith"], Literal["strip"], Literal["swapcase"], Literal["title"], Literal["translate"], Literal["upper"], Literal["zfill"]]`
| |
``` ```

16
crates/ty_python_semantic/src/types/function.rs
View file

@ -78,7 +78,7 @@ use crate::types::visitor::any_over_type;
use crate::types::{ use crate::types::{
BoundMethodType, CallableType, ClassLiteral, ClassType, DeprecatedInstance, DynamicType, BoundMethodType, CallableType, ClassLiteral, ClassType, DeprecatedInstance, DynamicType,
KnownClass, Truthiness, Type, TypeMapping, TypeRelation, TypeTransformer, TypeVarInstance, KnownClass, Truthiness, Type, TypeMapping, TypeRelation, TypeTransformer, TypeVarInstance,
UnionBuilder, walk_type_mapping, UnionBuilder, all_members, walk_type_mapping,
}; };
use crate::{Db, FxOrderSet, ModuleName, resolve_module}; use crate::{Db, FxOrderSet, ModuleName, resolve_module};
@ -1082,6 +1082,8 @@ pub enum KnownFunction {
EnumMembers, EnumMembers,
/// `ty_extensions.all_members` /// `ty_extensions.all_members`
AllMembers, AllMembers,
/// `ty_extensions.has_member`
HasMember,
/// `ty_extensions.top_materialization` /// `ty_extensions.top_materialization`
TopMaterialization, TopMaterialization,
/// `ty_extensions.bottom_materialization` /// `ty_extensions.bottom_materialization`
@ -1150,6 +1152,7 @@ impl KnownFunction {
| Self::DunderAllNames | Self::DunderAllNames
| Self::EnumMembers | Self::EnumMembers
| Self::StaticAssert | Self::StaticAssert
| Self::HasMember
| Self::AllMembers => module.is_ty_extensions(), | Self::AllMembers => module.is_ty_extensions(),
Self::ImportModule => module.is_importlib(), Self::ImportModule => module.is_importlib(),
} }
@ -1186,6 +1189,16 @@ impl KnownFunction {
} }
} }
KnownFunction::HasMember => {
let [Some(ty), Some(Type::StringLiteral(member))] = parameter_types else {
return;
};
let ty_members = all_members(db, *ty);
overload.set_return_type(Type::BooleanLiteral(
ty_members.iter().any(|m| m.name == member.value(db)),
));
}
KnownFunction::AssertType => { KnownFunction::AssertType => {
let [Some(actual_ty), Some(asserted_ty)] = parameter_types else { let [Some(actual_ty), Some(asserted_ty)] = parameter_types else {
return; return;
@ -1444,6 +1457,7 @@ pub(crate) mod tests {
| KnownFunction::IsEquivalentTo | KnownFunction::IsEquivalentTo
| KnownFunction::TopMaterialization | KnownFunction::TopMaterialization
| KnownFunction::BottomMaterialization | KnownFunction::BottomMaterialization
| KnownFunction::HasMember
| KnownFunction::AllMembers => KnownModule::TyExtensions, | KnownFunction::AllMembers => KnownModule::TyExtensions,
KnownFunction::ImportModule => KnownModule::ImportLib, KnownFunction::ImportModule => KnownModule::ImportLib,

56
crates/ty_python_semantic/src/types/infer.rs
View file

@ -7691,38 +7691,6 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
right: Type<'db>, right: Type<'db>,
range: TextRange, range: TextRange,
) -> Result<Type<'db>, CompareUnsupportedError<'db>> { ) -> Result<Type<'db>, CompareUnsupportedError<'db>> {
let is_str_literal_in_tuple = |literal: Type<'db>, tuple: TupleType<'db>| {
// Protect against doing a lot of work for pathologically large
// tuples.
//
// Ref: https://github.com/astral-sh/ruff/pull/18251#discussion_r2115909311
let (minimum_length, _) = tuple.tuple(self.db()).len().size_hint();
if minimum_length > 1 << 12 {
return None;
}
let mut definitely_true = false;
let mut definitely_false = true;
for element in tuple.tuple(self.db()).all_elements().copied() {
if element.is_string_literal() {
if literal == element {
definitely_true = true;
definitely_false = false;
}
} else if !literal.is_disjoint_from(self.db(), element) {
definitely_false = false;
}
}
if definitely_true {
Some(true)
} else if definitely_false {
Some(false)
} else {
None
}
};
// Note: identity (is, is not) for equal builtin types is unreliable and not part of the // Note: identity (is, is not) for equal builtin types is unreliable and not part of the
// language spec. // language spec.
// - `[ast::CompOp::Is]`: return `false` if unequal, `bool` if equal // - `[ast::CompOp::Is]`: return `false` if unequal, `bool` if equal
@ -7854,30 +7822,6 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
} }
} }
} }
(Type::StringLiteral(_), Type::Tuple(tuple)) if op == ast::CmpOp::In => {
if let Some(answer) = is_str_literal_in_tuple(left, tuple) {
return Ok(Type::BooleanLiteral(answer));
}
self.infer_binary_type_comparison(
KnownClass::Str.to_instance(self.db()),
op,
right,
range,
)
}
(Type::StringLiteral(_), Type::Tuple(tuple)) if op == ast::CmpOp::NotIn => {
if let Some(answer) = is_str_literal_in_tuple(left, tuple) {
return Ok(Type::BooleanLiteral(!answer));
}
self.infer_binary_type_comparison(
KnownClass::Str.to_instance(self.db()),
op,
right,
range,
)
}
(Type::StringLiteral(_), _) => self.infer_binary_type_comparison( (Type::StringLiteral(_), _) => self.infer_binary_type_comparison(
KnownClass::Str.to_instance(self.db()), KnownClass::Str.to_instance(self.db()),
op, op,

3
crates/ty_vendored/ty_extensions/ty_extensions.pyi
View file

@ -61,3 +61,6 @@ def bottom_materialization(type: Any) -> Any: ...
# * `dir` will respect an object's `__dir__` implementation, if present, but # * `dir` will respect an object's `__dir__` implementation, if present, but
# this method (currently) does not. # this method (currently) does not.
def all_members(obj: Any) -> tuple[str, ...]: ... def all_members(obj: Any) -> tuple[str, ...]: ...
# Returns `True` if the given object has a member with the given name.
def has_member(obj: Any, name: str) -> bool: ...