Rollup of 9 pull requests

compiler/rustc_ast/src/ast.rs

@@ -4073,6 +4073,7 @@ pub struct TestBinderConstraints {
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TestBinderBody {
+    pub span: Span,
     pub foralls: ThinVec<TestBinderForall>,
     pub exists: ThinVec<TestBinderExists>,
     pub constraints: Vec<TestBinderConstraint>,

compiler/rustc_ast_lowering/src/item.rs

@@ -2005,7 +2005,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .iter()
                 .map(|predicate| self.lower_where_predicate(predicate, &[], &mut dedup_map)),
         );
-        hir::TestBinderBody { foralls, exists, constraints, predicates }
+        let span = self.lower_span(body.span);
+        hir::TestBinderBody { foralls, exists, constraints, predicates, span }
     }
 
     fn lower_test_binder_forall(

compiler/rustc_hir/src/hir.rs

@@ -4527,6 +4527,7 @@ impl FnHeader {
 
 #[derive(Debug, Clone, Copy, StableHash)]
 pub struct TestBinderBody<'hir> {
+    pub span: Span,
     pub foralls: &'hir [TestBinderForall<'hir>],
     pub exists: &'hir [TestBinderExists<'hir>],
     /// Constraints to be inserted directly into constraint storage to be proven

compiler/rustc_hir/src/intravisit.rs

@@ -1600,7 +1600,7 @@ pub fn walk_test_binder_body<'v, V: Visitor<'v>>(
     visitor: &mut V,
     body: &'v TestBinderBody<'v>,
 ) -> V::Result {
-    let TestBinderBody { foralls, exists, constraints, predicates } = body;
+    let TestBinderBody { span: _, foralls, exists, constraints, predicates } = body;
     walk_list!(visitor, visit_test_binder_forall, *foralls);
     walk_list!(visitor, visit_test_binder_exists, *exists);
     try_visit!(visitor.visit_test_binder_constraint(&constraints));

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -2380,7 +2380,7 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     pub(super) fn check_test_binder_body(&self, body: TestBinderBody<'tcx>) {
-        let TestBinderBody { foralls, exists, constraints, predicates } = body;
+        let TestBinderBody { span, foralls, exists, constraints, predicates } = body;
         if !predicates.is_empty() {
             for (predicate, span) in predicates {
                 let cause = traits::ObligationCause::misc(span, self.body_def_id);
@@ -2400,6 +2400,10 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
             Ok(()) => constraints,
             Err(_guar) => ty::region_constraint::RegionConstraint::new_true(),
         };
+        if constraints.is_false() {
+            self.tcx().dcx().span_err(span, "top level false constraints are not supported");
+            return;
+        }
 
         self.infcx.register_solver_region_constraint(constraints);
 
@@ -2479,6 +2483,13 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
                 u,
             )
             .with_spans(forall.span);
+            if constraint.is_false() {
+                self.tcx().dcx().span_err(forall.span, "forall evaluated to false");
+                self.infcx.overwrite_solver_region_constraint(
+                    ty::region_constraint::RegionConstraint::new_true(),
+                );
+                return;
+            }
             if let Some(assert_on_exit) = &forall.assert_on_exit {
                 self.check_test_binder_region_constraints(forall.span, assert_on_exit, &constraint);
             }
@@ -2798,6 +2809,7 @@ struct RedundantLifetimeArgsLint<'tcx> {
 
 #[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
 pub(crate) struct TestBinderBody<'tcx> {
+    pub span: Span,
     pub foralls: Vec<TestBinderForall<'tcx>>,
     pub exists: Vec<TestBinderExists<'tcx>>,
     /// Constraints to be inserted directly into constraint storage to be proven

compiler/rustc_hir_analysis/src/collect.rs

@@ -328,7 +328,7 @@ impl<'tcx> ItemCtxt<'tcx> {
         &self,
         item: &hir::TestBinderBody<'tcx>,
     ) -> TestBinderBody<'tcx> {
-        let hir::TestBinderBody { foralls, exists, constraints, predicates } = item;
+        let hir::TestBinderBody { span, foralls, exists, constraints, predicates } = item;
         let foralls = foralls.iter().map(|forall| self.lower_test_binder_forall(forall)).collect();
         let exists = exists.iter().map(|exists| self.lower_test_binder_exists(exists)).collect();
         let constraints = self.lower_test_binder_constraint(&constraints);
@@ -337,7 +337,7 @@ impl<'tcx> ItemCtxt<'tcx> {
             clauses_of::where_predicate_clauses(self, predicate, &mut clauses);
         }
         let predicates = clauses.into_iter().map(|(c, span)| (c.kind(), span)).collect();
-        TestBinderBody { foralls, exists, constraints, predicates }
+        TestBinderBody { span: *span, foralls, exists, constraints, predicates }
     }
 
     #[instrument(level = "debug", skip(self), ret)]

compiler/rustc_parse/src/diagnostics.rs

@@ -1712,6 +1712,15 @@ pub(crate) struct GenericParamsWithoutAngleBrackets {
     pub sugg: GenericParamsWithoutAngleBracketsSugg,
 }
 
+#[derive(Diagnostic)]
+#[diag("use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments")]
+pub(crate) struct MissingTurbofishForLifetime {
+    #[primary_span]
+    pub span: Span,
+    #[suggestion("add `::`", style = "verbose", code = "::", applicability = "machine-applicable")]
+    pub suggest_turbofish: Span,
+}
+
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
     "surround the type parameters with angle brackets",

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -1143,6 +1143,13 @@ impl<'a> Parser<'a> {
         }
     }
 
