Fix handling of const qpath args

Author: camelid

compiler/rustc_ast/src/util/const_args.rs

@@ -1,7 +1,8 @@
 use std::ops::ControlFlow;
 
+use crate::ptr::P;
 use crate::visit::{Visitor, walk_anon_const};
-use crate::{DUMMY_NODE_ID, Expr, ExprKind, Path};
+use crate::{DUMMY_NODE_ID, Expr, ExprKind, Path, QSelf};
 
 impl Expr {
     // FIXME: update docs
@@ -18,7 +19,7 @@ impl Expr {
             MGCATrivialConstArgVisitor::new().visit_expr(this).is_continue()
         } else {
             if let ExprKind::Path(None, path) = &this.kind
-                && path.is_potential_trivial_const_arg(allow_mgca_arg)
+                && path.is_potential_trivial_const_arg(&None, allow_mgca_arg)
             {
                 true
             } else {
@@ -31,11 +32,19 @@ impl Expr {
 impl Path {
     // FIXME: add docs
     #[tracing::instrument(level = "debug", ret)]
-    pub fn is_potential_trivial_const_arg(&self, allow_mgca_arg: bool) -> bool {
+    pub fn is_potential_trivial_const_arg(
+        &self,
+        qself: &Option<P<QSelf>>,
+        allow_mgca_arg: bool,
+    ) -> bool {
         if allow_mgca_arg {
-            MGCATrivialConstArgVisitor::new().visit_path(self, DUMMY_NODE_ID).is_continue()
+            let mut visitor = MGCATrivialConstArgVisitor::new();
+            visitor.visit_qself(qself).is_continue()
+                && visitor.visit_path(self, DUMMY_NODE_ID).is_continue()
         } else {
-            self.segments.len() == 1 && self.segments.iter().all(|seg| seg.args.is_none())
+            qself.is_none()
+                && self.segments.len() == 1
+                && self.segments.iter().all(|seg| seg.args.is_none())
         }
     }
 }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1102,7 +1102,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         {
                             if !res.matches_ns(Namespace::TypeNS)
                             // FIXME: should this only allow single-segment paths?
-                                && path.is_potential_trivial_const_arg(self.tcx.features().min_generic_const_args())
+                                && path.is_potential_trivial_const_arg(&None, self.tcx.features().min_generic_const_args())
                             {
                                 debug!(
                                     "lower_generic_arg: Lowering type argument as const argument: {:?}",
@@ -2063,7 +2063,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let tcx = self.tcx;
 
         let ct_kind = if path
-            .is_potential_trivial_const_arg(tcx.features().min_generic_const_args())
+            .is_potential_trivial_const_arg(&None, tcx.features().min_generic_const_args())
             && (tcx.features().min_generic_const_args()
                 || matches!(res, Res::Def(DefKind::ConstParam, _)))
         {
@@ -2137,14 +2137,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
         let maybe_res =
             self.resolver.get_partial_res(expr.id).and_then(|partial_res| partial_res.full_res());
-        if let ExprKind::Path(None, path) = &expr.kind
-            && path.is_potential_trivial_const_arg(tcx.features().min_generic_const_args())
+        if let ExprKind::Path(qself, path) = &expr.kind
+            && path.is_potential_trivial_const_arg(qself, tcx.features().min_generic_const_args())
             && (tcx.features().min_generic_const_args()
                 || matches!(maybe_res, Some(Res::Def(DefKind::ConstParam, _))))
         {
             let qpath = self.lower_qpath(
                 expr.id,
-                &None,
+                qself,
                 path,
                 ParamMode::Optional,
                 AllowReturnTypeNotation::No,

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -1623,7 +1623,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
     /// Lower a qualified path to a type.
     #[instrument(level = "debug", skip_all)]
-    fn lower_qpath(
+    fn lower_qpath_ty(
         &self,
         span: Span,
         opt_self_ty: Option<Ty<'tcx>>,
@@ -1641,14 +1641,64 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         };
         debug!(?self_ty);
 
+        let (item_def_id, item_args) = self.lower_qpath_shared(
+            span,
+            self_ty,
+            trait_def_id,
+            item_def_id,
+            trait_segment,
+            item_segment,
+        );
+        Ty::new_projection_from_args(tcx, item_def_id, item_args)
+    }
+
+    /// Lower a qualified path to a const.
+    #[instrument(level = "debug", skip_all)]
+    fn lower_qpath_const(
+        &self,
+        span: Span,
+        self_ty: Ty<'tcx>,
+        item_def_id: DefId,
+        trait_segment: &hir::PathSegment<'tcx>,
+        item_segment: &hir::PathSegment<'tcx>,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+
+        let trait_def_id = tcx.parent(item_def_id);
+        debug!(?trait_def_id);
+
+        debug!(?self_ty);
+
+        let (item_def_id, item_args) = self.lower_qpath_shared(
+            span,
+            self_ty,
+            trait_def_id,
+            item_def_id,
+            trait_segment,
+            item_segment,
+        );
+        let uv = ty::UnevaluatedConst::new(item_def_id, item_args);
+        Const::new_unevaluated(tcx, uv)
+    }
+
+    #[instrument(level = "debug", skip_all)]
+    fn lower_qpath_shared(
+        &self,
+        span: Span,
+        self_ty: Ty<'tcx>,
+        trait_def_id: DefId,
+        item_def_id: DefId,
+        trait_segment: &hir::PathSegment<'tcx>,
+        item_segment: &hir::PathSegment<'tcx>,
+    ) -> (DefId, GenericArgsRef<'tcx>) {
         let trait_ref =
             self.lower_mono_trait_ref(span, trait_def_id, self_ty, trait_segment, false);
         debug!(?trait_ref);
 
         let item_args =
             self.lower_generic_args_of_assoc_item(span, item_def_id, item_segment, trait_ref.args);
 
-        Ty::new_projection_from_args(tcx, item_def_id, item_args)
+        (item_def_id, item_args)
     }
 
     fn error_missing_qpath_self_ty(
@@ -1999,7 +2049,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     path.segments[..path.segments.len() - 2].iter(),
                     GenericsArgsErrExtend::None,
                 );
-                self.lower_qpath(
+                self.lower_qpath_ty(
                     span,
                     opt_self_ty,
                     def_id,
@@ -2164,6 +2214,22 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
                 ty::Const::new_unevaluated(tcx, ty::UnevaluatedConst::new(did, args))
             }
+            Res::Def(DefKind::AssocConst, did) => {
+                debug_assert!(path.segments.len() >= 2);
+                let _ = self.prohibit_generic_args(
+                    path.segments[..path.segments.len() - 2].iter(),
+                    GenericsArgsErrExtend::None,
+                );
+                // FIXME(mgca): maybe needs proper error reported
+                let Some(self_ty) = opt_self_ty else { span_bug!(span, "{path:?}") };
+                self.lower_qpath_const(
+                    span,
+                    self_ty,
+                    did,
+                    &path.segments[path.segments.len() - 2],
+                    path.segments.last().unwrap(),
+                )
+            }
             Res::Def(DefKind::Static { .. }, _) => {
                 span_bug!(span, "use of bare `static` ConstArgKind::Path's not yet supported")
             }
@@ -2176,7 +2242,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
             // Exhaustive match to be clear about what exactly we're considering to be
             // an invalid Res for a const path.
-            Res::Def(
+            res @ (Res::Def(
                 DefKind::Mod
                 | DefKind::Enum
                 | DefKind::Variant
@@ -2190,7 +2256,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 | DefKind::Union
                 | DefKind::Trait
                 | DefKind::ForeignTy
-                | DefKind::AssocConst
                 | DefKind::TyParam
                 | DefKind::Macro(_)
                 | DefKind::LifetimeParam
@@ -2213,7 +2278,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             | Res::Local(_)
             | Res::ToolMod
             | Res::NonMacroAttr(_)
-            | Res::Err => Const::new_error_with_message(tcx, span, "invalid Res for const path"),
+            | Res::Err) => Const::new_error_with_message(
+                tcx,
+                span,
+                format!("invalid Res {res:?} for const path"),
+            ),
         }
     }
 

compiler/rustc_resolve/src/late.rs

@@ -1181,7 +1181,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(false)
+                    && path.is_potential_trivial_const_arg(&None, false)
                 {
                     let mut check_ns = |ns| {
                         self.maybe_resolve_ident_in_lexical_scope(path.segments[0].ident, ns)