reviews

Author: BoxyUwU

compiler/rustc_ast_lowering/src/lib.rs

@@ -2413,17 +2413,22 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
         let tcx = self.tcx;
 
+        // We cannot change parsing depending on feature gates available,
+        // we can only require feature gates to be active as a delayed check.
+        // Thus we just parse anon consts generally and make the real decision
+        // making in ast lowering.
+        // FIXME(min_generic_const_args): revisit once stable
         if tcx.features().min_generic_const_args() {
-            match anon.mgca_disambiguation {
+            return match anon.mgca_disambiguation {
                 MgcaDisambiguation::AnonConst => {
                     let lowered_anon = self.lower_anon_const_to_anon_const(anon);
-                    return ConstArg {
+                    ConstArg {
                         hir_id: self.next_id(),
                         kind: hir::ConstArgKind::Anon(lowered_anon),
-                    };
+                    }
                 }
                 MgcaDisambiguation::Direct => {
-                    return self.lower_expr_to_const_arg_direct(&anon.value);
+                    self.lower_expr_to_const_arg_direct(&anon.value)
                 }
             }
         }

compiler/rustc_parse/src/parser/expr.rs

@@ -1621,6 +1621,11 @@ impl<'a> Parser<'a> {
                 let count = if self.token.is_keyword(kw::Const)
                     && self.look_ahead(1, |t| *t == token::OpenBrace)
                 {
+                    // While we could just disambiguate `Direct` from `AnonConst` by
+                    // treating all const block exprs as `AnonConst`, that would
+                    // complicate the DefCollector and likely all other visitors.
+                    // So we strip the const blockiness and just store it as a block
+                    // in the AST with the extra disambiguator on the AnonConst
                     self.parse_expr_anon_const(MgcaDisambiguation::AnonConst)?
                 } else {
                     self.parse_expr_anon_const(MgcaDisambiguation::Direct)?

compiler/rustc_parse/src/parser/path.rs

@@ -874,6 +874,11 @@ impl<'a> Parser<'a> {
             let value = self.parse_expr_block(None, self.token.span, BlockCheckMode::Default)?;
             (value, MgcaDisambiguation::Direct)
         } else if self.token.is_keyword(kw::Const) {
+            // While we could just disambiguate `Direct` from `AnonConst` by
+            // treating all const block exprs as `AnonConst`, that would
+            // complicate the DefCollector and likely all other visitors.
+            // So we strip the const blockiness and just store it as a block
+            // in the AST with the extra disambiguator on the AnonConst
             let value = self.parse_mgca_const_block(true)?;
             (value.value, MgcaDisambiguation::AnonConst)
         } else {

compiler/rustc_parse/src/parser/ty.rs

@@ -661,6 +661,11 @@ impl<'a> Parser<'a> {
             let mut length = if self.token.is_keyword(kw::Const)
                 && self.look_ahead(1, |t| *t == token::OpenBrace)
             {
+                // While we could just disambiguate `Direct` from `AnonConst` by
+                // treating all const block exprs as `AnonConst`, that would
+                // complicate the DefCollector and likely all other visitors.
+                // So we strip the const blockiness and just store it as a block
+                // in the AST with the extra disambiguator on the AnonConst
                 self.parse_mgca_const_block(false)?
             } else {
                 self.parse_expr_anon_const(MgcaDisambiguation::Direct)?