refactor: encapsulate TyLoweringContext usage in hir-ty

crates/hir-ty/src/lib.rs

@@ -94,7 +94,7 @@ pub use infer::{
 };
 pub use lower::{
     GenericPredicates, ImplTraits, LifetimeElisionKind, TyDefId, TyLoweringContext, ValueTyDefId,
-    associated_type_shorthand_candidates, diagnostics::*,
+    associated_type_shorthand_candidates, diagnostics::*, lower_ty_ext_for_def, lower_ty_for_def,
 };
 pub use next_solver::interner::{attach_db, attach_db_allow_change, with_attached_db};
 pub use target_feature::TargetFeatures;

crates/hir-ty/src/lower.rs

@@ -2615,6 +2615,33 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
         })
 }
 
+/// Lowers a [`TypeRefId`] to a [`Ty`] given a generic definition context.
+///
+/// This is the public API for crates that need to lower type references
+/// without manually creating a [`TyLoweringContext`]. Elided lifetimes are inferred.
+pub fn lower_ty_for_def<'db>(
+    db: &'db dyn HirDatabase,
+    resolver: &Resolver<'db>,
+    store: &ExpressionStore,
+    def: GenericDefId,
+    type_ref: TypeRefId,
+) -> Ty<'db> {
+    TyLoweringContext::new(db, resolver, store, def, LifetimeElisionKind::Infer).lower_ty(type_ref)
+}
+
+/// Like [`lower_ty_for_def`], but also returns the [`TypeNs`] resolution if
+/// the type resolved to a named type in the type namespace (e.g. an ADT, trait, or type alias).
+pub fn lower_ty_ext_for_def<'db>(
+    db: &'db dyn HirDatabase,
+    resolver: &Resolver<'db>,
+    store: &ExpressionStore,
+    def: GenericDefId,
+    type_ref: TypeRefId,
+) -> (Ty<'db>, Option<TypeNs>) {
+    TyLoweringContext::new(db, resolver, store, def, LifetimeElisionKind::Infer)
+        .lower_ty_ext(type_ref)
+}
+
 pub fn associated_type_shorthand_candidates(
     db: &dyn HirDatabase,
     def: GenericDefId,

crates/hir/src/source_analyzer.rs

@@ -29,12 +29,13 @@ use hir_expand::{
     name::{AsName, Name},
 };
 use hir_ty::{
-    Adjustment, InferenceResult, LifetimeElisionKind, ParamEnvAndCrate, TyLoweringContext,
+    Adjustment, InferenceResult, ParamEnvAndCrate,
     diagnostics::{
         InsideUnsafeBlock, record_literal_missing_fields, record_pattern_missing_fields,
         unsafe_operations,
     },
     lang_items::lang_items_for_bin_op,
+    lower_ty_ext_for_def, lower_ty_for_def,
     method_resolution::{self, CandidateId},
     next_solver::{
         DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, Ty, TyKind, TypingMode,
@@ -276,17 +277,13 @@ impl<'db> SourceAnalyzer<'db> {
 
         let type_ref = self.type_id(ty)?;
 
-        let mut ty = TyLoweringContext::new(
+        let mut ty = lower_ty_for_def(
             db,
             &self.resolver,
             self.store()?,
             self.resolver.generic_def()?,
-            // FIXME: Is this correct here? Anyway that should impact mostly diagnostics, which we don't emit here
-            // (this can impact the lifetimes generated, e.g. in `const` they won't be `'static`, but this seems like a
-            // small problem).
-            LifetimeElisionKind::Infer,
-        )
-        .lower_ty(type_ref);
+            type_ref,
+        );
 
         // Try and substitute unknown types using InferenceResult
         if let Some(infer) = self.infer()
@@ -1649,9 +1646,7 @@ fn resolve_hir_path_(
     let types = || {
         let (ty, unresolved) = match path.type_anchor() {
             Some(type_ref) => resolver.generic_def().and_then(|def| {
-                let (_, res) =
-                    TyLoweringContext::new(db, resolver, store?, def, LifetimeElisionKind::Infer)
-                        .lower_ty_ext(type_ref);
+                let (_, res) = lower_ty_ext_for_def(db, resolver, store?, def, type_ref);
                 res.map(|ty_ns| (ty_ns, path.segments().first()))
             }),
             None => {
@@ -1798,9 +1793,7 @@ fn resolve_hir_path_qualifier(
     (|| {
         let (ty, unresolved) = match path.type_anchor() {
             Some(type_ref) => resolver.generic_def().and_then(|def| {
-                let (_, res) =
-                    TyLoweringContext::new(db, resolver, store, def, LifetimeElisionKind::Infer)
-                        .lower_ty_ext(type_ref);
+                let (_, res) = lower_ty_ext_for_def(db, resolver, store, def, type_ref);
                 res.map(|ty_ns| (ty_ns, path.segments().first()))
             }),
             None => {