chore: Format and lints

Author: LukeMathWalker

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, EnumVariantConstructorPath, EnumVariantInit, GenericArgument, PathType,
-    RustIdentifier, Type,
+    Callable, CallableInput, EnumVariantConstructorPath, EnumVariantInit, GenericArgument,
+    PathType, RustIdentifier, Type,
 };
 use crate::rustdoc::{CORE_PACKAGE_ID_REPR, CrateCollection};
 

compiler/pavexc/src/compiler/analyses/call_graph/borrow_checker/clone.rs

@@ -13,7 +13,7 @@ use crate::compiler::analyses::user_components::ScopeId;
 use crate::compiler::computation::Computation;
 use crate::compiler::utils::resolve_type_path;
 use crate::language::{
-    Callable, CallableInput, FnHeader, Lifetime, RustIdentifier, PathType, TraitMethod,
+    Callable, CallableInput, FnHeader, Lifetime, PathType, RustIdentifier, TraitMethod,
     TraitMethodPath, Type, TypeReference,
 };
 use crate::rustdoc::CrateCollection;

compiler/pavexc/src/compiler/analyses/processing_pipeline/pipeline.rs

@@ -25,7 +25,7 @@ use crate::compiler::utils::LifetimeGenerator;
 use crate::diagnostic::{AnnotatedSource, CompilerDiagnostic, HelpWithSnippet};
 use crate::language::{
     Callable, CallableInput, CanonicalType, GenericArgument, GenericLifetimeParameter, Lifetime,
-    RustIdentifier, PathType, PathTypeExt, StructLiteralInit, Type, TypeReference,
+    PathType, PathTypeExt, RustIdentifier, StructLiteralInit, Type, TypeReference,
 };
 use crate::rustdoc::CrateCollection;
 

compiler/pavexc/src/compiler/analyses/user_components/annotations/coordinates.rs

@@ -11,10 +11,10 @@ use super::{
     AuxiliaryData, ConfigType, ImplInfo, annotated_item2type, cannot_resolve_callable_path,
     invalid_config_type, validate_route_path,
 };
-use rustdoc_resolver::{resolve_free_function, rustdoc_method2callable};
 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};
 
 /// Resolve coordinates to the annotation they point to.
 /// Then process the corresponding item.

compiler/pavexc/src/compiler/resolvers.rs

@@ -10,7 +10,7 @@ use tracing_log_error::log_error;
 use crate::language::{
     Callable, CallableInput, CallableItem, FQGenericArgument, FQPath, FQPathSegment, FQPathType,
     FnHeader, FreeFunction, FreeFunctionPath, Generic, GenericArgument, GenericLifetimeParameter,
-    InherentMethod, InherentMethodPath, RustIdentifier, PathType, TraitMethod, TraitMethodPath,
+    InherentMethod, InherentMethodPath, PathType, RustIdentifier, TraitMethod, TraitMethodPath,
     Type, UnknownPath, find_rustdoc_callable_items, find_rustdoc_item_type, resolve_fq_path_type,
 };
 use crate::rustdoc::{CannotGetCrateData, CrateCollection, ResolvedItem};

compiler/pavexc/src/language/fq_path_resolution.rs

@@ -4,7 +4,6 @@ use std::sync::Arc;
 
 use rustdoc_types::ItemEnum;
 
-use rustdoc_resolver::{GenericBindings, resolve_type};
 use crate::language::callable_path::{CallPathGenericArgument, CallPathLifetime, CallPathType};
 use crate::language::krate_name::dependency_name2package_id;
 use crate::language::resolved_type::{Array, GenericArgument, Slice};
@@ -13,6 +12,7 @@ use crate::rustdoc::{
     CannotGetCrateData, CrateCollection, CrateCollectionExt, GlobalItemId, ResolvedItem,
 };
 use rustdoc_ext::RustdocKindExt;
+use rustdoc_resolver::{GenericBindings, resolve_type};
 
 use super::RawIdentifiers;
 use super::fq_path::*;

compiler/pavexc/src/language/mod.rs

