Factor out shared code for probing inherent assoc items

Author: camelid

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -494,7 +494,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         err.emit()
     }
 
-    pub(crate) fn complain_about_ambiguous_inherent_assoc_ty(
+    pub(crate) fn complain_about_ambiguous_inherent_assoc(
         &self,
         name: Ident,
         candidates: Vec<DefId>,
@@ -555,13 +555,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     }
 
     // FIXME(inherent_associated_types): Find similarly named associated types and suggest them.
-    pub(crate) fn complain_about_inherent_assoc_ty_not_found(
+    pub(crate) fn complain_about_inherent_assoc_not_found(
         &self,
         name: Ident,
         self_ty: Ty<'tcx>,
         candidates: Vec<(DefId, (DefId, DefId))>,
         fulfillment_errors: Vec<FulfillmentError<'tcx>>,
         span: Span,
+        kind: ty::AssocKind,
     ) -> ErrorGuaranteed {
         // FIXME(fmease): This was copied in parts from an old version of `rustc_hir_typeck::method::suggest`.
         // Either
@@ -571,12 +572,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let tcx = self.tcx();
 
+        let kind_str = assoc_kind_str(kind);
         let adt_did = self_ty.ty_adt_def().map(|def| def.did());
         let add_def_label = |err: &mut Diag<'_>| {
             if let Some(did) = adt_did {
                 err.span_label(
                     tcx.def_span(did),
-                    format!("associated item `{name}` not found for this {}", tcx.def_descr(did)),
+                    format!(
+                        "associated {kind_str} `{name}` not found for this {}",
+                        tcx.def_descr(did)
+                    ),
                 );
             }
         };
@@ -603,11 +608,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 self.dcx(),
                 name.span,
                 E0220,
-                "associated type `{name}` not found for `{self_ty}` in the current scope"
+                "associated {kind_str} `{name}` not found for `{self_ty}` in the current scope"
             );
             err.span_label(name.span, format!("associated item not found in `{self_ty}`"));
             err.note(format!(
-                "the associated type was found for\n{type_candidates}{additional_types}",
+                "the associated {kind_str} was found for\n{type_candidates}{additional_types}",
             ));
             add_def_label(&mut err);
             return err.emit();
@@ -688,7 +693,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let mut err = self.dcx().struct_span_err(
             name.span,
-            format!("the associated type `{name}` exists for `{self_ty}`, but its trait bounds were not satisfied")
+            format!("the associated {kind_str} `{name}` exists for `{self_ty}`, but its trait bounds were not satisfied")
         );
         if !bounds.is_empty() {
             err.note(format!(
@@ -698,7 +703,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
         err.span_label(
             name.span,
-            format!("associated type cannot be referenced on `{self_ty}` due to unsatisfied trait bounds")
+            format!("associated {kind_str} cannot be referenced on `{self_ty}` due to unsatisfied trait bounds")
         );
 
         for (span, mut bounds) in bound_spans {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -1176,7 +1176,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
             // FIXME(inherent_associated_types, #106719): Support self types other than ADTs.
             if let Some((ty, did)) = self.probe_inherent_assoc_ty(
-                assoc_ident,
                 assoc_segment,
                 adt_def.did(),
                 qself_ty,
@@ -1377,7 +1376,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
     fn probe_inherent_assoc_ty(
         &self,
-        name: Ident,
         segment: &hir::PathSegment<'tcx>,
         adt_did: DefId,
         self_ty: Ty<'tcx>,
@@ -1396,6 +1394,60 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             return Ok(None);
         }
 
+        let Some((def_id, args)) = self.probe_inherent_assoc_shared(
+            segment,
+            adt_did,
+            self_ty,
+            block,
+            span,
+            ty::AssocKind::Type,
+        )?
+        else {
+            return Ok(None);
+        };
+
+        let ty = Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new_from_args(tcx, def_id, args));
+        Ok(Some((ty, def_id)))
+    }
+
+    fn probe_inherent_assoc_const(
+        &self,
+        segment: &hir::PathSegment<'tcx>,
+        adt_did: DefId,
+        self_ty: Ty<'tcx>,
+        block: HirId,
+        span: Span,
+    ) -> Result<Option<(Const<'tcx>, DefId)>, ErrorGuaranteed> {
+        let tcx = self.tcx();
+
+        let Some((def_id, args)) = self.probe_inherent_assoc_shared(
+            segment,
+            adt_did,
+            self_ty,
+            block,
+            span,
+            ty::AssocKind::Const,
+        )?
+        else {
+            return Ok(None);
+        };
+
+        let ct = Const::new_unevaluated(tcx, ty::UnevaluatedConst::new(def_id, args));
+        Ok(Some((ct, def_id)))
+    }
+
+    fn probe_inherent_assoc_shared(
+        &self,
+        segment: &hir::PathSegment<'tcx>,
+        adt_did: DefId,
+        self_ty: Ty<'tcx>,
+        block: HirId,
+        span: Span,
+        kind: ty::AssocKind,
+    ) -> Result<Option<(DefId, GenericArgsRef<'tcx>)>, ErrorGuaranteed> {
+        let tcx = self.tcx();
+
+        let name = segment.ident;
         let candidates: Vec<_> = tcx
             .inherent_impls(adt_did)
             .iter()
@@ -1439,8 +1491,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             &mut universes,
             self_ty,
             |self_ty| {
-                self.select_inherent_assoc_type_candidates(
-                    infcx, name, span, self_ty, param_env, candidates,
+                self.select_inherent_assoc_candidates(
+                    infcx, name, span, self_ty, param_env, candidates, kind,
                 )
             },
         )?;
@@ -1457,20 +1509,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 .chain(args.into_iter().skip(parent_args.len())),
         );
 
-        let ty =
-            Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new_from_args(tcx, assoc_item, args));
-
-        Ok(Some((ty, assoc_item)))
+        Ok(Some((assoc_item, args)))
     }
 
-    fn select_inherent_assoc_type_candidates(
+    fn select_inherent_assoc_candidates(
         &self,
         infcx: &InferCtxt<'tcx>,
         name: Ident,
         span: Span,
         self_ty: Ty<'tcx>,
         param_env: ParamEnv<'tcx>,
         candidates: Vec<(DefId, (DefId, DefId))>,
+        kind: ty::AssocKind,
     ) -> Result<(DefId, (DefId, DefId)), ErrorGuaranteed> {
         let tcx = self.tcx();
         let mut fulfillment_errors = Vec::new();
@@ -1515,17 +1565,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             .collect();
 
         match &applicable_candidates[..] {
-            &[] => Err(self.complain_about_inherent_assoc_ty_not_found(
+            &[] => Err(self.complain_about_inherent_assoc_not_found(
                 name,
                 self_ty,
                 candidates,
                 fulfillment_errors,
                 span,
+                kind,
             )),
 
             &[applicable_candidate] => Ok(applicable_candidate),
 
-            &[_, ..] => Err(self.complain_about_ambiguous_inherent_assoc_ty(
+            &[_, ..] => Err(self.complain_about_ambiguous_inherent_assoc(
                 name,
                 applicable_candidates.into_iter().map(|(_, (candidate, _))| candidate).collect(),
                 span,
@@ -2254,6 +2305,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 debug!(?qself, ?segment);
                 let ty = self.lower_ty(qself);
                 self.lower_const_assoc_path(hir_id, const_arg.span(), ty, qself, segment)
+                    .unwrap_or_else(|guar| Const::new_error(tcx, guar))
             }
             hir::ConstArgKind::Path(qpath @ hir::QPath::LangItem(..)) => {
                 ty::Const::new_error_with_message(
@@ -2379,7 +2431,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         qself_ty: Ty<'tcx>,
         qself: &'tcx hir::Ty<'tcx>,
         assoc_segment: &'tcx hir::PathSegment<'tcx>,
-    ) -> Const<'tcx> {
+    ) -> Result<Const<'tcx>, ErrorGuaranteed> {
         debug!(%qself_ty, ?assoc_segment.ident);
         let tcx = self.tcx();
 
@@ -2400,42 +2452,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         GenericsArgsErrExtend::EnumVariant { qself, assoc_segment, adt_def },
                     );
                     let uv = ty::UnevaluatedConst::new(variant_def.def_id, ty::List::empty());
-                    return Const::new_unevaluated(tcx, uv);
+                    return Ok(Const::new_unevaluated(tcx, uv));
                 }
             }
 
             // FIXME(mgca): Support self types other than ADTs.
-            let candidates = tcx
-                .inherent_impls(adt_def.did())
-                .iter()
-                .filter_map(|&impl_| {
-                    self.probe_assoc_item(
-                        assoc_ident,
-                        ty::AssocKind::Const,
-                        hir_ref_id,
-                        span,
-                        impl_,
-                    )
-                    .map(|assoc| (impl_, assoc))
-                })
-                .collect::<Vec<_>>();
-            match &candidates[..] {
-                [] => {}
-                &[(impl_, assoc)] => {
-                    // FIXME(mgca): adapted from temporary inherent assoc ty code that may be incorrect
-                    let parent_args = ty::GenericArgs::identity_for_item(tcx, impl_);
-                    let args = self.lower_generic_args_of_assoc_item(
-                        span,
-                        assoc.def_id,
-                        assoc_segment,
-                        parent_args,
-                    );
-                    let uv = ty::UnevaluatedConst::new(assoc.def_id, args);
-                    return Const::new_unevaluated(tcx, uv);
-                }
-                [..] => {
-                    return Const::new_error_with_message(tcx, span, "ambiguous assoc const path");
-                }
+            if let Some((ct, _)) = self.probe_inherent_assoc_const(
+                assoc_segment,
+                adt_def.did(),
+                qself_ty,
+                hir_ref_id,
+                span,
+            )? {
+                return Ok(ct);
             }
         }
 
@@ -2484,21 +2513,21 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         };
         let bound = match bound_result {
             Ok(b) => b,
-            Err(reported) => return Const::new_error(tcx, reported),
+            Err(reported) => return Err(reported),
         };
 
         let trait_did = bound.def_id();
         let assoc_const = self
             .probe_assoc_item(assoc_ident, ty::AssocKind::Const, hir_ref_id, span, trait_did)
             .expect("failed to find associated const");
         if assoc_const.has_type_const_attr(tcx) {
-            self.lower_assoc_const(span, assoc_const.def_id, assoc_segment, bound)
+            Ok(self.lower_assoc_const(span, assoc_const.def_id, assoc_segment, bound))
         } else {
             let mut err = tcx
                 .dcx()
                 .struct_span_err(span, "use of trait associated const without `#[type_const]`");
             err.note("the declaration in the trait must be marked with `#[type_const]`");
-            Const::new_error(tcx, err.emit())
+            Err(err.emit())
         }
     }
 

tests/ui/associated-inherent-types/issue-109299-1.stderr

@@ -2,7 +2,7 @@ error[E0220]: associated type `Cursor` not found for `Lexer<T>` in the current s
   --> $DIR/issue-109299-1.rs:10:40
    |
 LL | struct Lexer<T>(T);
-   | --------------- associated item `Cursor` not found for this struct
+   | --------------- associated type `Cursor` not found for this struct
 ...
 LL | type X = impl for<T> Fn() -> Lexer<T>::Cursor;
    |                                        ^^^^^^ associated item not found in `Lexer<T>`
@@ -14,7 +14,7 @@ error[E0220]: associated type `Cursor` not found for `Lexer<T>` in the current s
   --> $DIR/issue-109299-1.rs:10:40
    |
 LL | struct Lexer<T>(T);
-   | --------------- associated item `Cursor` not found for this struct
+   | --------------- associated type `Cursor` not found for this struct
 ...
 LL | type X = impl for<T> Fn() -> Lexer<T>::Cursor;
    |                                        ^^^^^^ associated item not found in `Lexer<T>`

tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.shadowed.stderr

@@ -2,7 +2,7 @@ error[E0220]: associated type `Pr` not found for `S<bool>` in the current scope
   --> $DIR/not-found-self-type-differs-shadowing-trait-item.rs:28:23
    |
 LL | struct S<T>(T);
-   | ----------- associated item `Pr` not found for this struct
+   | ----------- associated type `Pr` not found for this struct
 ...
 LL |     let _: S::<bool>::Pr = ();
    |                       ^^ associated item not found in `S<bool>`

tests/ui/associated-inherent-types/not-found-self-type-differs.stderr

@@ -2,7 +2,7 @@ error[E0220]: associated type `Proj` not found for `Family<Option<()>>` in the c
   --> $DIR/not-found-self-type-differs.rs:15:32
    |
 LL | struct Family<T>(T);
-   | ---------------- associated item `Proj` not found for this struct
+   | ---------------- associated type `Proj` not found for this struct
 ...
 LL |     let _: Family<Option<()>>::Proj;
    |                                ^^^^ associated item not found in `Family<Option<()>>`
@@ -15,7 +15,7 @@ error[E0220]: associated type `Proj` not found for `Family<PathBuf>` in the curr
   --> $DIR/not-found-self-type-differs.rs:16:40
    |
 LL | struct Family<T>(T);
-   | ---------------- associated item `Proj` not found for this struct
+   | ---------------- associated type `Proj` not found for this struct
 ...
 LL |     let _: Family<std::path::PathBuf>::Proj = ();
    |                                        ^^^^ associated item not found in `Family<PathBuf>`

tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-0.stderr

@@ -2,7 +2,7 @@ error: the associated type `Yield` exists for `Container<[u8]>`, but its trait b
   --> $DIR/not-found-unsatisfied-bounds-0.rs:19:29
    |
 LL | struct Container<T: ?Sized>(T);
-   | --------------------------- associated item `Yield` not found for this struct
+   | --------------------------- associated type `Yield` not found for this struct
 ...
 LL |     let _: Container<[u8]>::Yield = 1;
    |                             ^^^^^ associated type cannot be referenced on `Container<[u8]>` due to unsatisfied trait bounds
@@ -14,7 +14,7 @@ error: the associated type `Combination` exists for `Duple<String, Rc<str>>`, bu
   --> $DIR/not-found-unsatisfied-bounds-0.rs:20:45
    |
 LL | struct Duple<T, U>(T, U);
-   | ------------------ associated item `Combination` not found for this struct
+   | ------------------ associated type `Combination` not found for this struct
 ...
 LL |     let _: Duple<String, std::rc::Rc<str>>::Combination;
    |                                             ^^^^^^^^^^^ associated type cannot be referenced on `Duple<String, Rc<str>>` due to unsatisfied trait bounds

tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-1.stderr

@@ -5,7 +5,7 @@ LL |     let _: Container<T>::Proj = String::new();
    |                          ^^^^ associated type cannot be referenced on `Container<T>` due to unsatisfied trait bounds
 ...
 LL | struct Container<T>(T);
-   | ------------------- associated item `Proj` not found for this struct
+   | ------------------- associated type `Proj` not found for this struct
    |
    = note: the following trait bounds were not satisfied:
            `T: Clone`

tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-in-multiple-impls.stderr

@@ -2,7 +2,7 @@ error: the associated type `X` exists for `S<Featureless, Featureless>`, but its
   --> $DIR/not-found-unsatisfied-bounds-in-multiple-impls.rs:19:43
    |
 LL | struct S<A, B>(A, B);
-   | -------------- associated item `X` not found for this struct
+   | -------------- associated type `X` not found for this struct
 LL | struct Featureless;
    | ------------------ doesn't satisfy `Featureless: One` or `Featureless: Two`
 ...