+    pub(super) fn recover_missing_turbofish_for_lifetimes(&self, lt_span: Span) {
+        self.dcx().emit_err(crate::diagnostics::MissingTurbofishForLifetime {
+            span: lt_span,
+            suggest_turbofish: lt_span.shrink_to_lo(),
+        });
+    }
+
     /// When writing a turbofish with multiple type parameters missing the leading `::`, we will
     /// encounter a parse error when encountering the first `,`.
     pub(super) fn check_mistyped_turbofish_with_multiple_type_params(

compiler/rustc_parse/src/parser/expr.rs

@@ -410,12 +410,6 @@ impl<'a> Parser<'a> {
                     pre_span,
                 ));
             }
-            token::Ident(..)
-                if this.token.is_keyword(kw::Move)
-                    && this.look_ahead(1, |t| *t == token::OpenParen) =>
-            {
-                make_it!(this, attrs, |this, _| this.parse_expr_move(lo))
-            }
             token::Ident(..) if this.may_recover() && this.is_mistaken_not_ident_negation() => {
                 make_it!(this, attrs, |this, _| this.recover_not_expr(lo))
             }
@@ -447,16 +441,6 @@ impl<'a> Parser<'a> {
         self.parse_expr_unary(lo, UnOp::Not)
     }
 
