Type aliases, take #N

doc_examples/guide/cookies/installation/missing_process_config.snap

@@ -2,7 +2,7 @@
   × I can't find a constructor for `biscotti::ProcessorConfig`.
   │ I need an instance of `biscotti::ProcessorConfig` to
   │ invoke your constructor, `<pavex::cookie::Processor as
-  │ std::convert::From::<pavex::cookie::ProcessorConfig>>::from`.
+  │ core::convert::From::<pavex::cookie::ProcessorConfig>>::from`.
   │
   │     ╭─[../../../../../libs/pavex/src/cookie/kit.rs:80:1]
   │  80 │                     .error_handler(f!(super::errors::InjectResponseCookiesError::into_response));

libs/pavexc/src/compiler/analyses/call_graph/dependency_graph.rs

@@ -351,7 +351,13 @@ fn cycle_error(
         .unwrap();
     }
 
-    let diagnostic_builder = CompilerDiagnostic::builder(anyhow::anyhow!(error_msg));
+    let error = anyhow::anyhow!(
+        "There is a cycle in this dependency graph. Graph:\n{}",
+        // TODO: Use a PadAdapter to indent the graph, avoiding the need for an intermediate stringa allocation.
+        textwrap::indent(&graph.debug_dot(component_db, computation_db), "  ")
+    )
+    .context(error_msg);
+    let diagnostic_builder = CompilerDiagnostic::builder(error);
 
     diagnostic_builder.help(
             "Break the cycle! Remove one of the 'depends-on' relationship by changing the signature of \

libs/pavexc/src/compiler/analyses/components/db/diagnostics.rs

@@ -159,7 +159,7 @@ impl ComponentDb {
                     package_graph: &PackageGraph,
                 ) -> Option<AnnotatedSnippet> {
                     let global_item_id = callable.source_coordinates.as_ref()?;
-                    let item = krate_collection.get_type_by_global_type_id(global_item_id);
+                    let item = krate_collection.get_item_by_global_type_id(global_item_id);
                     let definition_span = item.span.as_ref()?;
                     let source_contents = diagnostic::read_source_file(
                         &definition_span.filename,
@@ -177,6 +177,10 @@ impl ComponentDb {
                                 syn::parse_str::<syn::ImplItemFn>(&span_contents)
                             {
                                 item.sig.output
+                            } else if let Ok(item) =
+                                syn::parse_str::<syn::TraitItemFn>(&span_contents)
+                            {
+                                item.sig.output
                             } else {
                                 panic!("Could not parse as a function or method:\n{span_contents}")
                             }
@@ -271,7 +275,7 @@ impl ComponentDb {
                     package_graph: &PackageGraph,
                 ) -> Option<AnnotatedSnippet> {
                     let global_item_id = callable.source_coordinates.as_ref()?;
-                    let item = krate_collection.get_type_by_global_type_id(global_item_id);
+                    let item = krate_collection.get_item_by_global_type_id(global_item_id);
                     let definition_span = item.span.as_ref()?;
                     let source_contents = diagnostic::read_source_file(
                         &definition_span.filename,
@@ -289,6 +293,10 @@ impl ComponentDb {
                                 syn::parse_str::<syn::ImplItemFn>(&span_contents)
                             {
                                 item.sig.generics.params
+                            } else if let Ok(item) =
+                                syn::parse_str::<syn::TraitItemFn>(&span_contents)
+                            {
+                                item.sig.generics.params
                             } else {
                                 panic!("Could not parse as a function or method:\n{span_contents}")
                             }

libs/pavexc/src/compiler/analyses/constructibles.rs

@@ -23,12 +23,26 @@ use crate::try_source;
 
 use super::framework_items::FrameworkItemDb;
 
-#[derive(Debug)]
 /// The set of types that can be injected into request handlers, error handlers and (other) constructors.
 pub(crate) struct ConstructibleDb {
     scope_id2constructibles: IndexMap<ScopeId, ConstructiblesInScope>,
 }
 
+impl std::fmt::Debug for ConstructibleDb {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Available constructibles:\n")?;
+        for (scope_id, constructibles) in &self.scope_id2constructibles {
+            writeln!(
+                f,
+                "- {scope_id}:\n{}",
+                // TODO: Use a PadAdapter down here to avoid allocating an intermediate string
+                textwrap::indent(&format!("{:?}", constructibles), "    ")
+            )?;
+        }
+        Ok(())
+    }
+}
+
 impl ConstructibleDb {
     /// Compute the set of types that can be injected into request handlers, error handlers and
     /// (other) constructors.
@@ -147,6 +161,20 @@ impl ConstructibleDb {
                         }
                     }
 
+                    // Both `T` and `&T` are always constructibles, when looking at generic constructors that take them
+                    // as input. The actual check will happen when they are bound to a specific type.
+                    match input {
+                        ResolvedType::Reference(ref_) => {
+                            if let ResolvedType::Generic(_) = ref_.inner.as_ref() {
+                                continue;
+                            }
+                        }
+                        ResolvedType::Generic(_) => {
+                            continue;
+                        }
+                        _ => {}
+                    }
+
                     if let Some((input_component_id, mode)) = self.get_or_try_bind(
                         scope_id,
                         input,
@@ -232,7 +260,7 @@ impl ConstructibleDb {
                         continue;
                     }
                     if let Some(user_component_id) = component_db.user_component_id(component_id) {
-                        Self::missing_constructor(
+                        self.missing_constructor(
                             user_component_id,
                             component_db.user_component_db(),
                             input,
@@ -605,6 +633,7 @@ impl ConstructibleDb {
     }
 
     fn missing_constructor(
+        &self,
         user_component_id: UserComponentId,
         user_component_db: &UserComponentDb,
         unconstructible_type: &ResolvedType,
@@ -640,10 +669,12 @@ impl ConstructibleDb {
             .flatten();
 
         let callable = &computation_db[user_component_id];
-        let e = anyhow::anyhow!(
-            "I can't find a constructor for `{unconstructible_type:?}`.\n\
-            I need an instance of `{unconstructible_type:?}` to invoke your {component_kind}, `{}`.",
-            callable.path
+        let e = anyhow::anyhow!("I can't find a constructor for `{}`.\n{self:?}", unconstructible_type.display_for_error()).context(
+            format!(
+                "I can't find a constructor for `{unconstructible_type:?}`.\n\
+                I need an instance of `{unconstructible_type:?}` to invoke your {component_kind}, `{}`.",
+                callable.path
+            )
         );
         let definition_info = get_definition_info(
             callable,
@@ -935,7 +966,6 @@ impl ConstructibleDb {
     }
 }
 
-#[derive(Debug)]
 /// The set of constructibles that have been registered in a given scope.
 ///
 /// Be careful! This is not the set of all types that can be constructed in the given scope!
@@ -1006,15 +1036,22 @@ impl ConstructiblesInScope {
         }
         for templated_constructible_type in &self.templated_constructors {
             if let Some(bindings) = templated_constructible_type.is_a_template_for(type_) {
-                let (templated_component_id, _) = self.get(templated_constructible_type).unwrap();
+                let template = templated_constructible_type.clone();
+                let (templated_component_id, _) = self.get(&template).unwrap();
                 self.bind_and_register_constructor(
                     templated_component_id,
                     component_db,
                     computation_db,
                     framework_item_db,
                     &bindings,
                 );
-                return self.get(type_);
+                let bound = self.get(type_);
+                assert!(bound.is_some(), "I used {} as a templated constructor to build {} but the binding process didn't succeed as expected.\nBindings:\n{}", 
+                    template.display_for_error(),
+                    type_.display_for_error(),
+                    bindings.into_iter().map(|(k, v)| format!("- {k} -> {}", v.display_for_error())).collect::<Vec<_>>().join("\n")
+                );
+                return bound;
             }
         }
 
@@ -1090,3 +1127,13 @@ impl ConstructiblesInScope {
         }
     }
 }
+
+impl std::fmt::Debug for ConstructiblesInScope {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Constructibles:")?;
+        for (type_, component_id) in &self.type2constructor_id {
+            writeln!(f, "- {} -> {:?}", type_.display_for_error(), component_id)?;
+        }
+        Ok(())
+    }
+}

libs/pavexc/src/compiler/analyses/user_components/scope_graph.rs

@@ -67,6 +67,12 @@ pub struct ScopeGraphBuilder {
 /// See [`ScopeGraph`] for more information.
 pub struct ScopeId(usize);
 
+impl std::fmt::Display for ScopeId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Scope {}", self.0)
+    }
+}
+
 impl PartialEq<ScopeId> for &ScopeId {
     fn eq(&self, other: &ScopeId) -> bool {
         self.0 == other.0

libs/pavexc/src/compiler/component/prebuilt_type.rs

@@ -3,7 +3,7 @@ use crate::language::ResolvedType;
 pub struct PrebuiltType(ResolvedType);
 
 impl PrebuiltType {
-    pub fn new(ty: ResolvedType) -> Result<Self, PrebuiltTypeValidationError> {
+    pub(crate) fn new(ty: ResolvedType) -> Result<Self, PrebuiltTypeValidationError> {
         if ty.has_implicit_lifetime_parameters() || !ty.named_lifetime_parameters().is_empty() {
             return Err(PrebuiltTypeValidationError::CannotHaveLifetimeParameters { ty });
         }

libs/pavexc/src/compiler/path_parameter_validation.rs

@@ -141,7 +141,7 @@ pub(crate) fn verify_path_parameters(
                     unreachable!()
                 };
                 for field_id in field_ids {
-                    let field_item = krate_collection.get_type_by_global_type_id(&GlobalItemId {
+                    let field_item = krate_collection.get_item_by_global_type_id(&GlobalItemId {
                         rustdoc_item_id: field_id.clone(),
                         package_id: extracted_path_type.package_id.clone(),
                     });
@@ -298,7 +298,7 @@ fn must_be_a_plain_struct(
             let Some(item_id) = t.rustdoc_id.clone() else {
                 unreachable!()
             };
-            let item = krate_collection.get_type_by_global_type_id(&GlobalItemId {
+            let item = krate_collection.get_item_by_global_type_id(&GlobalItemId {
                 rustdoc_item_id: item_id,
                 package_id: t.package_id.clone(),
             });