chore: Remove CallableMetadata

LukeMathWalker · LukeMathWalker · commit 8ea72235fa96 · 2026-03-10T13:40:07.000+01:00
diff --git a/compiler/pavexc/src/compiler/analyses/application_state/mod.rs b/compiler/pavexc/src/compiler/analyses/application_state/mod.rs
@@ -20,8 +20,8 @@ use super::{
 use crate::{
     compiler::app::GENERATED_APP_PACKAGE_ID,
     language::{
-        Callable, CallableInput, CallableMetadata, GenericArgument, PathTypeExt, RustIdentifier,
-        StructLiteralInit, Type,
+        Callable, CallableInput, GenericArgument, PathTypeExt, RustIdentifier, StructLiteralInit,
+        Type,
     },
     rustdoc::CrateCollection,
 };
@@ -188,20 +188,18 @@ impl ApplicationState {
 
         Callable::StructLiteralInit(StructLiteralInit {
             path: ty_.callable_struct_literal_path(),
-            metadata: CallableMetadata {
-                output: Some(ty_.into()),
-                inputs: {
-                    // Ensure that the inputs are sorted by name.
-                    let b = self.bindings.iter().collect::<BTreeMap<_, _>>();
-                    b.into_iter()
-                        .map(|(name, type_)| CallableInput {
-                            name: RustIdentifier::new(name.to_string()),
-                            type_: type_.clone(),
-                        })
-                        .collect()
-                },
-                source_coordinates: None,
+            self_: Some(ty_.into()),
+            fields: {
+                // Ensure that the inputs are sorted by name.
+                let b = self.bindings.iter().collect::<BTreeMap<_, _>>();
+                b.into_iter()
+                    .map(|(name, type_)| CallableInput {
+                        name: RustIdentifier::new(name.to_string()),
+                        type_: type_.clone(),
+                    })
+                    .collect()
             },
+            source_coordinates: None,
             extra_field2default_value: Default::default(),
         })
     }
diff --git a/compiler/pavexc/src/compiler/analyses/call_graph/application_state.rs b/compiler/pavexc/src/compiler/analyses/call_graph/application_state.rs
@@ -23,8 +23,8 @@ use crate::compiler::analyses::framework_items::FrameworkItemDb;
 use crate::compiler::app::GENERATED_APP_PACKAGE_ID;
 use crate::compiler::computation::{Computation, MatchResultVariant};
 use crate::language::{
-    Callable, CallableInput, CallableMetadata, EnumVariantConstructorPath, EnumVariantInit,
-    GenericArgument, PathType, RustIdentifier, Type,
+    Callable, CallableInput, EnumVariantConstructorPath, EnumVariantInit, GenericArgument, PathType,
+    RustIdentifier, Type,
 };
 use crate::rustdoc::{CORE_PACKAGE_ID_REPR, CrateCollection};
 
@@ -157,14 +157,12 @@ pub(crate) fn application_state_call_graph(
                     enum_generics: vec![],
                     variant_name: "Ok".into(),
                 },
-                metadata: CallableMetadata {
-                    output: Some(application_state_result.clone().into()),
-                    inputs: vec![CallableInput {
-                        name: RustIdentifier::new("_0".into()),
-                        type_: application_state.type_().into(),
-                    }],
-                    source_coordinates: None,
-                },
+                self_: Some(application_state_result.clone().into()),
+                fields: vec![CallableInput {
+                    name: RustIdentifier::new("_0".into()),
+                    type_: application_state.type_().into(),
+                }],
+                source_coordinates: None,
             })
         };
         let err_wrapper = {
@@ -177,14 +175,12 @@ pub(crate) fn application_state_call_graph(
                     enum_generics: vec![],
                     variant_name: "Err".into(),
                 },
-                metadata: CallableMetadata {
-                    output: Some(application_state_result.into()),
-                    inputs: vec![CallableInput {
-                        name: RustIdentifier::new("_0".into()),
-                        type_: error_enum.clone().into(),
-                    }],
-                    source_coordinates: None,
-                },
+                self_: Some(application_state_result.into()),
+                fields: vec![CallableInput {
+                    name: RustIdentifier::new("_0".into()),
+                    type_: error_enum.clone().into(),
+                }],
+                source_coordinates: None,
             })
         };
         component_db.get_or_intern_transformer(
@@ -263,14 +259,12 @@ pub(crate) fn application_state_call_graph(
                         enum_generics: vec![],
                         variant_name: error_type_name.to_owned(),
                     },
-                    metadata: CallableMetadata {
-                        output: Some(error_enum.clone().into()),
-                        inputs: vec![CallableInput {
-                            name: RustIdentifier::new("_0".into()),
-                            type_: error_type.to_owned(),
-                        }],
-                        source_coordinates: None,
-                    },
+                    self_: Some(error_enum.clone().into()),
+                    fields: vec![CallableInput {
+                        name: RustIdentifier::new("_0".into()),
+                        type_: error_type.to_owned(),
+                    }],
+                    source_coordinates: None,
                 });
                 let transformer_id = component_db.get_or_intern_transformer(
                     computation_db.get_or_intern(error_variant_constructor.clone()),
diff --git a/compiler/pavexc/src/compiler/analyses/call_graph/borrow_checker/clone.rs b/compiler/pavexc/src/compiler/analyses/call_graph/borrow_checker/clone.rs
@@ -13,8 +13,8 @@ use crate::compiler::analyses::user_components::ScopeId;
 use crate::compiler::computation::Computation;
 use crate::compiler::utils::resolve_type_path;
 use crate::language::{
-    Callable, CallableInput, CallableMetadata, FnHeader, Lifetime, RustIdentifier, PathType,
-    TraitMethod, TraitMethodPath, Type, TypeReference,
+    Callable, CallableInput, FnHeader, Lifetime, RustIdentifier, PathType, TraitMethod,
+    TraitMethodPath, Type, TypeReference,
 };
 use crate::rustdoc::CrateCollection;
 
@@ -71,7 +71,7 @@ pub(super) fn get_clone_component_id(
             method_name: "clone".into(),
             method_generics: vec![],
         },
-        metadata: CallableMetadata {
+        header: FnHeader {
             output: Some(output.clone()),
             inputs: vec![CallableInput {
                 name: RustIdentifier::new("_0".into()),
@@ -81,15 +81,13 @@ pub(super) fn get_clone_component_id(
                     inner: Box::new(output),
                 }),
             }],
-            source_coordinates: None,
-        },
-        header: FnHeader {
             is_async: false,
             abi: rustdoc_types::Abi::Rust,
             is_unsafe: false,
             is_c_variadic: false,
             symbol_name: None,
         },
+        source_coordinates: None,
         takes_self_as_ref: true,
     });
 
