Keep narrows to classes extending Any in narrow joins

crates/pyrefly_types/src/type_info.rs

@@ -982,7 +982,19 @@ fn join_types_impl(
             base_ty
         } else {
             let joined_ty = union_types(types);
-            if is_subset_eq(&base_ty, &joined_ty) {
+            // If `base_ty` is a subset of a single member of the join, that member is at least
+            // as precise, so keep the join. This matters when the subset check is vacuous:
+            // `type[object]` is assignable to `type[C]` if `C` extends `Any`. It doesn't hold
+            // for types containing `Any`, which every type is a subset of.
+            let within_one_member = || {
+                !base_ty.any(Type::is_any)
+                    && !joined_ty.any(Type::is_any)
+                    && match &joined_ty {
+                        Type::Union(u) => u.members.iter().any(|ty| is_subset_eq(&base_ty, ty)),
+                        _ => true,
+                    }
+            };
+            if is_subset_eq(&base_ty, &joined_ty) && !within_one_member() {
                 base_ty
             } else {
                 joined_ty

pyrefly/lib/test/narrow.rs

@@ -5272,6 +5272,77 @@ def preserve_facets_and_subtypes(x: A, flag: bool) -> None:
     "#,
 );
 
+// https://github.com/facebook/pyrefly/issues/5546
+testcase!(
+    test_narrow_or_to_class_extending_any,
+    r#"
+from typing import Any, TypeGuard, reveal_type
+
+class C(Any):
+    pass
+
+def has(cls: type) -> TypeGuard[type[C]]:
+    return hasattr(cls, "tag")
+
+def has2(cls: type) -> TypeGuard[type[C]]:
+    return hasattr(cls, "tag")
+
+def is_c(x: object) -> TypeGuard[C]:
+    return True
+
+def repeated_guard(t: type[object]) -> None:
+    if has(t) or has(t):
+        reveal_type(t)  # E: revealed type: type[C]
+        t.tag
+
+def different_guards(t: type[object]) -> None:
+    if has(t) or has2(t):
+        reveal_type(t)  # E: revealed type: type[C]
+
+def instance_guard(x: object) -> None:
+    if is_c(x) or is_c(x):
+        reveal_type(x)  # E: revealed type: C
+
+def one_branch_does_not_narrow(t: type[object]) -> None:
+    if has(t) or isinstance(t, type):
+        reveal_type(t)  # E: revealed type: type[object]
+
+def gradual_base(x) -> None:
+    if isinstance(x, int) or isinstance(x, str):
+        reveal_type(x)  # E: revealed type: int | str
+
+class Holder:
+    t: type[object]
+
+def attribute(o: Holder) -> None:
+    if has(o.t) or has(o.t):
+        reveal_type(o.t)  # E: revealed type: type[C]
+
+def control_flow_merge(t: type[object], flag: bool) -> None:
+    if flag:
+        if not has(t):
+            return
+    else:
+        if not has2(t):
+            return
+    reveal_type(t)  # E: revealed type: type[C]
+
+def covering_branches(x: bool) -> None:
+    # The branches are `Literal[True]` and `Literal[False]`, which together cover `bool`.
+    if x or not x:
+        reveal_type(x)  # E: revealed type: bool
+
+blocked: list[str] = []
+
+def takes_int(x: int) -> None: ...
+
+def base_contains_any(x: int | Any | None) -> None:
+    if x is None or x in blocked:
+        return
+    takes_int(x)
+    "#,
+);
+
 // https://github.com/facebook/pyrefly/issues/5147
 testcase!(
     test_isinstance_union_with_typevar_classinfo,