allow implicit anon consts for literals

Author: BoxyUwU

compiler/rustc_ast_lowering/src/lib.rs

@@ -2422,15 +2422,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             return match anon.mgca_disambiguation {
                 MgcaDisambiguation::AnonConst => {
                     let lowered_anon = self.lower_anon_const_to_anon_const(anon);
-                    ConstArg {
-                        hir_id: self.next_id(),
-                        kind: hir::ConstArgKind::Anon(lowered_anon),
-                    }
-                }
-                MgcaDisambiguation::Direct => {
-                    self.lower_expr_to_const_arg_direct(&anon.value)
+                    ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Anon(lowered_anon) }
                 }
-            }
+                MgcaDisambiguation::Direct => self.lower_expr_to_const_arg_direct(&anon.value),
+            };
         }
 
         // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments

compiler/rustc_parse/src/parser/asm.rs

@@ -149,7 +149,7 @@ fn parse_asm_operand<'a>(
         let block = p.parse_block()?;
         ast::InlineAsmOperand::Label { block }
     } else if p.eat_keyword(exp!(Const)) {
-        let anon_const = p.parse_expr_anon_const(MgcaDisambiguation::AnonConst)?;
+        let anon_const = p.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?;
         ast::InlineAsmOperand::Const { anon_const }
     } else if p.eat_keyword(exp!(Sym)) {
         let expr = p.parse_expr()?;

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -31,16 +31,15 @@ use crate::errors::{
     AddParen, AmbiguousPlus, AsyncMoveBlockIn2015, AsyncUseBlockIn2015, AttributeOnParamType,
     AwaitSuggestion, BadQPathStage2, BadTypePlus, BadTypePlusSub, ColonAsSemi,
     ComparisonOperatorsCannotBeChained, ComparisonOperatorsCannotBeChainedSugg,
-    ConstGenericWithoutBraces, ConstGenericWithoutBracesSugg, DocCommentDoesNotDocumentAnything,
-    DocCommentOnParamType, DoubleColonInBound, ExpectedIdentifier, ExpectedSemi, ExpectedSemiSugg,
-    GenericParamsWithoutAngleBrackets, GenericParamsWithoutAngleBracketsSugg,
-    HelpIdentifierStartsWithNumber, HelpUseLatestEdition, InInTypo, IncorrectAwait,
-    IncorrectSemicolon, IncorrectUseOfAwait, IncorrectUseOfUse, PatternMethodParamWithoutBody,
-    QuestionMarkInType, QuestionMarkInTypeSugg, SelfParamNotFirst, StructLiteralBodyWithoutPath,
-    StructLiteralBodyWithoutPathSugg, SuggAddMissingLetStmt, SuggEscapeIdentifier, SuggRemoveComma,
-    TernaryOperator, TernaryOperatorSuggestion, UnexpectedConstInGenericParam,
-    UnexpectedConstParamDeclaration, UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets,
-    UseEqInstead, WrapType,
+    DocCommentDoesNotDocumentAnything, DocCommentOnParamType, DoubleColonInBound,
+    ExpectedIdentifier, ExpectedSemi, ExpectedSemiSugg, GenericParamsWithoutAngleBrackets,
+    GenericParamsWithoutAngleBracketsSugg, HelpIdentifierStartsWithNumber, HelpUseLatestEdition,
+    InInTypo, IncorrectAwait, IncorrectSemicolon, IncorrectUseOfAwait, IncorrectUseOfUse,
+    PatternMethodParamWithoutBody, QuestionMarkInType, QuestionMarkInTypeSugg, SelfParamNotFirst,
+    StructLiteralBodyWithoutPath, StructLiteralBodyWithoutPathSugg, SuggAddMissingLetStmt,
+    SuggEscapeIdentifier, SuggRemoveComma, TernaryOperator, TernaryOperatorSuggestion,
+    UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
+    UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead, WrapType,
 };
 use crate::parser::FnContext;
 use crate::parser::attr::InnerAttrPolicy;
@@ -2558,36 +2557,6 @@ impl<'a> Parser<'a> {
         Ok(false) // Don't continue.
     }
 
-    /// Attempt to parse a generic const argument that has not been enclosed in braces.
-    /// There are a limited number of expressions that are permitted without being encoded
-    /// in braces:
-    /// - Literals.
-    /// - Single-segment paths (i.e. standalone generic const parameters).
-    /// All other expressions that can be parsed will emit an error suggesting the expression be
-    /// wrapped in braces.
-    pub(super) fn handle_unambiguous_unbraced_const_arg(&mut self) -> PResult<'a, Box<Expr>> {
-        let start = self.token.span;
-        let attrs = self.parse_outer_attributes()?;
-        let (expr, _) =
-            self.parse_expr_res(Restrictions::CONST_EXPR, attrs).map_err(|mut err| {
-                err.span_label(
-                    start.shrink_to_lo(),
-                    "while parsing a const generic argument starting here",
-                );
-                err
-            })?;
-        if !self.expr_is_valid_const_arg(&expr) {
-            self.dcx().emit_err(ConstGenericWithoutBraces {
-                span: expr.span,
-                sugg: ConstGenericWithoutBracesSugg {
-                    left: expr.span.shrink_to_lo(),
-                    right: expr.span.shrink_to_hi(),
-                },
-            });
-        }
-        Ok(expr)
-    }
-
     fn recover_const_param_decl(&mut self, ty_generics: Option<&Generics>) -> Option<GenericArg> {
         let snapshot = self.create_snapshot_for_diagnostic();
         let param = match self.parse_const_param(AttrVec::new()) {

compiler/rustc_parse/src/parser/expr.rs

@@ -87,9 +87,13 @@ impl<'a> Parser<'a> {
 
     pub fn parse_expr_anon_const(
         &mut self,
-        mgca_disambiguation: MgcaDisambiguation,
+        mgca_disambiguation: impl FnOnce(&Self, &Expr) -> MgcaDisambiguation,
     ) -> PResult<'a, AnonConst> {
-        self.parse_expr().map(|value| AnonConst { id: DUMMY_NODE_ID, value, mgca_disambiguation })
+        self.parse_expr().map(|value| AnonConst {
+            id: DUMMY_NODE_ID,
+            mgca_disambiguation: mgca_disambiguation(self, &value),
+            value,
+        })
     }
 
     fn parse_expr_catch_underscore(
@@ -1626,9 +1630,9 @@ impl<'a> Parser<'a> {
                     // 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)?
+                    self.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?
                 } else {
-                    self.parse_expr_anon_const(MgcaDisambiguation::Direct)?
+                    self.parse_expr_anon_const(|this, expr| this.mgca_direct_lit_hack(expr))?
                 };
                 self.expect(close)?;
                 ExprKind::Repeat(first_expr, count)

compiler/rustc_parse/src/parser/item.rs

@@ -1651,7 +1651,7 @@ impl<'a> Parser<'a> {
             };
 
             let disr_expr = if this.eat(exp!(Eq)) {
-                Some(this.parse_expr_anon_const(MgcaDisambiguation::AnonConst)?)
+                Some(this.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?)
             } else {
                 None
             };
@@ -1867,7 +1867,7 @@ impl<'a> Parser<'a> {
                 if p.token == token::Eq {
                     let mut snapshot = p.create_snapshot_for_diagnostic();
                     snapshot.bump();
-                    match snapshot.parse_expr_anon_const(MgcaDisambiguation::AnonConst) {
+                    match snapshot.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst) {
                         Ok(const_expr) => {
                             let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
                             p.psess.gated_spans.gate(sym::default_field_values, sp);
@@ -2069,7 +2069,7 @@ impl<'a> Parser<'a> {
         }
         let default = if self.token == token::Eq {
             self.bump();
-            let const_expr = self.parse_expr_anon_const(MgcaDisambiguation::AnonConst)?;
+            let const_expr = self.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?;
             let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
             self.psess.gated_spans.gate(sym::default_field_values, sp);
             Some(const_expr)

compiler/rustc_parse/src/parser/path.rs

@@ -16,12 +16,13 @@ use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
 use super::{Parser, Restrictions, TokenType};
 use crate::ast::{PatKind, TyKind};
 use crate::errors::{
-    self, AttributeOnEmptyType, AttributeOnGenericArg, FnPathFoundNamedParams,
-    PathFoundAttributeInParams, PathFoundCVariadicParams, PathSingleColon, PathTripleColon,
+    self, AttributeOnEmptyType, AttributeOnGenericArg, ConstGenericWithoutBraces,
+    ConstGenericWithoutBracesSugg, FnPathFoundNamedParams, PathFoundAttributeInParams,
+    PathFoundCVariadicParams, PathSingleColon, PathTripleColon,
 };
 use crate::exp;
 use crate::parser::{
-    CommaRecoveryMode, ExprKind, FnContext, FnParseMode, RecoverColon, RecoverComma,
+    CommaRecoveryMode, Expr, ExprKind, FnContext, FnParseMode, RecoverColon, RecoverComma,
 };
 
 /// Specifies how to parse a path.
@@ -882,12 +883,65 @@ impl<'a> Parser<'a> {
             let value = self.parse_mgca_const_block(true)?;
             (value.value, MgcaDisambiguation::AnonConst)
         } else {
-            let value = self.handle_unambiguous_unbraced_const_arg()?;
-            (value, MgcaDisambiguation::Direct)
+            self.parse_unambiguous_unbraced_const_arg()?
         };
         Ok(AnonConst { id: ast::DUMMY_NODE_ID, value, mgca_disambiguation })
     }
 
+    /// Attempt to parse a const argument that has not been enclosed in braces.
+    /// There are a limited number of expressions that are permitted without being
+    /// enclosed in braces:
+    /// - Literals.
+    /// - Single-segment paths (i.e. standalone generic const parameters).
+    /// All other expressions that can be parsed will emit an error suggesting the expression be
+    /// wrapped in braces.
+    pub(super) fn parse_unambiguous_unbraced_const_arg(
+        &mut self,
+    ) -> PResult<'a, (Box<Expr>, MgcaDisambiguation)> {
+        let start = self.token.span;
+        let attrs = self.parse_outer_attributes()?;
+        let (expr, _) =
+            self.parse_expr_res(Restrictions::CONST_EXPR, attrs).map_err(|mut err| {
+                err.span_label(
+                    start.shrink_to_lo(),
+                    "while parsing a const generic argument starting here",
+                );
+                err
+            })?;
+        if !self.expr_is_valid_const_arg(&expr) {
+            self.dcx().emit_err(ConstGenericWithoutBraces {
+                span: expr.span,
+                sugg: ConstGenericWithoutBracesSugg {
+                    left: expr.span.shrink_to_lo(),
+                    right: expr.span.shrink_to_hi(),
+                },
+            });
+        }
+
+        let mgca_disambiguation = self.mgca_direct_lit_hack(&expr);
+        Ok((expr, mgca_disambiguation))
+    }
+
+    /// Under `min_generic_const_args` we still allow *some* anon consts to be written without
+    /// a `const` block as it makes things quite a lot nicer. This function is useful for contexts
+    /// where we would like to use `MgcaDisambiguation::Direct` but need to fudge it to be `AnonConst`
+    /// in the presence of literals.
+    //
+    /// FIXME(min_generic_const_args): In the long term it would be nice to have a way to directly
+    /// represent literals in `hir::ConstArgKind` so that we can remove this special case by not
+    /// needing an anon const.
+    pub fn mgca_direct_lit_hack(&self, expr: &Expr) -> MgcaDisambiguation {
+        match &expr.kind {
+            ast::ExprKind::Lit(_) => MgcaDisambiguation::AnonConst,
+            ast::ExprKind::Unary(ast::UnOp::Neg, expr)
+                if matches!(expr.kind, ast::ExprKind::Lit(_)) =>
+            {
+                MgcaDisambiguation::AnonConst
+            }
+            _ => MgcaDisambiguation::Direct,
+        }
+    }
+
     /// Parse a generic argument in a path segment.
     /// This does not include constraints, e.g., `Item = u8`, which is handled in `parse_angle_arg`.
     pub(super) fn parse_generic_arg(

compiler/rustc_parse/src/parser/ty.rs

@@ -668,7 +668,7 @@ impl<'a> Parser<'a> {
                 // in the AST with the extra disambiguator on the AnonConst
                 self.parse_mgca_const_block(false)?
             } else {
-                self.parse_expr_anon_const(MgcaDisambiguation::Direct)?
+                self.parse_expr_anon_const(|this, expr| this.mgca_direct_lit_hack(expr))?
             };
 
             if let Err(e) = self.expect(exp!(CloseBracket)) {
@@ -713,7 +713,7 @@ impl<'a> Parser<'a> {
 
         // FIXME(mgca): recovery is broken for `const {` args
         // we first try to parse pattern like `[u8 5]`
-        let length = match self.parse_expr_anon_const(MgcaDisambiguation::Direct) {
+        let length = match self.parse_expr_anon_const(|_, _| MgcaDisambiguation::Direct) {
             Ok(length) => length,
             Err(e) => {
                 e.cancel();
@@ -801,7 +801,7 @@ impl<'a> Parser<'a> {
     /// an error type.
     fn parse_typeof_ty(&mut self, lo: Span) -> PResult<'a, TyKind> {
         self.expect(exp!(OpenParen))?;
-        let _expr = self.parse_expr_anon_const(MgcaDisambiguation::AnonConst)?;
+        let _expr = self.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?;
         self.expect(exp!(CloseParen))?;
         let span = lo.to(self.prev_token.span);
         let guar = self

src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.fixed

@@ -8,7 +8,7 @@ trait AssocConstTrait {
 }
 fn assoc_const_args<T>()
 where
-    T: AssocConstTrait<ASSOC = const { 0 }>,
+    T: AssocConstTrait<ASSOC = 0>,
     //~^ trait_duplication_in_bounds
 {
 }

src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs

@@ -8,7 +8,7 @@ trait AssocConstTrait {
 }
 fn assoc_const_args<T>()
 where
-    T: AssocConstTrait<ASSOC = const { 0 }> + AssocConstTrait<ASSOC = const { 0 }>,
+    T: AssocConstTrait<ASSOC = 0> + AssocConstTrait<ASSOC = 0>,
     //~^ trait_duplication_in_bounds
 {
 }

src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.stderr

@@ -1,8 +1,8 @@
 error: these where clauses contain repeated elements
   --> tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs:11:8
    |
-LL |     T: AssocConstTrait<ASSOC = const { 0 }> + AssocConstTrait<ASSOC = const { 0 }>,
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `AssocConstTrait<ASSOC = const { 0 }>`
+LL |     T: AssocConstTrait<ASSOC = 0> + AssocConstTrait<ASSOC = 0>,
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `AssocConstTrait<ASSOC = 0>`
    |
 note: the lint level is defined here
   --> tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs:1:9