diff --git a/compiler/pavexc/src/compiler/analyses/call_graph/request_scoped.rs b/compiler/pavexc/src/compiler/analyses/call_graph/request_scoped.rs
@@ -16,8 +16,7 @@ use crate::compiler::analyses::computations::ComputationDb;
 use crate::compiler::analyses::constructibles::ConstructibleDb;
 use crate::compiler::computation::Computation;
 use crate::language::{
-    Callable, CallableInput, CallableMetadata, EnumVariantConstructorPath, EnumVariantInit,
-    RustIdentifier, Type,
+    Callable, CallableInput, EnumVariantConstructorPath, EnumVariantInit, RustIdentifier, Type,
 };
 use crate::rustdoc::CrateCollection;
 
@@ -210,14 +209,12 @@ fn augment_preprocessing_graph(
                 enum_generics: vec![],
                 variant_name: "EarlyReturn".into(),
             },
-            metadata: CallableMetadata {
-                output: Some(component_db.pavex_processing.clone()),
-                inputs: vec![CallableInput {
-                    name: RustIdentifier::new("_0".into()),
-                    type_: output_type.to_owned(),
-                }],
-                source_coordinates: None,
-            },
+            self_: Some(component_db.pavex_processing.clone()),
+            fields: vec![CallableInput {
+                name: RustIdentifier::new("_0".into()),
+                type_: output_type.to_owned(),
+            }],
+            source_coordinates: None,
         });
         component_db.get_or_intern_transformer(
             computation_db.get_or_intern(wrapper),
diff --git a/compiler/pavexc/src/compiler/analyses/into_error.rs b/compiler/pavexc/src/compiler/analyses/into_error.rs
@@ -6,8 +6,7 @@ use crate::compiler::analyses::computations::ComputationDb;
 use crate::compiler::analyses::user_components::ScopeId;
 use crate::compiler::computation::{Computation, MatchResultVariant};
 use crate::language::{
-    Callable, CallableInput, CallableMetadata, FnHeader, InherentMethod, InherentMethodPath,
-    RustIdentifier, Type,
+    Callable, CallableInput, FnHeader, InherentMethod, InherentMethodPath, RustIdentifier, Type,
 };
 
 /// Returns the [`ComponentId`] for a transformer component that calls `pavex::Error::new` on the
@@ -52,21 +51,19 @@ pub(super) fn register_error_new_transformer(
             method_name: "new".into(),
             method_generics: vec![],
         },
-        metadata: CallableMetadata {
+        header: FnHeader {
             output: Some(pavex_error.clone().into()),
             inputs: vec![CallableInput {
                 name: RustIdentifier::new("_0".into()),
                 type_: error.to_owned(),
             }],
-            source_coordinates: None,
-        },
-        header: FnHeader {
             is_async: false,
             abi: rustdoc_types::Abi::Rust,
             is_unsafe: false,
             is_c_variadic: false,
             symbol_name: None,
         },
+        source_coordinates: None,
         takes_self_as_ref: true,
     });
 