@@ -12,8 +12,8 @@ use pavex_bp_schema::CreatedAt;
 pub(crate) use resolved_type::{
     Callable, CallableInput, CanonicalType, EnumVariantConstructorPath, EnumVariantInit, FnHeader,
     FreeFunction, FreeFunctionPath, Generic, GenericArgument, GenericLifetimeParameter,
-    InherentMethod, InherentMethodPath, Lifetime, RustIdentifier, PathType, PathTypeExt,
-    RawPointer, StructLiteralInit, TraitMethod, TraitMethodPath, Tuple, Type, TypeReference,
+    InherentMethod, InherentMethodPath, Lifetime, PathType, PathTypeExt, RawPointer,
+    RustIdentifier, StructLiteralInit, TraitMethod, TraitMethodPath, Tuple, Type, TypeReference,
 };
 
 mod callable_path;

compiler/pavexc/src/rustdoc/queries/collection.rs

@@ -3,12 +3,12 @@ use std::sync::Arc;
 
 use rustdoc_types::{Item, ItemEnum};
 
-use rustdoc_resolver::{GenericBindings, resolve_type};
 use crate::language::{
     FQGenericArgument, FQPathType, UnknownCrate, krate2package_id, resolve_fq_path_type,
 };
 use crate::rustdoc::CannotGetCrateData;
 use rustdoc_ext::RustdocKindExt;
+use rustdoc_resolver::{GenericBindings, resolve_type};
 
 use super::super::AnnotatedItem;
 use super::super::annotations::AnnotationCoordinates;

rustdoc/rustdoc_resolver/src/resolve_type.rs

@@ -10,11 +10,11 @@ use rustdoc_ir::{
     Array, Generic, GenericArgument, GenericLifetimeParameter, PathType, RawPointer, Slice, Tuple,
     Type, TypeReference,
 };
-use rustdoc_processor::indexing::CrateIndexer;
 use rustdoc_processor::CrateCollection;
+use rustdoc_processor::indexing::CrateIndexer;
 
-use crate::errors::*;
 use crate::GenericBindings;
+use crate::errors::*;
 
 /// Convert a `rustdoc_types::Type` into a `rustdoc_ir::Type`, recursively resolving
 /// through type aliases and substituting generic bindings.
@@ -520,16 +520,15 @@ fn skip_default<I: CrateIndexer>(krate_collection: &CrateCollection<I>, default:
         // the canonical path.  Fall back to the well-known path if resolution
         // fails (e.g. alloc docs not available).
         let alloc_pid = PackageId::new(rustdoc_processor::ALLOC_PACKAGE_ID_REPR);
-        if let Some(krate) = krate_collection.get_crate_by_package_id(&alloc_pid) {
-            if let Some(item_entry) = krate
+        if let Some(krate) = krate_collection.get_crate_by_package_id(&alloc_pid)
+            && let Some(item_entry) = krate
                 .import_index
                 .items
                 .iter()
                 .find(|(_, entry)| entry.canonical_path() == ["alloc", "alloc", "Global"])
             {
                 return item_entry.1.canonical_path().to_vec();
             }
-        }
         vec!["alloc".into(), "alloc".into(), "Global".into()]
     });
 

rustdoc/rustdoc_resolver/src/type_def.rs

@@ -2,23 +2,26 @@
 
 use rustdoc_types::{Item, ItemEnum};
 
-use rustdoc_ir::{Generic, GenericArgument, GenericLifetimeParameter, PathType, Type};
 use rustdoc_ext::RustdocKindExt;
+use rustdoc_ir::{Generic, GenericArgument, GenericLifetimeParameter, PathType, Type};
+use rustdoc_processor::CrateCollection;
 use rustdoc_processor::indexing::CrateIndexer;
 use rustdoc_processor::queries::Crate;
-use rustdoc_processor::CrateCollection;
 
+use crate::GenericBindings;
 use crate::errors::{TypeResolutionError, UnsupportedConstGeneric};
 use crate::resolve_type::resolve_type;
-use crate::GenericBindings;
 
 /// Convert an enum or a struct definition from the JSON documentation
 /// for a crate into our own representation for types.
 ///
 /// # Panics
 ///
 /// Panics if the item isn't of kind enum or struct.
-pub fn rustdoc_new_type_def2type(item: &Item, krate: &Crate) -> Result<Type, UnsupportedConstGeneric> {
+pub fn rustdoc_new_type_def2type(
+    item: &Item,
+    krate: &Crate,
+) -> Result<Type, UnsupportedConstGeneric> {
     assert!(
         matches!(&item.inner, ItemEnum::Struct(_) | ItemEnum::Enum(_)),
         "Unexpected item type, `{}`. Expected a struct or an enum.",