-    fn parse_expr_move(&mut self, move_kw: Span) -> PResult<'a, (Span, ExprKind)> {
-        self.bump();
-        self.psess.gated_spans.gate(sym::move_expr, move_kw);
-        self.expect(exp!(OpenParen))?;
-        let expr = self.parse_expr()?;
-        self.expect(exp!(CloseParen))?;
-        let span = move_kw.to(self.prev_token.span);
-        Ok((span, ExprKind::Move(expr, move_kw)))
-    }
-
     fn is_mistaken_not_ident_negation(&self) -> bool {
         let token_cannot_continue_expr = |t: &Token| match t.uninterpolate().kind {
             // These tokens can start an expression after `!`, but
@@ -1335,6 +1319,10 @@ impl<'a> Parser<'a> {
                 this.parse_expr_builtin()
             } else if this.check_path() {
                 this.parse_expr_path_start()
+            } else if this.token.is_keyword(kw::Move)
+                && this.look_ahead(1, |t| *t == token::OpenParen)
+            {
+                this.parse_expr_move()
             } else if this.check_keyword(exp!(Move))
                 || this.check_keyword(exp!(Use))
                 || this.check_keyword(exp!(Static))
@@ -2216,6 +2204,17 @@ impl<'a> Parser<'a> {
         Ok(self.mk_expr(blk.span, ExprKind::Block(blk, None)))
     }
 
+    fn parse_expr_move(&mut self) -> PResult<'a, Box<Expr>> {
+        let move_kw = self.token.span;
+        self.expect_keyword(exp!(Move))?;
+        self.expect(exp!(OpenParen))?;
+        let expr = self.parse_expr()?;
+        self.expect(exp!(CloseParen))?;
+        let span = move_kw.to(self.prev_token.span);
+        self.psess.gated_spans.gate(sym::move_expr, span);
+        Ok(self.mk_expr(span, ExprKind::Move(expr, move_kw)))
+    }
+
     /// Parses a closure expression (e.g., `move |args| expr`).
     fn parse_expr_closure(&mut self) -> PResult<'a, Box<Expr>> {
         let lo = self.token.span;

compiler/rustc_parse/src/parser/item.rs

@@ -2717,6 +2717,7 @@ impl<'a> Parser<'a> {
         let mut exists = ThinVec::new();
         let mut constraints = Vec::new();
         let mut predicates = Vec::new();
+        let mut span = self.token.span;
         self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), |this| {
             match this.token.ident() {
                 Some((Ident { name: sym::predicates, .. }, IdentKind::Normal)) => {
@@ -2735,7 +2736,8 @@ impl<'a> Parser<'a> {
             }
             Ok(())
         })?;
-        Ok(TestBinderBody { foralls, exists, constraints, predicates })
+        span = span.to(self.prev_token.span);
+        Ok(TestBinderBody { foralls, exists, constraints, predicates, span })
     }
 
     pub fn parse_test_binder_forall(&mut self) -> PResult<'a, TestBinderForall> {

compiler/rustc_parse/src/parser/path.rs

@@ -303,9 +303,20 @@ impl<'a> Parser<'a> {
             is_args_start(&this.token)
         };
 
+        // A lifetime followed by `>` or `,` can never start a valid expression, so `<` here
+        // must be the start of generic arguments with a missing `::`.
+        let is_missing_turbofish_for_lifetime = |this: &mut Self| {
+            this.token == token::Lt
+                && this.may_recover()
+                && style == PathStyle::Expr
+                && this.look_ahead(1, |t| t.is_lifetime())
+                && this.look_ahead(2, |t| matches!(t.kind, token::Gt | token::Comma))
+        };
+
         Ok(
             if style == PathStyle::Type && check_args_start(self)
                 || style != PathStyle::Mod && self.check_path_sep_and_look_ahead(is_args_start)
+                || is_missing_turbofish_for_lifetime(self)
             {
                 // We use `style == PathStyle::Expr` to check if this is in a recursion or not. If
                 // it isn't, then we reset the unmatched angle bracket count as we're about to start
@@ -314,12 +325,18 @@ impl<'a> Parser<'a> {
                     self.unmatched_angle_bracket_count = 0;
                 }
 
+                let missing_turbofish =
+                    style == PathStyle::Expr && !self.check_path_sep_and_look_ahead(is_args_start);
+
                 // Generic arguments are found - `<`, `(`, `::<` or `::(`.
                 // First, eat `::` if it exists.
                 let _ = self.eat_path_sep();
 
                 let lo = self.token.span;
                 let args = if self.eat_lt() {
+                    if missing_turbofish {
+                        self.recover_missing_turbofish_for_lifetimes(lo);
+                    }
                     // `<'a, T, A = U>`
                     let args = self.parse_angle_args_with_leading_angle_bracket_recovery(
                         style,