diff --git a/compiler/pavexc/src/compiler/analyses/processing_pipeline/pipeline.rs b/compiler/pavexc/src/compiler/analyses/processing_pipeline/pipeline.rs
@@ -24,9 +24,8 @@ use crate::compiler::computation::Computation;
 use crate::compiler::utils::LifetimeGenerator;
 use crate::diagnostic::{AnnotatedSource, CompilerDiagnostic, HelpWithSnippet};
 use crate::language::{
-    Callable, CallableInput, CallableMetadata, CanonicalType, GenericArgument,
-    GenericLifetimeParameter, Lifetime, RustIdentifier, PathType, PathTypeExt, StructLiteralInit,
-    Type, TypeReference,
+    Callable, CallableInput, CanonicalType, GenericArgument, GenericLifetimeParameter, Lifetime,
+    RustIdentifier, PathType, PathTypeExt, StructLiteralInit, Type, TypeReference,
 };
 use crate::rustdoc::CrateCollection;
 
@@ -690,17 +689,15 @@ impl RequestHandlerPipeline {
         // `next_type`.
         let next_state_constructor = Callable::StructLiteralInit(StructLiteralInit {
             path: next_state_type.callable_struct_literal_path(),
-            metadata: CallableMetadata {
-                output: Some(next_state_type.clone().into()),
-                inputs: next_state_parameters
-                    .iter()
-                    .map(|input| CallableInput {
-                        name: RustIdentifier::new(input.ident.clone()),
-                        type_: input.type_.clone(),
-                    })
-                    .collect(),
-                source_coordinates: None,
-            },
+            self_: Some(next_state_type.clone().into()),
+            fields: next_state_parameters
+                .iter()
+                .map(|input| CallableInput {
+                    name: RustIdentifier::new(input.ident.clone()),
+                    type_: input.type_.clone(),
+                })
+                .collect(),
+            source_coordinates: None,
             // TODO: remove when TAIT stabilises
             extra_field2default_value: BTreeMap::from([(
                 "next".into(),
diff --git a/compiler/pavexc/src/compiler/resolvers.rs b/compiler/pavexc/src/compiler/resolvers.rs
@@ -8,11 +8,10 @@ use rustdoc_types::{GenericParamDefKind, ItemEnum, Type as RustdocType};
 use tracing_log_error::log_error;
 
 use crate::language::{
-    Callable, CallableInput, CallableItem, CallableMetadata, FQGenericArgument, FQPath,
-    FQPathSegment, FQPathType, FnHeader, FreeFunction, FreeFunctionPath, Generic, GenericArgument,
-    GenericLifetimeParameter, InherentMethod, InherentMethodPath, RustIdentifier, PathType,
-    TraitMethod, TraitMethodPath, Type, UnknownPath, find_rustdoc_callable_items,
-    find_rustdoc_item_type, resolve_fq_path_type,
+    Callable, CallableInput, CallableItem, FQGenericArgument, FQPath, FQPathSegment, FQPathType,
+    FnHeader, FreeFunction, FreeFunctionPath, Generic, GenericArgument, GenericLifetimeParameter,
+    InherentMethod, InherentMethodPath, RustIdentifier, PathType, TraitMethod, TraitMethodPath,
+    Type, UnknownPath, find_rustdoc_callable_items, find_rustdoc_item_type, resolve_fq_path_type,
 };
 use crate::rustdoc::{CannotGetCrateData, CrateCollection, ResolvedItem};
 use rustdoc_ext::RustdocKindExt;
@@ -277,34 +276,32 @@ pub(crate) fn resolve_callable(
             .expect("Failed to convert generic arguments when building callable path");
 
     let fn_header = FnHeader {
+        output: output_type_path,
+        inputs: resolved_parameter_types,
         is_async: header.is_async,
         abi: header.abi.clone(),
         is_unsafe: header.is_unsafe,
         is_c_variadic: decl.is_c_variadic,
         symbol_name,
     };
-    let metadata = CallableMetadata {
-        output: output_type_path,
-        inputs: resolved_parameter_types,
-        source_coordinates: Some(callable_item.item_id.clone()),
-    };
+    let source_coordinates = Some(callable_item.item_id.clone());
 
     let callable = match resolved_path {
         ResolvedPath::FreeFunction(path) => Callable::FreeFunction(FreeFunction {
             path,
-            metadata,
             header: fn_header,
+            source_coordinates,
         }),
         ResolvedPath::InherentMethod(path) => Callable::InherentMethod(InherentMethod {
             path,
-            metadata,
             header: fn_header,
+            source_coordinates,
             takes_self_as_ref,
         }),
         ResolvedPath::TraitMethod(path) => Callable::TraitMethod(TraitMethod {
             path,
-            metadata,
             header: fn_header,
+            source_coordinates,
             takes_self_as_ref,
         }),
     };
diff --git a/compiler/pavexc/src/language/mod.rs b/compiler/pavexc/src/language/mod.rs
@@ -10,11 +10,10 @@ pub use krate_name::{
 };
 use pavex_bp_schema::CreatedAt;
 pub(crate) use resolved_type::{
-    Callable, CallableInput, CallableMetadata, CanonicalType, EnumVariantConstructorPath,
-    EnumVariantInit, FnHeader, FreeFunction, FreeFunctionPath, Generic, GenericArgument,
-    GenericLifetimeParameter, InherentMethod, InherentMethodPath, Lifetime, RustIdentifier,
-    PathType, PathTypeExt, RawPointer, StructLiteralInit, TraitMethod, TraitMethodPath, Tuple,
-    Type, TypeReference,
+    Callable, CallableInput, CanonicalType, EnumVariantConstructorPath, EnumVariantInit, FnHeader,
+    FreeFunction, FreeFunctionPath, Generic, GenericArgument, GenericLifetimeParameter,
+    InherentMethod, InherentMethodPath, Lifetime, RustIdentifier, PathType, PathTypeExt,
+    RawPointer, StructLiteralInit, TraitMethod, TraitMethodPath, Tuple, Type, TypeReference,
 };
 
 mod callable_path;
diff --git a/rustdoc/rustdoc_ir/src/callable.rs b/rustdoc/rustdoc_ir/src/callable.rs
diff --git a/rustdoc/rustdoc_ir/src/lib.rs b/rustdoc/rustdoc_ir/src/lib.rs
diff --git a/rustdoc/rustdoc_resolver/src/free_fn.rs b/rustdoc/rustdoc_resolver/src/free_fn.rs
diff --git a/rustdoc/rustdoc_resolver/src/method.rs b/rustdoc/rustdoc_resolver/src/method.rs
