Start lowering multi-segment const paths as ConstArgKind::Path

Author: camelid

compiler/rustc_ast/src/ast.rs

@@ -124,10 +124,10 @@ impl Path {
         self.segments.first().is_some_and(|segment| segment.ident.name == kw::PathRoot)
     }
 
-    /// If this path is a single identifier with no arguments, does not ensure
-    /// that the path resolves to a const param, the caller should check this.
-    pub fn is_potential_trivial_const_arg(&self) -> bool {
-        matches!(self.segments[..], [PathSegment { args: None, .. }])
+    /// Does this path have no arguments, and if allow_multi_segment is false, is it a single segment?
+    pub fn is_potential_trivial_const_arg(&self, allow_multi_segment: bool) -> bool {
+        (allow_multi_segment || self.segments.len() == 1)
+            && self.segments.iter().all(|seg| seg.args.is_none())
     }
 }
 
@@ -1208,18 +1208,19 @@ pub struct Expr {
 }
 
 impl Expr {
+    // FIXME: update docs
     /// Could this expr be either `N`, or `{ N }`, where `N` is a const parameter.
     ///
     /// If this is not the case, name resolution does not resolve `N` when using
     /// `min_const_generics` as more complex expressions are not supported.
     ///
     /// Does not ensure that the path resolves to a const param, the caller should check this.
     /// This also does not consider macros, so it's only correct after macro-expansion.
-    pub fn is_potential_trivial_const_arg(&self) -> bool {
+    pub fn is_potential_trivial_const_arg(&self, allow_multi_segment: bool) -> bool {
         let this = self.maybe_unwrap_block();
 
         if let ExprKind::Path(None, path) = &this.kind
-            && path.is_potential_trivial_const_arg()
+            && path.is_potential_trivial_const_arg(allow_multi_segment)
         {
             true
         } else {

compiler/rustc_ast_lowering/src/lib.rs

@@ -1094,7 +1094,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             .and_then(|partial_res| partial_res.full_res())
                         {
                             if !res.matches_ns(Namespace::TypeNS)
-                                && path.is_potential_trivial_const_arg()
+                            // FIXME: should this only allow single-segment paths?
+                                && path.is_potential_trivial_const_arg(self.tcx.features().min_generic_const_args())
                             {
                                 debug!(
                                     "lower_generic_arg: Lowering type argument as const argument: {:?}",
@@ -2061,8 +2062,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> &'hir hir::ConstArg<'hir> {
         let tcx = self.tcx;
 
-        // FIXME(min_generic_const_args): we only allow one-segment const paths for now
-        let ct_kind = if path.is_potential_trivial_const_arg()
+        let ct_kind = if path
+            .is_potential_trivial_const_arg(tcx.features().min_generic_const_args())
             && (tcx.features().min_generic_const_args()
                 || matches!(res, Res::Def(DefKind::ConstParam, _)))
         {
@@ -2136,9 +2137,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
         let maybe_res =
             self.resolver.get_partial_res(expr.id).and_then(|partial_res| partial_res.full_res());
-        // FIXME(min_generic_const_args): we only allow one-segment const paths for now
         if let ExprKind::Path(None, path) = &expr.kind
-            && path.is_potential_trivial_const_arg()
+            && path.is_potential_trivial_const_arg(tcx.features().min_generic_const_args())
             && (tcx.features().min_generic_const_args()
                 || matches!(maybe_res, Some(Res::Def(DefKind::ConstParam, _))))
         {

compiler/rustc_builtin_macros/src/format.rs

@@ -190,7 +190,8 @@ fn make_format_args(
                                 && let [stmt] = block.stmts.as_slice()
                                 && let StmtKind::Expr(expr) = &stmt.kind
                                 && let ExprKind::Path(None, path) = &expr.kind
-                                && path.is_potential_trivial_const_arg()
+                                && path.segments.len() == 1
+                                && path.segments[0].args.is_none()
                             {
                                 err.multipart_suggestion(
                                     "quote your inlined format argument to use as string literal",

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2167,11 +2167,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself));
                 self.lower_const_path_resolved(opt_self_ty, path, hir_id)
             }
-            hir::ConstArgKind::Path(qpath) => ty::Const::new_error_with_message(
-                tcx,
-                qpath.span(),
-                format!("Const::lower_const_arg: invalid qpath {qpath:?}"),
-            ),
+            hir::ConstArgKind::Path(hir::QPath::TypeRelative(qself, segment)) => {
+                debug!(?qself, ?segment);
+                let ty = self.lower_ty(qself);
+                self.lower_const_assoc_path(hir_id, const_arg.span(), ty, qself, segment)
+            }
+            hir::ConstArgKind::Path(qpath @ hir::QPath::LangItem(..)) => {
+                ty::Const::new_error_with_message(
+                    tcx,
+                    qpath.span(),
+                    format!("Const::lower_const_arg: invalid qpath {qpath:?}"),
+                )
+            }
             hir::ConstArgKind::Anon(anon) => self.lower_anon_const(anon),
             hir::ConstArgKind::Infer(span, ()) => self.ct_infer(None, span),
         }
@@ -2264,8 +2271,134 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
-    /// Literals and const generic parameters are eagerly converted to a constant, everything else
-    /// becomes `Unevaluated`.
+    #[instrument(level = "debug", skip(self))]
+    pub fn lower_const_assoc_path(
+        &self,
+        hir_ref_id: HirId,
+        span: Span,
+        qself_ty: Ty<'tcx>,
+        qself: &'tcx hir::Ty<'tcx>,
+        assoc_segment: &'tcx hir::PathSegment<'tcx>,
+    ) -> Const<'tcx> {
+        debug!(%qself_ty, ?assoc_segment.ident);
+        let tcx = self.tcx();
+
+        let assoc_ident = assoc_segment.ident;
+
+        // Check if we have an enum variant or an inherent associated const.
+        // FIXME(min_generic_const_args): handle assoc fns once we support those
+        if let Some(adt_def) = self.probe_adt(span, qself_ty) {
+            if adt_def.is_enum() {
+                let variant_def = adt_def
+                    .variants()
+                    .iter()
+                    .find(|vd| tcx.hygienic_eq(assoc_ident, vd.ident(tcx), adt_def.did()));
+                if let Some(variant_def) = variant_def {
+                    tcx.check_stability(variant_def.def_id, Some(hir_ref_id), span, None);
+                    let _ = self.prohibit_generic_args(
+                        slice::from_ref(assoc_segment).iter(),
+                        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);
+                }
+            }
+
+            // FIXME(min_generic_const_args): 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_,
+                    )
+                })
+                .collect::<Vec<_>>();
+            match &candidates[..] {
+                [] => {}
+                [assoc] => return self.lower_assoc_const(span, assoc.def_id, assoc_segment),
+                [..] => {
+                    return Const::new_error_with_message(tcx, span, "ambiguous assoc const path");
+                }
+            }
+        }
+
+        let qself_res = if let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = &qself.kind {
+            path.res
+        } else {
+            Res::Err
+        };
+
+        // Find the type of the associated item, and the trait where the associated
+        // item is declared.
+        let bound_result = match (qself_ty.kind(), qself_res) {
+            (_, Res::SelfTyAlias { alias_to: impl_def_id, is_trait_impl: true, .. }) => {
+                // `Self` in an impl of a trait -- we have a concrete self type and a
+                // trait reference.
+                let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) else {
+                    // A cycle error occurred, most likely.
+                    self.dcx().span_bug(span, "expected cycle error");
+                };
+
+                self.probe_single_bound_for_assoc_item(
+                    || {
+                        traits::supertraits(
+                            tcx,
+                            ty::Binder::dummy(trait_ref.instantiate_identity()),
+                        )
+                    },
+                    AssocItemQSelf::SelfTyAlias,
+                    ty::AssocKind::Const,
+                    assoc_ident,
+                    span,
+                    None,
+                )
+            }
+            (
+                &ty::Param(_),
+                Res::SelfTyParam { trait_: param_did } | Res::Def(DefKind::TyParam, param_did),
+            ) => self.probe_single_ty_param_bound_for_assoc_item(
+                param_did.expect_local(),
+                qself.span,
+                ty::AssocKind::Const,
+                assoc_ident,
+                span,
+            ),
+            _ => panic!("handle errors here"), // TODO: do this
+        };
+        let bound = match bound_result {
+            Ok(b) => b,
+            Err(reported) => return Const::new_error(tcx, 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");
+        self.lower_assoc_const(span, assoc_const.def_id, assoc_segment)
+    }
+
+    fn lower_assoc_const(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &hir::PathSegment<'tcx>,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+        // FIXME: this is not necessarily correct.
+        // adapted from other code that also had a fixme about it being temporary.
+        let parent_args = ty::GenericArgs::identity_for_item(tcx, tcx.parent(item_def_id));
+        let args =
+            self.lower_generic_args_of_assoc_item(span, item_def_id, item_segment, parent_args);
+        let uv = ty::UnevaluatedConst::new(item_def_id, args);
+        Const::new_unevaluated(tcx, uv)
+    }
+
+    /// Literals are eagerly converted to a constant, everything else becomes `Unevaluated`.
     #[instrument(skip(self), level = "debug")]
     fn lower_anon_const(&self, anon: &AnonConst) -> Const<'tcx> {
         let tcx = self.tcx();

compiler/rustc_resolve/src/late.rs

@@ -1202,7 +1202,7 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
                 if let TyKind::Path(None, ref path) = ty.kind
                     // We cannot disambiguate multi-segment paths right now as that requires type
                     // checking.
-                    && path.is_potential_trivial_const_arg()
+                    && path.is_potential_trivial_const_arg(false)
                 {
                     let mut check_ns = |ns| {
                         self.maybe_resolve_ident_in_lexical_scope(path.segments[0].ident, ns)
@@ -4630,11 +4630,12 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             constant, anon_const_kind
         );
 
-        self.resolve_anon_const_manual(
-            constant.value.is_potential_trivial_const_arg(),
-            anon_const_kind,
-            |this| this.resolve_expr(&constant.value, None),
-        )
+        let is_trivial_const_arg = constant
+            .value
+            .is_potential_trivial_const_arg(self.r.tcx.features().min_generic_const_args());
+        self.resolve_anon_const_manual(is_trivial_const_arg, anon_const_kind, |this| {
+            this.resolve_expr(&constant.value, None)
+        })
     }
 
     /// There are a few places that we need to resolve an anon const but we did not parse an
@@ -4794,8 +4795,11 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     // Constant arguments need to be treated as AnonConst since
                     // that is how they will be later lowered to HIR.
                     if const_args.contains(&idx) {
+                        let is_trivial_const_arg = argument.is_potential_trivial_const_arg(
+                            self.r.tcx.features().min_generic_const_args(),
+                        );
                         self.resolve_anon_const_manual(
-                            argument.is_potential_trivial_const_arg(),
+                            is_trivial_const_arg,
                             AnonConstKind::ConstArg(IsRepeatExpr::No),
                             |this| this.resolve_expr(argument, None),
                         );