[ty] Infer TypedDict types with >=1 required key as being always truthy (#22808)

Author: AlexWaygood

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

@@ -363,3 +363,44 @@ def f():
     else:
         reveal_type(x)  # revealed: (str & ~AlwaysTruthy) | None
 ```
+
+## Narrowing a union of a `TypedDict` and `None`
+
+```py
+from typing_extensions import TypedDict, NotRequired, Required
+
+class Empty(TypedDict): ...
+
+class NonEmpty(TypedDict):
+    x: int
+
+class HasNotRequired1(TypedDict):
+    x: NotRequired[int]
+
+class HasNotRequired2(TypedDict, total=False):
+    x: int
+
+class AlsoNonEmpty(TypedDict, total=False):
+    x: Required[int]
+
+def f(arg1: Empty | None, arg2: NonEmpty | None, arg3: HasNotRequired1 | None, arg4: HasNotRequired2 | None, arg5: AlsoNonEmpty):
+    if arg1:
+        # the truthiness of `Empty` is ambiguous,
+        # because the `Empty` type includes possible `TypedDict` subtypes
+        # that might have required keys
+        reveal_type(arg1)  # revealed: Empty & ~AlwaysFalsy
+
+    if arg2:
+        # but `NonEmpty` is known to be a subtype of `AlwaysTruthy`
+        # because of the required key, so we can narrow to a simpler type here
+        reveal_type(arg2)  # revealed: NonEmpty
+
+    if arg3:
+        reveal_type(arg3)  # revealed: HasNotRequired1 & ~AlwaysFalsy
+
+    if arg4:
+        reveal_type(arg4)  # revealed: HasNotRequired2 & ~AlwaysFalsy
+
+    if arg5:
+        reveal_type(arg5)  # revealed: AlsoNonEmpty
+```

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

@@ -221,15 +221,14 @@ class Normal(TypedDict):
     b: int
 
 def _(n: Normal) -> None:
-    # Could be `Literal[True]`
-    reveal_type(bool(n))  # revealed: bool
+    reveal_type(bool(n))  # revealed: Literal[True]
 
 class OnlyFalsyItems(TypedDict):
     wrong: Literal[False]
 
 def _(n: OnlyFalsyItems) -> None:
-    # Could be `Literal[True]` (it does not matter if all items are falsy)
-    reveal_type(bool(n))  # revealed: bool
+    # (it does not matter if all items are falsy)
+    reveal_type(bool(n))  # revealed: Literal[True]
 
 class Empty(TypedDict):
     pass

crates/ty_python_semantic/src/types.rs

@@ -71,6 +71,7 @@ use crate::types::newtype::NewType;
 pub(crate) use crate::types::signatures::{Parameter, Parameters};
 use crate::types::signatures::{ParameterForm, walk_signature};
 use crate::types::tuple::{Tuple, TupleSpec, TupleSpecBuilder};
+use crate::types::typed_dict::TypedDictField;
 pub(crate) use crate::types::typed_dict::{TypedDictParams, TypedDictType, walk_typed_dict_type};
 pub use crate::types::variance::TypeVarVariance;
 use crate::types::variance::VarianceInferable;
@@ -3658,10 +3659,14 @@ impl<'db> Type<'db> {
             | Type::TypeIs(_)
             | Type::TypeGuard(_) => Truthiness::Ambiguous,
 
-            Type::TypedDict(_) => {
-                // TODO: We could do better here, but it's unclear if this is important.
-                // See existing `TypedDict`-related tests in `truthiness.md`
-                Truthiness::Ambiguous
+            Type::TypedDict(td) => {
+                if td.items(db).values().any(TypedDictField::is_required) {
+                    Truthiness::AlwaysTrue
+                } else {
+                    // We can potentially infer empty typeddicts as always falsy if they're `closed=True`,
+                    // but as of 22-01-26 we don't yet support PEP 728.
+                    Truthiness::Ambiguous
+                }
             }
 
             Type::KnownInstance(KnownInstanceType::ConstraintSet(tracked_set)) => {