feat: Allow function and method resolvers to configure how aliases should be handled

LukeMathWalker · LukeMathWalker · commit ffa178ab6256 · 2026-03-14T15:14:45.000+01:00
diff --git a/compiler/pavexc/src/compiler/analyses/user_components/annotations/coordinates.rs b/compiler/pavexc/src/compiler/analyses/user_components/annotations/coordinates.rs
@@ -14,7 +14,7 @@ use super::{
 use crate::compiler::analyses::user_components::{UserComponent, UserComponentId};
 use crate::compiler::component::{DefaultStrategy, PrebuiltType};
 use pavex_bp_schema::{CloningPolicy, Lint, LintSetting};
-use rustdoc_resolver::{resolve_free_function, rustdoc_method2callable};
+use rustdoc_resolver::{TypeAliasResolution, resolve_free_function, rustdoc_method2callable};
 
 /// Resolve coordinates to the annotation they point to.
 /// Then process the corresponding item.
@@ -212,9 +212,9 @@ pub(crate) fn resolve_annotation_coordinates(
 
         let outcome = match annotation.impl_ {
             Some(ImplInfo { attached_to, impl_ }) => {
-                rustdoc_method2callable(attached_to, impl_, &item, krate, krate_collection)
+                rustdoc_method2callable(attached_to, impl_, &item, krate, krate_collection, TypeAliasResolution::ResolveThrough)
             }
-            None => resolve_free_function(&item, krate, krate_collection)
+            None => resolve_free_function(&item, krate, krate_collection, TypeAliasResolution::ResolveThrough)
                 .map(rustdoc_ir::Callable::FreeFunction),
         };
         let callable = match outcome {
diff --git a/compiler/pavexc/src/compiler/analyses/user_components/annotations/mod.rs b/compiler/pavexc/src/compiler/analyses/user_components/annotations/mod.rs
@@ -33,8 +33,8 @@ use pavex_bp_schema::{CloningPolicy, Lifecycle, Lint, LintSetting};
 use pavexc_attr_parser::{AnnotationKind, AnnotationProperties};
 use rustdoc_ext::RustdocKindExt;
 use rustdoc_resolver::{
-    resolve_free_function, rustdoc_method2callable, rustdoc_new_type_def2type,
-    rustdoc_type_alias2type,
+    TypeAliasResolution, resolve_free_function, rustdoc_method2callable,
+    rustdoc_new_type_def2type, rustdoc_type_alias2type,
 };
 use rustdoc_types::{Item, ItemEnum};
 
@@ -179,9 +179,9 @@ pub(super) fn register_imported_components(
 
             let outcome = match annotation.impl_ {
                 Some(ImplInfo { attached_to, impl_ }) => {
-                    rustdoc_method2callable(attached_to, impl_, &item, krate, krate_collection)
+                    rustdoc_method2callable(attached_to, impl_, &item, krate, krate_collection, TypeAliasResolution::ResolveThrough)
                 }
-                None => resolve_free_function(&item, krate, krate_collection)
+                None => resolve_free_function(&item, krate, krate_collection, TypeAliasResolution::ResolveThrough)
                     .map(rustdoc_ir::Callable::FreeFunction),
             };
             let callable = match outcome {
diff --git a/compiler/pavexc/src/compiler/framework_rustdoc.rs b/compiler/pavexc/src/compiler/framework_rustdoc.rs
@@ -10,7 +10,7 @@ use crate::rustdoc::{CannotGetCrateData, CrateCollection};
 use rustdoc_ext::GlobalItemId;
 use rustdoc_ir::{CallableInput, FnHeader, RustIdentifier, TraitMethod, TraitMethodPath};
 use rustdoc_processor::queries::Crate;
-use rustdoc_resolver::{GenericBindings, resolve_type};
+use rustdoc_resolver::{GenericBindings, TypeAliasResolution, resolve_type};
 
 use super::app::PAVEX_VERSION;
 
@@ -157,6 +157,7 @@ pub(crate) fn resolve_type_path(raw_path: &str, krate_collection: &CrateCollecti
                         &global_id.package_id,
                         krate_collection,
                         &GenericBindings::default(),
+                        TypeAliasResolution::ResolveThrough,
                     )
                     .expect("Failed to resolve default generic type");
                     GenericArgument::TypeParameter(default)
@@ -198,7 +199,7 @@ pub(crate) fn resolve_framework_free_function(
         .unwrap_or_else(|e| panic!("Unknown free function path {}: {e:?}", segments.join("::")));
 
     let item = krate.get_item_by_local_type_id(&global_id.rustdoc_item_id);
-    let free_fn = rustdoc_resolver::resolve_free_function(&item, krate, krate_collection)
+    let free_fn = rustdoc_resolver::resolve_free_function(&item, krate, krate_collection, TypeAliasResolution::ResolveThrough)
         .expect("Failed to resolve free function");
     Callable::FreeFunction(free_fn)
 }
@@ -249,6 +250,7 @@ pub(crate) fn resolve_framework_inherent_method(
                     &item,
                     krate,
                     krate_collection,
+                    TypeAliasResolution::ResolveThrough,
                 )
                 .expect("Failed to resolve inherent method");
                 return callable;
@@ -334,6 +336,7 @@ pub(crate) fn resolve_framework_trait_method(
             &krate.core.package_id,
             krate_collection,
             &generic_bindings,
+            TypeAliasResolution::ResolveThrough,
         )
         .map_err(|e| {
             anyhow::anyhow!(
@@ -357,6 +360,7 @@ pub(crate) fn resolve_framework_trait_method(
                 &krate.core.package_id,
                 krate_collection,
                 &generic_bindings,
+                TypeAliasResolution::ResolveThrough,
             )
             .map_err(|e| {
                 anyhow::anyhow!(
diff --git a/compiler/pavexc/src/compiler/traits.rs b/compiler/pavexc/src/compiler/traits.rs
@@ -5,7 +5,7 @@ use rustdoc_types::{GenericParamDefKind, ItemEnum, Type as RustdocType};
 
 use crate::language::{PathType, Type};
 use crate::rustdoc::{Crate, CrateCollection};
-use rustdoc_resolver::{GenericBindings, resolve_type};
+use rustdoc_resolver::{GenericBindings, TypeAliasResolution, resolve_type};
 
 /// It returns an error if `type_` doesn't implement the specified trait.
 ///
@@ -102,6 +102,7 @@ pub(crate) fn implements_trait(
                                 &our_path_type.package_id,
                                 krate_collection,
                                 &generic_bindings,
+                                TypeAliasResolution::ResolveThrough,
                             )?;
                             generic_bindings
                                 .types
@@ -122,6 +123,7 @@ pub(crate) fn implements_trait(
                     &our_path_type.package_id,
                     krate_collection,
                     &generic_bindings,
+                    TypeAliasResolution::ResolveThrough,
                 )?;
                 if implements_trait(krate_collection, &type_, expected_trait)? {
                     return Ok(true);
diff --git a/rustdoc/rustdoc_resolver/src/free_fn.rs b/rustdoc/rustdoc_resolver/src/free_fn.rs
@@ -11,13 +11,15 @@ use rustdoc_processor::indexing::CrateIndexer;
 use rustdoc_processor::queries::Crate;
 
 use crate::errors::*;
+use crate::resolve_type::TypeAliasResolution;
 use crate::resolve_type::resolve_type;
 
 /// Convert a free function from `rustdoc_types` into a [`FreeFunction`].
 pub fn resolve_free_function<I: CrateIndexer>(
     item: &Item,
     krate: &Crate,
     krate_collection: &CrateCollection<I>,
+    alias_resolution: TypeAliasResolution,
 ) -> Result<FreeFunction, CallableResolutionError> {
     let ItemEnum::Function(inner) = &item.inner else {
         unreachable!("Expected a function item");
@@ -35,6 +37,7 @@ pub fn resolve_free_function<I: CrateIndexer>(
             &krate.core.package_id,
             krate_collection,
             &Default::default(),
+            alias_resolution,
         ) {
             Ok(t) => {
                 inputs.push(CallableInput {
@@ -62,6 +65,7 @@ pub fn resolve_free_function<I: CrateIndexer>(
                 &krate.core.package_id,
                 krate_collection,
                 &Default::default(),
+                alias_resolution,
             ) {
                 Ok(t) => Some(t),
                 Err(e) => {
diff --git a/rustdoc/rustdoc_resolver/src/lib.rs b/rustdoc/rustdoc_resolver/src/lib.rs
@@ -13,7 +13,7 @@ mod type_def;
 pub use errors::*;
 pub use free_fn::resolve_free_function;
 pub use method::rustdoc_method2callable;
-pub use resolve_type::resolve_type;
+pub use resolve_type::{TypeAliasResolution, resolve_type};
 pub use type_def::{rustdoc_new_type_def2type, rustdoc_type_alias2type};
 
 use ahash::HashMap;
diff --git a/rustdoc/rustdoc_resolver/src/method.rs b/rustdoc/rustdoc_resolver/src/method.rs
@@ -16,6 +16,7 @@ use rustdoc_processor::queries::Crate;
 
 use crate::GenericBindings;
 use crate::errors::*;
+use crate::resolve_type::TypeAliasResolution;
 use crate::resolve_type::resolve_type;
 
 /// Convert a method item retrieved from `rustdoc`'s JSON output to Pavex's internal
@@ -37,6 +38,7 @@ pub fn rustdoc_method2callable<I: CrateIndexer>(
     method_item: &Item,
     krate: &Crate,
     krate_collection: &CrateCollection<I>,
+    alias_resolution: TypeAliasResolution,
 ) -> Result<Callable, CallableResolutionError> {
     let impl_item = krate.get_item_by_local_type_id(&impl_id);
     let ItemEnum::Impl(impl_item) = &impl_item.inner else {
@@ -50,6 +52,7 @@ pub fn rustdoc_method2callable<I: CrateIndexer>(
         &krate.core.package_id,
         krate_collection,
         &generic_bindings,
+        alias_resolution,
     ) {
         Ok(t) => t,
         Err(e) => {
@@ -110,6 +113,7 @@ pub fn rustdoc_method2callable<I: CrateIndexer>(
                             &krate.core.package_id,
                             krate_collection,
                             &generic_bindings,
+                            alias_resolution,
                         ) else {
                             todo!()
                         };
@@ -178,6 +182,7 @@ pub fn rustdoc_method2callable<I: CrateIndexer>(
             &krate.core.package_id,
             krate_collection,
             &generic_bindings,
+            alias_resolution,
         ) {
             Ok(t) => {
                 inputs.push(CallableInput {
@@ -205,6 +210,7 @@ pub fn rustdoc_method2callable<I: CrateIndexer>(
                 &krate.core.package_id,
                 krate_collection,
                 &generic_bindings,
+                alias_resolution,
             ) {
                 Ok(t) => Some(t),
                 Err(e) => {
diff --git a/rustdoc/rustdoc_resolver/src/resolve_type.rs b/rustdoc/rustdoc_resolver/src/resolve_type.rs
diff --git a/rustdoc/rustdoc_resolver/src/type_def.rs b/rustdoc/rustdoc_resolver/src/type_def.rs
