Parse unambiguous const expressions in param position

When encountering the start of an expression that cannot be a type
parameter, parse it as a const expression. For an expression to be valid
they must not contain "greater than" or "shift right" operations. The
new behavior only parses expressions that begin with a token that can
start an expression but can't start a type. Calling functions and
methods will cause a type path parsing error.

Author: estebank

src/librustc_parse/parser/expr.rs

@@ -331,6 +331,12 @@ impl<'a> Parser<'a> {
     /// Also performs recovery for `and` / `or` which are mistaken for `&&` and `||` respectively.
     fn check_assoc_op(&self) -> Option<Spanned<AssocOp>> {
         let (op, span) = match (AssocOp::from_token(&self.token), self.token.ident()) {
+            // When parsing const expressions, stop parsing when encountering `<` and `>`.
+            (Some(AssocOp::ShiftRight), _) | (Some(AssocOp::Greater), _)
+                if self.restrictions.contains(Restrictions::CONST_EXPR) =>
+            {
+                return None;
+            }
             (Some(op), _) => (op, self.token.span),
             (None, Some((Ident { name: sym::and, span }, false))) => {
                 self.error_bad_logical_op("and", "&&", "conjunction");
@@ -1585,7 +1591,9 @@ impl<'a> Parser<'a> {
         let lo = self.prev_token.span;
         let pat = self.parse_top_pat(GateOr::No)?;
         self.expect(&token::Eq)?;
-        let expr = self.with_res(Restrictions::NO_STRUCT_LITERAL, |this| {
+        // `self.restrictions |` below is to account for `CONST_EXPR` so that we can correctly
+        // parse `let` expressions in `const` arguments.
+        let expr = self.with_res(self.restrictions | Restrictions::NO_STRUCT_LITERAL, |this| {
             this.parse_assoc_expr_with(1 + prec_let_scrutinee_needs_par(), None.into())
         })?;
         let span = lo.to(expr.span);

src/librustc_parse/parser/mod.rs

@@ -34,6 +34,7 @@ bitflags::bitflags! {
     struct Restrictions: u8 {
         const STMT_EXPR         = 1 << 0;
         const NO_STRUCT_LITERAL = 1 << 1;
+        const CONST_EXPR        = 1 << 2;
     }
 }
 

src/librustc_parse/parser/path.rs

@@ -1,5 +1,5 @@
 use super::ty::{AllowPlus, RecoverQPath};
-use super::{Parser, TokenType};
+use super::{Parser, Restrictions, TokenType};
 use crate::maybe_whole;
 use rustc_ast::ast::{self, AngleBracketedArg, AngleBracketedArgs, GenericArg, ParenthesizedArgs};
 use rustc_ast::ast::{AnonConst, AssocTyConstraint, AssocTyConstraintKind, BlockCheckMode};
@@ -479,36 +479,34 @@ impl<'a> Parser<'a> {
             GenericArg::Lifetime(self.expect_lifetime())
         } else if self.check_const_arg() {
             // Parse const argument.
-            let expr = if let token::OpenDelim(token::Brace) = self.token.kind {
+            let value = if let token::OpenDelim(token::Brace) = self.token.kind {
                 self.parse_block_expr(
                     None,
                     self.token.span,
                     BlockCheckMode::Default,
                     ast::AttrVec::new(),
                 )?
-            } else if self.token.is_ident() {
+            } else {
                 // FIXME(const_generics): to distinguish between idents for types and consts,
                 // we should introduce a GenericArg::Ident in the AST and distinguish when
                 // lowering to the HIR. For now, idents for const args are not permitted.
-                if self.token.is_bool_lit() {
-                    self.parse_literal_maybe_minus()?
-                } else {
-                    let span = self.token.span;
-                    let msg = "identifiers may currently not be used for const generics";
-                    self.struct_span_err(span, msg).emit();
-                    let block = self.mk_block_err(span);
-                    self.mk_expr(span, ast::ExprKind::Block(block, None), ast::AttrVec::new())
-                }
-            } else {
-                self.parse_literal_maybe_minus()?
+                let start = self.token.span;
+                self.parse_expr_res(Restrictions::CONST_EXPR, None).map_err(|mut err| {
+                    err.span_label(
+                        start.shrink_to_lo(),
+                        "while parsing a `const` argument starting here",
+                    );
+                    err
+                })?
             };
-            GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value: expr })
+            GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value })
         } else if self.check_type() {
             // Parse type argument.
             GenericArg::Type(self.parse_ty()?)
         } else {
             return Ok(None);
         };
+        // FIXME: recover from const expressions without braces that require them.
         Ok(Some(arg))
     }
 }

src/test/ui/const-generics/const-expression-missing-braces.rs

@@ -15,8 +15,7 @@ fn b() {
 }
 fn c() {
     let bar = 3;
-    foo::<3 + 3>();
-    //~^ ERROR expected one of `,` or `>`, found `+`
+    foo::<3 + 3>(); // ok
 }
 
 fn main() {}

src/test/ui/const-generics/const-expression-missing-braces.stderr

@@ -4,12 +4,6 @@ error: expected one of `!`, `(`, `,`, `>`, `?`, `for`, lifetime, or path, found
 LL |     foo::<bar + 3>();
    |                 ^ expected one of 8 possible tokens
 
-error: expected one of `,` or `>`, found `+`
-  --> $DIR/const-expression-missing-braces.rs:18:13
-   |
-LL |     foo::<3 + 3>();
-   |             ^ expected one of `,` or `>`
-
 error: likely `const` expression parsed as trait bounds
   --> $DIR/const-expression-missing-braces.rs:13:11
    |
@@ -21,5 +15,5 @@ help: if you meant to write a `const` expression, surround the expression with b
 LL |     foo::<{ bar + bar }>();
    |           ^           ^
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 

src/test/ui/const-generics/const-expression-parameter.rs

@@ -1,5 +1,6 @@
+// check-pass
+#![allow(incomplete_features)]
 #![feature(const_generics)]
-//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
 
 fn i32_identity<const X: i32>() -> i32 {
     5
@@ -10,7 +11,7 @@ fn foo_a() {
 }
 
 fn foo_b() {
-    i32_identity::<1 + 2>(); //~ ERROR expected one of `,` or `>`, found `+`
+    i32_identity::<1 + 2>(); // ok
 }
 
 fn foo_c() {

src/test/ui/const-generics/const-expression-parameter.stderr

@@ -232,10 +232,10 @@ fn inside_const_generic_arguments() {
     // In the cases above we have `ExprKind::Block` to help us out.
     // Below however, we would not have a block and so an implementation might go
     // from visiting expressions to types without banning `let` expressions down the tree.
-    // This tests ensures that we are not caught by surprise should the parser
-    // admit non-IDENT expressions in const generic arguments.
-
+    // The parser admits non-IDENT expressions in const generic arguments and is caught by the 
+    // test below.
     if A::<
-        true && let 1 = 1 //~ ERROR expected one of `,` or `>`, found `&&`
+        true && let 1 = 1 //~ ERROR `let` expressions are not supported here
+        //~^ ERROR `match` is not allowed in a `const`
     >::O == 5 {}
 }

src/test/ui/rfc-2497-if-let-chains/disallowed-positions.rs

@@ -1,9 +1,3 @@
-error: expected one of `,` or `>`, found `&&`
-  --> $DIR/disallowed-positions.rs:239:14
-   |
-LL |         true && let 1 = 1
-   |              ^^ expected one of `,` or `>`
-
 error: `let` expressions are not supported here
   --> $DIR/disallowed-positions.rs:32:9
    |
@@ -499,6 +493,15 @@ LL |         true && let 1 = 1
    = note: only supported directly in conditions of `if`- and `while`-expressions
    = note: as well as when nested within `&&` and parenthesis in those conditions
 
+error: `let` expressions are not supported here
+  --> $DIR/disallowed-positions.rs:238:17
+   |
+LL |         true && let 1 = 1
+   |                 ^^^^^^^^^
+   |
+   = note: only supported directly in conditions of `if`- and `while`-expressions
+   = note: as well as when nested within `&&` and parenthesis in those conditions
+
 warning: the feature `const_generics` is incomplete and may cause the compiler to crash
   --> $DIR/disallowed-positions.rs:20:12
    |
@@ -540,6 +543,15 @@ LL |         true && let 1 = 1
    = note: see issue #49146 <https://github.com/rust-lang/rust/issues/49146> for more information
    = help: add `#![feature(const_if_match)]` to the crate attributes to enable
 
+error[E0658]: `match` is not allowed in a `const`
+  --> $DIR/disallowed-positions.rs:238:17
+   |
+LL |         true && let 1 = 1
+   |                 ^^^^^^^^^
+   |
+   = note: see issue #49146 <https://github.com/rust-lang/rust/issues/49146> for more information
+   = help: add `#![feature(const_if_match)]` to the crate attributes to enable
+
 error[E0308]: mismatched types
   --> $DIR/disallowed-positions.rs:32:8
    |
@@ -980,7 +992,7 @@ LL |         let 0 = 0?;
    = help: the trait `std::ops::Try` is not implemented for `{integer}`
    = note: required by `std::ops::Try::into_result`
 
-error: aborting due to 106 previous errors; 2 warnings emitted
+error: aborting due to 107 previous errors; 2 warnings emitted
 
 Some errors have detailed explanations: E0277, E0308, E0600, E0614, E0658.
 For more information about an error, try `rustc --explain E0277`.