[ty] infer function's return type

crates/ruff_benchmark/benches/ty_walltime.rs

@@ -164,7 +164,7 @@ static PANDAS: std::sync::LazyLock<Benchmark<'static>> = std::sync::LazyLock::ne
             max_dep_date: "2025-06-17",
             python_version: PythonVersion::PY312,
         },
-        3000,
+        3300,
     )
 });
 
@@ -199,7 +199,8 @@ static SYMPY: std::sync::LazyLock<Benchmark<'static>> = std::sync::LazyLock::new
             max_dep_date: "2025-06-17",
             python_version: PythonVersion::PY312,
         },
-        13000,
+        // TODO: With better decorator support, `__slots__` support, etc., it should be possible to reduce the number of errors considerably.
+        70000,
     )
 });
 

crates/ty_python_semantic/resources/corpus/cycle_into_callable.py

@@ -0,0 +1,17 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/17371
+# panicked in commit d1088545a08aeb57b67ec1e3a7f5141159efefa5
+# error message:
+# dependency graph cycle when querying ClassType < 'db >::into_callable_(Id(1c00))
+
+try:
+    class foo[T: bar](object):
+        pass
+    bar = foo
+except Exception:
+    bar = lambda: 0
+def bar():
+    pass
+
+@bar()
+class bar:
+    pass

crates/ty_python_semantic/resources/corpus/divergent.py

@@ -0,0 +1,72 @@
+def f(cond: bool):
+    if cond:
+        result = ()
+        result += (f(cond),)
+        return result
+
+    return None
+
+reveal_type(f(True))
+
+def f(cond: bool):
+    if cond:
+        result = ()
+        result += (f(cond),)
+        return result
+
+    return None
+
+def f(cond: bool):
+    result = None
+    if cond:
+        result = ()
+        result += (f(cond),)
+
+    return result
+
+reveal_type(f(True))
+
+def f(cond: bool):
+    result = None
+    if cond:
+        result = [f(cond) for _ in range(1)]
+
+    return result
+
+reveal_type(f(True))
+
+class Foo:
+    def value(self):
+        return 1
+
+def unwrap(value):
+    if isinstance(value, Foo):
+        foo = value
+        return foo.value()
+    elif type(value) is tuple:
+        length = len(value)
+        if length == 0:
+            return ()
+        elif length == 1:
+            return (unwrap(value[0]),)
+        else:
+            result = []
+            for item in value:
+                result.append(unwrap(item))
+            return tuple(result)
+    else:
+        raise TypeError()
+
+def descent(x: int, y: int):
+    if x > y:
+        y, x = descent(y, x)
+        return x, y
+    if x == 1:
+        return (1, 0)
+    if y == 1:
+        return (0, 1)
+    else:
+        return descent(x-1, y-1)
+
+def count_set_bits(n):
+    return 1 + count_set_bits(n & n - 1) if n else 0

crates/ty_python_semantic/resources/mdtest/annotations/invalid.md

@@ -79,7 +79,9 @@ def outer_sync():  # `yield` from is only valid syntax inside a synchronous func
         a: (yield from [1]),  # error: [invalid-type-form] "`yield from` expressions are not allowed in type expressions"
     ): ...
 
-async def baz(): ...
+async def baz():
+    yield
+
 async def outer_async():  # avoid unrelated syntax errors on `yield` and `await`
     def _(
         a: 1,  # error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"

crates/ty_python_semantic/resources/mdtest/call/union.md

@@ -111,7 +111,7 @@ def _(flag: bool):
 
     # error: [call-non-callable] "Object of type `Literal["This is a string literal"]` is not callable"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: None | Unknown
 ```
 
 ## Union of binding errors
@@ -128,7 +128,7 @@ def _(flag: bool):
     # error: [too-many-positional-arguments] "Too many positional arguments to function `f1`: expected 0, got 1"
     # error: [too-many-positional-arguments] "Too many positional arguments to function `f2`: expected 0, got 1"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: None
 ```
 
 ## One not-callable, one wrong argument
@@ -146,7 +146,7 @@ def _(flag: bool):
     # error: [too-many-positional-arguments] "Too many positional arguments to function `f1`: expected 0, got 1"
     # error: [call-non-callable] "Object of type `C` is not callable"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: None | Unknown
 ```
 
 ## Union including a special-cased function

crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md

@@ -125,7 +125,8 @@ match obj:
 
 ```py
 class C:
-    def __await__(self): ...
+    def __await__(self):
+        yield
 
 # error: [invalid-syntax] "`return` statement outside of a function"
 return