Clean up (most of) the refactoring

Author: camelid

compiler/rustc_hir_analysis/src/collect.rs

@@ -444,47 +444,6 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         self.tcx.at(span).type_param_predicates((self.item_def_id, def_id, assoc_name))
     }
 
-    fn lower_assoc_ty(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        poly_trait_ref: ty::PolyTraitRef<'tcx>,
-    ) -> Ty<'tcx> {
-        match self.lower_assoc_shared(
-            span,
-            item_def_id,
-            item_segment,
-            poly_trait_ref,
-            ty::AssocKind::Type,
-        ) {
-            Ok((def_id, args)) => Ty::new_projection_from_args(self.tcx(), def_id, args),
-            Err(witness) => Ty::new_error(self.tcx(), witness),
-        }
-    }
-
-    fn lower_assoc_const(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        poly_trait_ref: ty::PolyTraitRef<'tcx>,
-    ) -> Const<'tcx> {
-        match self.lower_assoc_shared(
-            span,
-            item_def_id,
-            item_segment,
-            poly_trait_ref,
-            ty::AssocKind::Const,
-        ) {
-            Ok((def_id, args)) => {
-                let uv = ty::UnevaluatedConst::new(def_id, args);
-                Const::new_unevaluated(self.tcx(), uv)
-            }
-            Err(witness) => Const::new_error(self.tcx(), witness),
-        }
-    }
-
     fn lower_assoc_shared(
         &self,
         span: Span,

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -153,7 +153,7 @@ pub trait HirTyLowerer<'tcx> {
         assoc_name: Ident,
     ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]>;
 
-    /// Lower an associated type (from a trait) to a projection.
+    /// Lower an associated type/const (from a trait) to a projection.
     ///
     /// This method has to be defined by the concrete lowering context because
     /// dealing with higher-ranked trait references depends on its capabilities:
@@ -165,26 +165,6 @@ pub trait HirTyLowerer<'tcx> {
     ///
     /// The canonical example of this is associated type `T::P` where `T` is a type
     /// param constrained by `T: for<'a> Trait<'a>` and where `Trait` defines `P`.
