option for no callable

dcreager · dcreager · commit 08145db00d96 · 2025-11-24T12:46:00.000-05:00
diff --git a/crates/ty_python_semantic/src/semantic_index/reachability_constraints.rs b/crates/ty_python_semantic/src/semantic_index/reachability_constraints.rs
@@ -871,12 +871,14 @@ impl ReachabilityConstraints {
                     return Truthiness::AlwaysFalse.negate_if(!predicate.is_positive);
                 }
 
-                let overloads_iterator =
-                    if let Some(callable) = ty.try_upcast_to_callable(db).exactly_one() {
-                        callable.signatures(db).overloads.iter()
-                    } else {
-                        return Truthiness::AlwaysFalse.negate_if(!predicate.is_positive);
-                    };
+                let overloads_iterator = if let Some(callable) = ty
+                    .try_upcast_to_callable(db)
+                    .and_then(|callables| callables.exactly_one())
+                {
+                    callable.signatures(db).overloads.iter()
+                } else {
+                    return Truthiness::AlwaysFalse.negate_if(!predicate.is_positive);
+                };
 
                 let (no_overloads_return_never, all_overloads_return_never) = overloads_iterator
                     .fold((true, true), |(none, all), overload| {
diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs
@@ -1525,20 +1525,20 @@ impl<'db> Type<'db> {
         }
     }
 
-    pub(crate) fn try_upcast_to_callable(self, db: &'db dyn Db) -> CallableTypes<'db> {
+    pub(crate) fn try_upcast_to_callable(self, db: &'db dyn Db) -> Option<CallableTypes<'db>> {
         match self {
-            Type::Callable(callable) => CallableTypes::one(callable),
+            Type::Callable(callable) => Some(CallableTypes::one(callable)),
 
-            Type::Dynamic(_) => CallableTypes::one(CallableType::function_like_callable(
+            Type::Dynamic(_) => Some(CallableTypes::one(CallableType::function_like_callable(
                 db,
                 Signature::dynamic(self),
-            )),
+            ))),
 
             Type::FunctionLiteral(function_literal) => {
-                CallableTypes::one(function_literal.into_callable_type(db))
+                Some(CallableTypes::one(function_literal.into_callable_type(db)))
             }
             Type::BoundMethod(bound_method) => {
-                CallableTypes::one(bound_method.into_callable_type(db))
+                Some(CallableTypes::one(bound_method.into_callable_type(db)))
             }
 
             Type::NominalInstance(_) | Type::ProtocolInstance(_) => {
@@ -1553,7 +1553,7 @@ impl<'db> Type<'db> {
                 if let Place::Defined(ty, _, Definedness::AlwaysDefined) = call_symbol {
                     ty.try_upcast_to_callable(db)
                 } else {
-                    CallableTypes::none()
+                    None
                 }
             }
             Type::ClassLiteral(class_literal) => {
@@ -1570,23 +1570,20 @@ impl<'db> Type<'db> {
             Type::SubclassOf(subclass_of_ty) => match subclass_of_ty.subclass_of() {
                 SubclassOfInner::Class(class) => class.into_callable(db),
                 SubclassOfInner::Dynamic(dynamic) => {
-                    CallableTypes::one(CallableType::single_callable(
+                    Some(CallableTypes::one(CallableType::single_callable(
                         db,
                         Signature::new(Parameters::unknown(), Some(Type::Dynamic(dynamic))),
-                    ))
+                    )))
                 }
             },
 
             Type::Union(union) => {
                 let mut callables = SmallVec::new();
                 for element in union.elements(db) {
-                    let element_callable = element.try_upcast_to_callable(db);
-                    if element_callable.is_empty() {
-                        return CallableTypes::none();
-                    }
+                    let element_callable = element.try_upcast_to_callable(db)?;
                     callables.extend(element_callable.into_inner());
                 }
-                CallableTypes(callables)
+                Some(CallableTypes(callables))
             }
 
             Type::EnumLiteral(enum_literal) => enum_literal
@@ -1595,27 +1592,29 @@ impl<'db> Type<'db> {
 
             Type::TypeAlias(alias) => alias.value_type(db).try_upcast_to_callable(db),
 
-            Type::KnownBoundMethod(method) => CallableTypes::one(CallableType::new(
+            Type::KnownBoundMethod(method) => Some(CallableTypes::one(CallableType::new(
                 db,
                 CallableSignature::from_overloads(method.signatures(db)),
                 false,
-            )),
+            ))),
 
-            Type::WrapperDescriptor(wrapper_descriptor) => CallableTypes::one(CallableType::new(
-                db,
-                CallableSignature::from_overloads(wrapper_descriptor.signatures(db)),
-                false,
-            )),
+            Type::WrapperDescriptor(wrapper_descriptor) => {
+                Some(CallableTypes::one(CallableType::new(
+                    db,
+                    CallableSignature::from_overloads(wrapper_descriptor.signatures(db)),
+                    false,
+                )))
+            }
 
             Type::KnownInstance(KnownInstanceType::NewType(newtype)) => {
-                CallableTypes::one(CallableType::single_callable(
+                Some(CallableTypes::one(CallableType::single_callable(
                     db,
                     Signature::new(
                         Parameters::new([Parameter::positional_only(None)
                             .with_annotated_type(newtype.base(db).instance_type(db))]),
                         Some(Type::NewTypeInstance(newtype)),
                     ),
-                ))
+                )))
             }
 
             Type::Never
@@ -1628,7 +1627,7 @@ impl<'db> Type<'db> {
             | Type::LiteralString
             | Type::BytesLiteral(_)
             | Type::TypeIs(_)
-            | Type::TypedDict(_) => CallableTypes::none(),
+            | Type::TypedDict(_) => None,
 
             // TODO
             Type::DataclassDecorator(_)
@@ -1638,7 +1637,7 @@ impl<'db> Type<'db> {
             | Type::PropertyInstance(_)
             | Type::Intersection(_)
             | Type::TypeVar(_)
-            | Type::BoundSuper(_) => CallableTypes::none(),
+            | Type::BoundSuper(_) => None,
         }
     }
 
@@ -2194,14 +2193,16 @@ impl<'db> Type<'db> {
 
             (_, Type::Callable(other_callable)) => {
                 relation_visitor.visit((self, target, relation), || {
-                    self.try_upcast_to_callable(db).has_relation_to_impl(
-                        db,
-                        other_callable,
-                        inferable,
-                        relation,
-                        relation_visitor,
-                        disjointness_visitor,
-                    )
+                    self.try_upcast_to_callable(db).when_some_and(|callables| {
+                        callables.has_relation_to_impl(
+                            db,
+                            other_callable,
+                            inferable,
+                            relation,
+                            relation_visitor,
+                            disjointness_visitor,
+                        )
+                    })
                 })
             }
 
@@ -11110,20 +11111,21 @@ impl<'db> CallableType<'db> {
 /// when coercing that result to a single type, you'll get a `UnionType`. But this lets you handle
 /// that result as a list of `CallableType`s before merging them into a `UnionType` should that be
 /// helpful.
+///
+/// Note that this type is guaranteed to contain at least one callable. If you need to support "no
+/// callables" as a possibility, use `Option<CallableTypes>`.
 #[derive(Clone, Debug, Eq, PartialEq, get_size2::GetSize, salsa::Update)]
 pub(crate) struct CallableTypes<'db>(SmallVec<[CallableType<'db>; 1]>);
 
 impl<'db> CallableTypes<'db> {
-    pub(crate) fn none() -> Self {
-        CallableTypes(smallvec![])
-    }
-
     pub(crate) fn one(callable: CallableType<'db>) -> Self {
         CallableTypes(smallvec![callable])
     }
 
     pub(crate) fn from_elements(callables: impl IntoIterator<Item = CallableType<'db>>) -> Self {
-        CallableTypes(callables.into_iter().collect())
+        let callables: SmallVec<_> = callables.into_iter().collect();
+        assert!(!callables.is_empty(), "CallableTypes should not be empty");
+        CallableTypes(callables)
     }
 
     pub(crate) fn exactly_one(self) -> Option<CallableType<'db>> {
@@ -11133,22 +11135,15 @@ impl<'db> CallableTypes<'db> {
         }
     }
 
-    fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
     fn into_inner(self) -> SmallVec<[CallableType<'db>; 1]> {
         self.0
     }
 
-    pub(crate) fn into_type(self, db: &'db dyn Db) -> Option<Type<'db>> {
+    pub(crate) fn into_type(self, db: &'db dyn Db) -> Type<'db> {
         match self.0.as_slice() {
-            [] => None,
-            [single] => Some(Type::Callable(*single)),
-            slice => Some(UnionType::from_elements(
-                db,
-                slice.iter().copied().map(Type::Callable),
-            )),
+            [] => unreachable!("CallableTypes should not be empty"),
+            [single] => Type::Callable(*single),
+            slice => UnionType::from_elements(db, slice.iter().copied().map(Type::Callable)),
         }
     }
 
@@ -11165,9 +11160,6 @@ impl<'db> CallableTypes<'db> {
         relation_visitor: &HasRelationToVisitor<'db>,
         disjointness_visitor: &IsDisjointVisitor<'db>,
     ) -> ConstraintSet<'db> {
-        if self.is_empty() {
-            return ConstraintSet::from(false);
-        }
         self.0.iter().when_all(db, |element| {
             element.has_relation_to_impl(
                 db,
diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs
@@ -1051,7 +1051,7 @@ impl<'db> ClassType<'db> {
     /// Return a callable type (or union of callable types) that represents the callable
     /// constructor signature of this class.
     #[salsa::tracked(cycle_initial=into_callable_cycle_initial, heap_size=ruff_memory_usage::heap_size)]
-    pub(super) fn into_callable(self, db: &'db dyn Db) -> CallableTypes<'db> {
+    pub(super) fn into_callable(self, db: &'db dyn Db) -> Option<CallableTypes<'db>> {
         let self_ty = Type::from(self);
         let metaclass_dunder_call_function_symbol = self_ty
             .member_lookup_with_policy(
@@ -1069,7 +1069,9 @@ impl<'db> ClassType<'db> {
             // https://typing.python.org/en/latest/spec/constructors.html#converting-a-constructor-to-callable
             // by always respecting the signature of the metaclass `__call__`, rather than
             // using a heuristic which makes unwarranted assumptions to sometimes ignore it.
-            return CallableTypes::one(metaclass_dunder_call_function.into_callable_type(db));
+            return Some(CallableTypes::one(
+                metaclass_dunder_call_function.into_callable_type(db),
+            ));
         }
 
         let dunder_new_function_symbol = self_ty.lookup_dunder_new(db);
@@ -1104,7 +1106,7 @@ impl<'db> ClassType<'db> {
             );
 
             if returns_non_subclass {
-                return CallableTypes::one(dunder_new_bound_method);
+                return Some(CallableTypes::one(dunder_new_bound_method));
             }
             Some(dunder_new_bound_method)
         } else {
@@ -1161,13 +1163,13 @@ impl<'db> ClassType<'db> {
 
         match (dunder_new_function, synthesized_dunder_init_callable) {
             (Some(dunder_new_function), Some(synthesized_dunder_init_callable)) => {
-                CallableTypes::from_elements([
+                Some(CallableTypes::from_elements([
                     dunder_new_function,
                     synthesized_dunder_init_callable,
-                ])
+                ]))
             }
             (Some(constructor), None) | (None, Some(constructor)) => {
-                CallableTypes::one(constructor)
+                Some(CallableTypes::one(constructor))
             }
             (None, None) => {
                 // If no `__new__` or `__init__` method is found, then we fall back to looking for
@@ -1183,17 +1185,17 @@ impl<'db> ClassType<'db> {
                 if let Place::Defined(Type::FunctionLiteral(new_function), _, _) =
                     new_function_symbol
                 {
-                    CallableTypes::one(
+                    Some(CallableTypes::one(
                         new_function
                             .into_bound_method_type(db, correct_return_type)
                             .into_callable_type(db),
-                    )
+                    ))
                 } else {
                     // Fallback if no `object.__new__` is found.
-                    CallableTypes::one(CallableType::single_callable(
+                    Some(CallableTypes::one(CallableType::single_callable(
                         db,
                         Signature::new(Parameters::empty(), Some(correct_return_type)),
-                    ))
+                    )))
                 }
             }
         }
@@ -1212,8 +1214,8 @@ fn into_callable_cycle_initial<'db>(
     _db: &'db dyn Db,
     _id: salsa::Id,
     _self: ClassType<'db>,
-) -> CallableTypes<'db> {
-    CallableTypes::none()
+) -> Option<CallableTypes<'db>> {
+    None
 }
 
 impl<'db> From<GenericAlias<'db>> for ClassType<'db> {
diff --git a/crates/ty_python_semantic/src/types/ide_support.rs b/crates/ty_python_semantic/src/types/ide_support.rs
@@ -876,7 +876,10 @@ pub fn definitions_for_keyword_argument<'db>(
 
     let mut resolved_definitions = Vec::new();
 
-    if let Some(callable_type) = func_type.try_upcast_to_callable(db).exactly_one() {
+    if let Some(callable_type) = func_type
+        .try_upcast_to_callable(db)
+        .and_then(|callables| callables.exactly_one())
+    {
         let signatures = callable_type.signatures(db);
 
         // For each signature, find the parameter with the matching name
@@ -987,7 +990,10 @@ pub fn call_signature_details<'db>(
     let func_type = call_expr.func.inferred_type(model);
 
     // Use into_callable to handle all the complex type conversions
-    if let Some(callable_type) = func_type.try_upcast_to_callable(db).into_type(db) {
+    if let Some(callable_type) = func_type
+        .try_upcast_to_callable(db)
+        .map(|callables| callables.into_type(db))
+    {
         let call_arguments =
             CallArguments::from_arguments(&call_expr.arguments, |_, splatted_value| {
                 splatted_value.inferred_type(model)
@@ -1042,7 +1048,7 @@ pub fn call_type_simplified_by_overloads<'db>(
     let func_type = call_expr.func.inferred_type(model);
 
     // Use into_callable to handle all the complex type conversions
-    let callable_type = func_type.try_upcast_to_callable(db).into_type(db)?;
+    let callable_type = func_type.try_upcast_to_callable(db)?.into_type(db);
     let bindings = callable_type.bindings(db);
 
     // If the callable is trivial this analysis is useless, bail out
diff --git a/crates/ty_python_semantic/src/types/infer/builder.rs b/crates/ty_python_semantic/src/types/infer/builder.rs
@@ -2287,7 +2287,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
 
                     let is_input_function_like = inferred_ty
                         .try_upcast_to_callable(self.db())
-                        .exactly_one()
+                        .and_then(|callables| callables.exactly_one())
                         .is_some_and(|callable| callable.is_function_like(self.db()));
 
                     if is_input_function_like
diff --git a/crates/ty_python_semantic/src/types/infer/builder/type_expression.rs b/crates/ty_python_semantic/src/types/infer/builder/type_expression.rs
@@ -1229,7 +1229,7 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
 
                 let Some(callable_type) = argument_type
                     .try_upcast_to_callable(db)
-                    .into_type(self.db())
+                    .map(|callables| callables.into_type(self.db()))
                 else {
                     if let Some(builder) = self
                         .context
diff --git a/crates/ty_python_semantic/src/types/protocol_class.rs b/crates/ty_python_semantic/src/types/protocol_class.rs
@@ -707,15 +707,18 @@ impl<'a, 'db> ProtocolMember<'a, 'db> {
                 let fallback_other = other.literal_fallback_instance(db).unwrap_or(other);
                 attribute_type
                     .try_upcast_to_callable(db)
-                    .map(|callable| callable.apply_self(db, fallback_other))
-                    .has_relation_to_impl(
-                        db,
-                        method.bind_self(db, Some(fallback_other)),
-                        inferable,
-                        relation,
-                        relation_visitor,
-                        disjointness_visitor,
-                    )
+                    .when_some_and(|callables| {
+                        callables
+                            .map(|callable| callable.apply_self(db, fallback_other))
+                            .has_relation_to_impl(
+                                db,
+                                method.bind_self(db, Some(fallback_other)),
+                                inferable,
+                                relation,
+                                relation_visitor,
+                                disjointness_visitor,
+                            )
+                    })
             }
             // TODO: consider the types of the attribute on `other` for property members
             ProtocolMemberKind::Property(_) => ConstraintSet::from(matches!(
