Relax overly strict mgca requirements

Author: camelid

compiler/rustc_ast/src/ast.rs

@@ -123,6 +123,13 @@ impl Path {
     pub fn is_global(&self) -> bool {
         self.segments.first().is_some_and(|segment| segment.ident.name == kw::PathRoot)
     }
+
+    // FIXME: add docs
+    #[tracing::instrument(level = "debug", ret)]
+    pub fn is_potential_trivial_const_arg(&self, allow_mgca_arg: bool) -> bool {
+        allow_mgca_arg
+            || self.segments.len() == 1 && self.segments.iter().all(|seg| seg.args.is_none())
+    }
 }
 
 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
@@ -1202,6 +1209,29 @@ 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, allow_mgca_arg: bool) -> bool {
+        let this = self.maybe_unwrap_block();
+        if allow_mgca_arg {
+            matches!(this.kind, ExprKind::Path(..))
+        } else {
+            if let ExprKind::Path(None, path) = &this.kind
+                && path.is_potential_trivial_const_arg(allow_mgca_arg)
+            {
+                true
+            } else {
+                false
+            }
+        }
+    }
+
     /// Returns an expression with (when possible) *one* outter brace removed
     pub fn maybe_unwrap_block(&self) -> &Expr {
         if let ExprKind::Block(block, None) = &self.kind

compiler/rustc_ast/src/lib.rs

@@ -26,7 +26,6 @@ pub mod util {
     pub mod case;
     pub mod classify;
     pub mod comments;
-    mod const_args;
     pub mod literal;
     pub mod parser;
     pub mod unicode;

compiler/rustc_ast/src/util/const_args.rs

@@ -1095,7 +1095,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(&None, self.tcx.features().min_generic_const_args())
+                                && path.is_potential_trivial_const_arg(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(&None, tcx.features().min_generic_const_args())
+            .is_potential_trivial_const_arg(tcx.features().min_generic_const_args())
             && (tcx.features().min_generic_const_args()
                 || matches!(res, Res::Def(DefKind::ConstParam, _)))
         {
@@ -2138,7 +2138,7 @@ 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(qself, path) = &expr.kind
-            && path.is_potential_trivial_const_arg(qself, tcx.features().min_generic_const_args())
+            && 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_ast_lowering/src/lib.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(&None, false)
+                    && path.is_potential_trivial_const_arg(false)
                 {
                     let mut check_ns = |ns| {
                         self.maybe_resolve_ident_in_lexical_scope(path.segments[0].ident, ns)