-    fn lower_assoc_ty(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        poly_trait_ref: ty::PolyTraitRef<'tcx>,
-    ) -> Ty<'tcx>;
-
-    /// Lower an associated constant (from a trait) to a [`ty::Const`].
-    fn lower_assoc_const(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        poly_trait_ref: ty::PolyTraitRef<'tcx>,
-    ) -> Const<'tcx>;
-
-    /// Helper function; use [`Self::lower_assoc_ty`] or [`Self::lower_assoc_const`] instead.
-    ///
-    /// The logic for lowering associated items that is the same between types and consts.
     fn lower_assoc_shared(
         &self,
         span: Span,
@@ -298,9 +278,8 @@ impl LowerAssocMode {
 
 #[derive(Debug, Clone, Copy)]
 enum LoweredAssoc<'tcx> {
-    Type(Ty<'tcx>, DefId),
+    Term(DefId, GenericArgsRef<'tcx>),
     Variant { adt: Ty<'tcx>, variant_did: DefId },
-    Const(Const<'tcx>),
 }
 
 /// New-typed boolean indicating whether explicit late-bound lifetimes
@@ -1184,6 +1163,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         assoc_segment: &'tcx hir::PathSegment<'tcx>,
         permit_variants: bool,
     ) -> Result<(Ty<'tcx>, DefKind, DefId), ErrorGuaranteed> {
+        let tcx = self.tcx();
         match self.lower_assoc_path_shared(
             hir_ref_id,
             span,
@@ -1192,9 +1172,20 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             assoc_segment,
             LowerAssocMode::Type { permit_variants },
         )? {
-            LoweredAssoc::Type(ty, def_id) => Ok((ty, DefKind::AssocTy, def_id)),
+            LoweredAssoc::Term(def_id, args) => {
+                let assoc = tcx.associated_item(def_id);
+                let ty = if matches!(assoc, ty::AssocItem {
+                    container: ty::AssocItemContainer::Impl,
+                    trait_item_def_id: None,
+                    ..
+                }) {
+                    Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new_from_args(tcx, def_id, args))
+                } else {
+                    Ty::new_projection_from_args(tcx, def_id, args)
+                };
+                Ok((ty, DefKind::AssocTy, def_id))
+            }
             LoweredAssoc::Variant { adt, variant_did } => Ok((adt, DefKind::Variant, variant_did)),
-            LoweredAssoc::Const(_) => unreachable!("lowered assoc type to const somehow"),
         }
     }
 
@@ -1207,21 +1198,29 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         qself: &'tcx hir::Ty<'tcx>,
         assoc_segment: &'tcx hir::PathSegment<'tcx>,
     ) -> Result<Const<'tcx>, ErrorGuaranteed> {
-        match self.lower_assoc_path_shared(
+        let tcx = self.tcx();
+        let (def_id, args) = match self.lower_assoc_path_shared(
             hir_ref_id,
             span,
             qself_ty,
             qself,
             assoc_segment,
             LowerAssocMode::Const,
         )? {
-            LoweredAssoc::Type(..) => unreachable!("lowered assoc const to type somehow"),
-            LoweredAssoc::Variant { adt: _, variant_did } => {
-                let uv = ty::UnevaluatedConst::new(variant_did, ty::List::empty());
-                Ok(Const::new_unevaluated(self.tcx(), uv))
+            LoweredAssoc::Term(def_id, args) => {
+                if !tcx.associated_item(def_id).is_type_const_capable(tcx) {
+                    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]`");
+                    return Err(err.emit());
+                }
+                (def_id, args)
             }
-            LoweredAssoc::Const(ct) => Ok(ct),
-        }
+            LoweredAssoc::Variant { adt: _, variant_did } => (variant_did, ty::List::empty()),
+        };
+        Ok(Const::new_unevaluated(tcx, ty::UnevaluatedConst::new(def_id, args)))
     }
 
     #[instrument(level = "debug", skip_all, ret)]
@@ -1264,31 +1263,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 }
             }
 
-            match mode {
-                LowerAssocMode::Type { .. } => {
-                    // FIXME(inherent_associated_types, #106719): Support self types other than ADTs.
-                    if let Some((ty, did)) = self.probe_inherent_assoc_ty(
-                        assoc_segment,
-                        adt_def.did(),
-                        qself_ty,
-                        hir_ref_id,
-                        span,
-                    )? {
-                        return Ok(LoweredAssoc::Type(ty, did));
-                    }
-                }
-                LowerAssocMode::Const => {
-                    // FIXME(mgca): Support self types other than ADTs.
-                    if let Some((ct, _)) = self.probe_inherent_assoc_const(
-                        assoc_segment,
-                        adt_def.did(),
-                        qself_ty,
-                        hir_ref_id,
-                        span,
-                    )? {
-                        return Ok(LoweredAssoc::Const(ct));
-                    }
-                }
+            // FIXME(inherent_associated_types, #106719): Support self types other than ADTs.
+            if let Some((did, args)) = self.probe_inherent_assoc_shared(
+                assoc_segment,
+                adt_def.did(),
+                qself_ty,
+                hir_ref_id,
+                span,
+                mode.kind(),
+            )? {
+                return Ok(LoweredAssoc::Term(did, args));
             }
         }
 
@@ -1452,26 +1436,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let assoc_item = self
             .probe_assoc_item(assoc_ident, mode.kind(), hir_ref_id, span, trait_did)
             .expect("failed to find associated item");
-        let result = match mode {
-            LowerAssocMode::Type { .. } => {
-                let assoc_ty = self.lower_assoc_ty(span, assoc_item.def_id, assoc_segment, bound);
-                LoweredAssoc::Type(assoc_ty, assoc_item.def_id)
-            }
-            LowerAssocMode::Const => {
-                if assoc_item.has_type_const_attr(tcx) {
-                    let assoc_ct =
-                        self.lower_assoc_const(span, assoc_item.def_id, assoc_segment, bound);
-                    LoweredAssoc::Const(assoc_ct)
-                } 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]`");
-                    return Err(err.emit());
-                }
-            }
-        };
+        let (def_id, args) =
+            self.lower_assoc_shared(span, assoc_item.def_id, assoc_segment, bound, mode.kind())?;
+        let result = LoweredAssoc::Term(def_id, args);
 
         if let Some(variant_def_id) = variant_resolution {
             tcx.node_span_lint(AMBIGUOUS_ASSOCIATED_ITEMS, hir_ref_id, span, |lint| {
@@ -1500,14 +1467,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         Ok(result)
     }
 
-    fn probe_inherent_assoc_ty(
+    fn probe_inherent_assoc_shared(
         &self,
         segment: &hir::PathSegment<'tcx>,
         adt_did: DefId,
         self_ty: Ty<'tcx>,
         block: HirId,
         span: Span,
-    ) -> Result<Option<(Ty<'tcx>, DefId)>, ErrorGuaranteed> {
+        kind: ty::AssocKind,
+    ) -> Result<Option<(DefId, GenericArgsRef<'tcx>)>, ErrorGuaranteed> {
         let tcx = self.tcx();
 
         // Don't attempt to look up inherent associated types when the feature is not enabled.
@@ -1516,70 +1484,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // selection during HIR ty lowering instead of in the trait solver), IATs can lead to cycle
         // errors (#108491) which mask the feature-gate error, needlessly confusing users
         // who use IATs by accident (#113265).
-        if !tcx.features().inherent_associated_types() {
+        if kind == ty::AssocKind::Type && !tcx.features().inherent_associated_types() {
             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()
             .filter_map(|&impl_| {
-                let (item, scope) =
-                    self.probe_assoc_item_unchecked(name, ty::AssocKind::Type, block, impl_)?;
+                let (item, scope) = self.probe_assoc_item_unchecked(name, kind, block, impl_)?;
                 Some((impl_, (item.def_id, scope)))
             })
             .collect();

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -308,47 +308,6 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         ))
     }
 
-    fn lower_assoc_ty(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        poly_trait_ref: ty::PolyTraitRef<'tcx>,
-    ) -> Ty<'tcx> {
-        match self.lower_assoc_shared(
-            span,
-            item_def_id,
-            item_segment,
-            poly_trait_ref,
-            ty::AssocKind::Type,
-        ) {
-            Ok((def_id, args)) => Ty::new_projection_from_args(self.tcx(), def_id, args),
-            Err(witness) => Ty::new_error(self.tcx(), witness),
-        }
-    }
-
-    fn lower_assoc_const(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        poly_trait_ref: ty::PolyTraitRef<'tcx>,
-    ) -> Const<'tcx> {
-        match self.lower_assoc_shared(
-            span,
-            item_def_id,
-            item_segment,
-            poly_trait_ref,
-            ty::AssocKind::Const,
-        ) {
-            Ok((def_id, args)) => {
-                let uv = ty::UnevaluatedConst::new(def_id, args);
-                Const::new_unevaluated(self.tcx(), uv)
-            }
-            Err(witness) => Const::new_error(self.tcx(), witness),
-        }
-    }
-
     fn lower_assoc_shared(
         &self,
         span: Span,

compiler/rustc_middle/src/ty/assoc.rs

@@ -109,10 +109,11 @@ impl AssocItem {
         self.opt_rpitit_info.is_some()
     }
 
-    /// Does this associated item have the `#[type_const]` attribute,
-    /// or (if it is in a trait impl), does the item from the original
-    /// trait have this attribute?
-    pub fn has_type_const_attr(&self, tcx: TyCtxt<'_>) -> bool {
+    /// Returns true if:
+    /// - This trait associated item has the `#[type_const]` attribute,
+    /// - If it is in a trait impl, the item from the original trait has this attribute, or
+    /// - It is an inherent assoc const.
+    pub fn is_type_const_capable(&self, tcx: TyCtxt<'_>) -> bool {
         if self.kind != ty::AssocKind::Const {
             return false;
         }
@@ -121,7 +122,7 @@ impl AssocItem {
             (AssocItemContainer::Trait, _) => self.def_id,
             (AssocItemContainer::Impl, Some(trait_item_did)) => trait_item_did,
             // Inherent impl but this attr is only applied to trait assoc items.
-            (AssocItemContainer::Impl, None) => return false,
+            (AssocItemContainer::Impl, None) => return true,
         };
         tcx.has_attr(def_id, sym::type_const)
     }