Simplify HasBindings by removing Maybe.

It literally only applies to functions, as a general category of thing. Or at least, we can divide it on types in the IR, instead of writing it down here.

Removing it is a strict simplification, see delta, and makes future changes a bit easier potentially. It also changes "this only applies to functions" from a thing that happens to be true but isn't easy to see by reading the codebase, to something that is explicitly noted with a `!matches!(item, Item::Func)`.

PiperOrigin-RevId: 747938928
Change-Id: I6c09aeec61e0662bf852a292c3c7db33910df51a

Author: ssbr

rs_bindings_from_cc/generate_bindings/has_bindings.rs

@@ -10,16 +10,9 @@ use std::rc::Rc;
 
 #[derive(Clone, PartialEq, Eq)]
 pub enum HasBindings {
-    /// This item is guaranteed to have bindings. If the translation unit
-    /// defining the item fails to generate bindings for it, it will not
-    /// compile.
+    /// This item will have bindings. This is *guaranteed*, if the item isn't a `Func`.
     Yes,
 
-    /// This item is not guaranteed to have bindings. There is no way to tell if
-    /// bindings were generated unless the item is defined in the current
-    /// translation unit.
-    Maybe,
-
     /// These bindings are guaranteed not to exist.
     No(NoBindingsReason),
 }
@@ -71,13 +64,6 @@ pub fn has_bindings(db: &dyn BindingsGenerator, item: &Item) -> HasBindings {
                     error: no_parent_bindings.into(),
                 });
             }
-            HasBindings::Maybe => {
-                // This shouldn't happen, Maybe is meant for Func items.
-                return HasBindings::No(NoBindingsReason::DependencyFailed {
-                    context: item.debug_name(&ir),
-                    error: anyhow!("parent item might not be defined"),
-                });
-            }
             HasBindings::Yes => {}
         }
 
@@ -95,9 +81,6 @@ pub fn has_bindings(db: &dyn BindingsGenerator, item: &Item) -> HasBindings {
     }
 
     match item {
-        // Function bindings aren't guaranteed, because they don't _need_ to be guaranteed. We
-        // choose not to generate code which relies on functions existing in other TUs.
-        Item::Func(..) => HasBindings::Maybe,
         Item::TypeAlias(alias) => match db.rs_type_kind(alias.underlying_type.clone()) {
             Ok(_) => HasBindings::Yes,
             Err(error) => HasBindings::No(NoBindingsReason::DependencyFailed {

rs_bindings_from_cc/generate_bindings/lib.rs

@@ -231,7 +231,7 @@ fn generate_item(db: &dyn BindingsGenerator, item: Item) -> Result<ApiSnippets>
             UnsupportedItem::new_with_cause(db.ir(), &enum_, Some(unsupported_item_path), err)
         }
         _ => {
-            if has_bindings(db, &item) == HasBindings::Yes {
+            if has_bindings(db, &item) == HasBindings::Yes && !matches!(item, Item::Func(_)) {
                 return Err(err);
             }
             // FIXME(cramertj): get paths here in more cases. It may be that

rs_bindings_from_cc/generate_bindings/rs_type_kind.rs

@@ -103,12 +103,6 @@ pub fn rs_type_kind(db: &dyn BindingsGenerator, ty: CcType) -> Result<RsTypeKind
                 {
                     return db.rs_type_kind(fallback_type.clone());
                 }
-                (HasBindings::Maybe, _) => {
-                    bail!(
-                        "Type {} may or may not exist, and cannot be used.",
-                        item.debug_name(&ir)
-                    );
-                }
                 (HasBindings::No(reason), _) => {
                     return Err(reason.into());
                 }