Allow const paths with generics/qself under mgca

Author: camelid

compiler/rustc_ast/src/ast.rs

@@ -123,12 +123,6 @@ impl Path {
     pub fn is_global(&self) -> bool {
         self.segments.first().is_some_and(|segment| segment.ident.name == kw::PathRoot)
     }
-
-    /// 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())
-    }
 }
 
 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
@@ -1208,26 +1202,6 @@ 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_multi_segment: bool) -> bool {
-        let this = self.maybe_unwrap_block();
-
-        if let ExprKind::Path(None, path) = &this.kind
-            && path.is_potential_trivial_const_arg(allow_multi_segment)
-        {
-            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,6 +26,7 @@ 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

@@ -0,0 +1,62 @@
+use std::ops::ControlFlow;
+
+use crate::visit::{Visitor, walk_anon_const};
+use crate::{DUMMY_NODE_ID, Expr, ExprKind, Path};
+
+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 {
+            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)
+            {
+                true
+            } else {
+                false
+            }
+        }
+    }
+}
+
+impl Path {
+    // FIXME: add docs
+    #[tracing::instrument(level = "debug", ret)]
+    pub fn is_potential_trivial_const_arg(&self, allow_mgca_arg: bool) -> bool {
+        if allow_mgca_arg {
+            MGCATrivialConstArgVisitor::new().visit_path(self, DUMMY_NODE_ID).is_continue()
+        } else {
+            self.segments.len() == 1 && self.segments.iter().all(|seg| seg.args.is_none())
+        }
+    }
+}
+
+pub(crate) struct MGCATrivialConstArgVisitor {}
+
+impl MGCATrivialConstArgVisitor {
+    pub(crate) fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<'ast> Visitor<'ast> for MGCATrivialConstArgVisitor {
+    type Result = ControlFlow<()>;
+
+    fn visit_anon_const(&mut self, c: &'ast crate::AnonConst) -> Self::Result {
+        let expr = c.value.maybe_unwrap_block();
+        match &expr.kind {
+            ExprKind::Path(_, _) => {}
+            _ => return ControlFlow::Break(()),
+        }
+        walk_anon_const(self, c)
+    }
+}

tests/ui/const-generics/mgca/assoc-const.rs

@@ -3,12 +3,12 @@
 #![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 
-pub trait Tr {
+pub trait Tr<X> {
     #[type_const]
     const SIZE: usize;
 }
 
-fn mk_array<T: Tr>(_x: T) -> [(); T::SIZE] {
+fn mk_array<T: Tr<bool>>(_x: T) -> [(); <T as Tr<bool>>::SIZE] {
     [(); T::SIZE]
 }