Address failing tests

Author: InSyncWithFoo

crates/ty_python_semantic/resources/mdtest/narrow/type_guards.md

@@ -14,13 +14,17 @@ def _(
     b: TypeIs[str | int],
     c: TypeGuard[Intersection[complex, Not[int], Not[float]]],
     d: TypeIs[tuple[TypeOf[bytes]]],
+    e: TypeGuard,  # error: [invalid-type-form]
+    f: TypeIs,  # error: [invalid-type-form]
 ):
     # TODO: Should be `TypeGuard[str]`
     reveal_type(a)  # revealed: @Todo(`TypeGuard[]` special form)
     reveal_type(b)  # revealed: TypeIs[str | int]
     # TODO: Should be `TypeGuard[complex & ~int & ~float]`
     reveal_type(c)  # revealed: @Todo(`TypeGuard[]` special form)
     reveal_type(d)  # revealed: TypeIs[tuple[<class 'bytes'>]]
+    reveal_type(e)  # revealed: Unknown
+    reveal_type(f)  # revealed: Unknown
 
 # TODO: error: [invalid-return-type] "Function can implicitly return `None`, which is not assignable to return type `TypeGuard[str]`"
 def _(a) -> TypeGuard[str]: ...
@@ -137,12 +141,12 @@ def g(a: Literal["foo", "bar"]) -> TypeIs[Literal["foo"]]:
 
 ## Invalid calls
 
-```pyi
+```py
 from typing import Any
 from typing_extensions import TypeGuard, TypeIs
 
-def f(a: object) -> TypeGuard[str]: ...
-def g(a: object) -> TypeIs[int]: ...
+def f(a: object) -> TypeGuard[str]: return True
+def g(a: object) -> TypeIs[int]: return True
 def _(d: Any):
     if f():  # error: [missing-argument]
         ...
@@ -158,7 +162,7 @@ def _(d: Any):
         ...
 
 def _(a: tuple[str, int] | tuple[int, str]):
-    if g(a[0]):  # error: [invalid-type-guard-call]
+    if g(a[0]):
         # TODO: Should be `tuple[str, int]`
         reveal_type(a)  # revealed: tuple[str, int] | tuple[int, str]
 ```
@@ -219,10 +223,10 @@ def _(x: str | int, flag: bool) -> None:
 
 ```py
 from typing import Any
-from typing_extensions import TypeGuard
+from typing_extensions import TypeGuard, TypeIs
 
 def guard_int(a: object) -> TypeGuard[int]: return True
-def is_int(a: object) -> TypeGuard[int]: return True
+def is_int(a: object) -> TypeIs[int]: return True
 def does_not_narrow_in_negative_case(a: str | int):
     if not guard_int(a):
         # TODO: Should be `str`

crates/ty_python_semantic/resources/mdtest/type_properties/is_disjoint_from.md

@@ -402,6 +402,17 @@ static_assert(is_disjoint_from(TypeOf[C.prop], D))
 static_assert(is_disjoint_from(D, TypeOf[C.prop]))
 ```
 
+### `TypeGuard` and `TypeIs`
+
+```py
+from ty_extensions import static_assert, is_disjoint_from
+from typing_extensions import TypeIs
+
+# TODO: TypeGuard
+# static_assert(not is_disjoint_from(bool, TypeGuard[str]))
+static_assert(not is_disjoint_from(bool, TypeIs[str]))
+```
+
 ## Callables
 
 No two callable types are disjoint because there exists a non-empty callable type

crates/ty_python_semantic/resources/mdtest/type_properties/is_subtype_of.md

@@ -358,11 +358,13 @@ from typing_extensions import TypeGuard, TypeIs
 `TypeIs` is invariant. `TypeGuard` is covariant.
 
 ```py
-from ty_extensions import is_subtype_of, static_assert
+from ty_extensions import is_equivalent_to, is_subtype_of, static_assert
 from typing_extensions import TypeGuard, TypeIs
 
 # TODO: TypeGuard
+# static_assert(is_subtype_of(TypeGuard[int], TypeGuard[int]))
 # static_assert(is_subtype_of(TypeGuard[bool], TypeGuard[int]))
+static_assert(is_subtype_of(TypeIs[int], TypeIs[int]))
 
 static_assert(not is_subtype_of(TypeGuard[int], TypeGuard[bool]))
 static_assert(not is_subtype_of(TypeIs[bool], TypeIs[int]))

crates/ty_python_semantic/src/types/infer.rs

@@ -118,7 +118,8 @@ use super::string_annotation::{
 };
 use super::subclass_of::SubclassOfInner;
 use super::{
-    BoundSuperError, BoundSuperType, ClassBase, TypeIsType, add_inferred_python_version_hint_to_diagnostic,
+    BoundSuperError, BoundSuperType, ClassBase, TypeIsType,
+    add_inferred_python_version_hint_to_diagnostic,
 };
 
 /// Infer all types for a [`ScopeId`], including all definitions and expressions in that scope.
@@ -5532,9 +5533,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         Some((symbol, name.to_string()))
                     }
                     // TODO: Attribute and subscript narrowing
-                    Some(expr) => {
-                        None
-                    }
+                    Some(_) => None,
                 };
 
                 // TODO: Handle unions/intersections

crates/ty_python_semantic/src/types/narrow.rs

@@ -742,23 +742,28 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
                 let return_ty =
                     inference.expression_type(expr_call.scoped_expression_id(self.db, scope));
 
+                if let Some(name) = expr_call.func.as_name_expr() {
+                    dbg!(&name.id);
+                    dbg!(return_ty);
+                }
+
                 // TODO: Handle unions and intersections
                 let (guarded_ty, symbol) = match return_ty {
                     // TODO: TypeGuard
                     Type::TypeIs(type_is) => {
                         let (_, symbol, _) = type_is.symbol_info(self.db)?;
+                        if let Some(name) = expr_call.func.as_name_expr() {
+                            dbg!(symbol, name);
+                        }
                         (type_is.ty(self.db), symbol)
                     }
                     _ => return None,
                 };
 
-                let mut constraints = NarrowingConstraints::default();
-
-                if is_positive {
-                    constraints.insert(symbol, guarded_ty.negate_if(self.db, !is_positive));
-                }
-
-                Some(constraints)
+                Some(NarrowingConstraints::from_iter([(
+                    symbol,
+                    guarded_ty.negate_if(self.db, !is_positive),
+                )]))
             }
             Type::FunctionLiteral(function_type) if expr_call.arguments.keywords.is_empty() => {
                 let [first_arg, second_arg] = &*expr_call.arguments.args else {

crates/ty_python_semantic/src/types/type_ordering.rs

@@ -3,8 +3,8 @@ use std::cmp::Ordering;
 use crate::db::Db;
 
 use super::{
-    DynamicType, SuperOwnerKind, TodoType, Type, TypeIsType,
-    class_base::ClassBase, subclass_of::SubclassOfInner,
+    DynamicType, SuperOwnerKind, TodoType, Type, TypeIsType, class_base::ClassBase,
+    subclass_of::SubclassOfInner,
 };
 
 /// Return an [`Ordering`] that describes the canonical order in which two types should appear