From 9786ee65a51e5898b3c5718f2447ef3bbf9046a0 Mon Sep 17 00:00:00 2001
From: Raushan singh <raushansinghrajpoot687@gmail.com>
Date: Sat, 12 Sep 2026 13:53:31 +0000
Subject: [PATCH 1/3] test(parser): add baseline for missing turbofish with
 lifetime in struct expr

---
 .../recover/missing-turbofish-lifetime.rs     | 30 ++++++++++
 .../recover/missing-turbofish-lifetime.stderr | 57 +++++++++++++++++++
 2 files changed, 87 insertions(+)
 create mode 100644 tests/ui/parser/recover/missing-turbofish-lifetime.rs
 create mode 100644 tests/ui/parser/recover/missing-turbofish-lifetime.stderr

diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime.rs b/tests/ui/parser/recover/missing-turbofish-lifetime.rs
new file mode 100644
index 0000000000000..596b197a317da
--- /dev/null
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime.rs
@@ -0,0 +1,30 @@
+struct Struct<'a> {
+    string: &'a str,
+}
+
+fn struct_with_reserved_lifetime() {
+    let _ = Struct<'_> {
+        //~^ ERROR labels cannot use keyword names
+        //~| ERROR expected `while`, `for`, `loop` or `{` after a label
+        //~| ERROR comparison operators cannot be chained
+        string: "",
+    };
+}
+
+fn struct_with_named_lifetime() {
+    let _ = Struct<'a> {
+        //~^ ERROR expected `while`, `for`, `loop` or `{` after a label
+        //~| ERROR comparison operators cannot be chained
+        string: "",
+    };
+}
+
+fn struct_with_multichar_lifetime() {
+    let _ = Struct<'abc> {
+        //~^ ERROR expected `while`, `for`, `loop` or `{` after a label
+        //~| ERROR comparison operators cannot be chained
+        string: "",
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime.stderr b/tests/ui/parser/recover/missing-turbofish-lifetime.stderr
new file mode 100644
index 0000000000000..e14d9d6aa464c
--- /dev/null
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime.stderr
@@ -0,0 +1,57 @@
+error: labels cannot use keyword names
+  --> $DIR/missing-turbofish-lifetime.rs:6:20
+   |
+LL |     let _ = Struct<'_> {
+   |                    ^^
+
+error: expected `while`, `for`, `loop` or `{` after a label
+  --> $DIR/missing-turbofish-lifetime.rs:6:22
+   |
+LL |     let _ = Struct<'_> {
+   |                      ^ expected `while`, `for`, `loop` or `{` after a label
+   |
+help: add `'` to close the char literal
+   |
+LL |     let _ = Struct<'_'> {
+   |                      +
+
+error: comparison operators cannot be chained
+  --> $DIR/missing-turbofish-lifetime.rs:6:19
+   |
+LL |     let _ = Struct<'_> {
+   |                   ^  ^
+
+error: expected `while`, `for`, `loop` or `{` after a label
+  --> $DIR/missing-turbofish-lifetime.rs:15:22
+   |
+LL |     let _ = Struct<'a> {
+   |                      ^ expected `while`, `for`, `loop` or `{` after a label
+   |
+help: add `'` to close the char literal
+   |
+LL |     let _ = Struct<'a'> {
+   |                      +
+
+error: comparison operators cannot be chained
+  --> $DIR/missing-turbofish-lifetime.rs:15:19
+   |
+LL |     let _ = Struct<'a> {
+   |                   ^  ^
+
+error: expected `while`, `for`, `loop` or `{` after a label
+  --> $DIR/missing-turbofish-lifetime.rs:23:24
+   |
+LL |     let _ = Struct<'abc> {
+   |                        ^ expected `while`, `for`, `loop` or `{` after a label
+
+error: comparison operators cannot be chained
+  --> $DIR/missing-turbofish-lifetime.rs:23:19
+   |
+LL |     let _ = Struct<'abc> {
+   |                   ^    ^
+   |
+   = help: use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
+   = help: or use `(...)` if you meant to specify fn arguments
+
+error: aborting due to 7 previous errors
+

From 67007bef4f76cbd87b1444384db6884c6e1c5a76 Mon Sep 17 00:00:00 2001
From: Raushan singh <raushansinghrajpoot687@gmail.com>
Date: Sun, 13 Sep 2026 06:16:34 +0000
Subject: [PATCH 2/3] refactor(parser): add IS_RHS_OF_LT_AFTER_PATH restriction
 and delay KeywordLabel emission in eat_label

---
 .../rustc_parse/src/parser/diagnostics.rs     |  6 ++-
 compiler/rustc_parse/src/parser/expr.rs       | 40 +++++++++++++------
 compiler/rustc_parse/src/parser/mod.rs        |  2 +
 3 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 40dbda2466de4..33d6251136d29 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -2844,7 +2844,11 @@ impl<'a> Parser<'a> {
         {
             return false;
         }
-        let label = self.eat_label().expect("just checked if a label exists");
+        let (label, err) = self.eat_label();
+        if let Some(e) = err {
+            e.emit();
+        }
+        let label = label.expect("just checked if a label exists");
         self.bump(); // eat `:`
         let span = label.ident.span.to(self.prev_token.span);
         let mut diag = self
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 8238a6518e41d..357de350ab4dc 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -274,9 +274,13 @@ impl<'a> Parser<'a> {
                 Fixity::Right => Bound::Included(prec),
                 Fixity::Left | Fixity::None => Bound::Excluded(prec),
             };
-            let rhs = self.with_res(restrictions - Restrictions::STMT_EXPR, |this| {
-                this.parse_expr_assoc(min_prec)
-            })?;
+            let mut rhs_restrictions = restrictions - Restrictions::STMT_EXPR;
+            if matches!(op, AssocOp::Binary(BinOpKind::Lt))
+                && matches!(lhs.kind, ExprKind::Path(..))
+            {
+                rhs_restrictions |= Restrictions::IS_RHS_OF_LT_AFTER_PATH;
+            }
+            let rhs = self.with_res(rhs_restrictions, |this| this.parse_expr_assoc(min_prec))?;
 
             let span = self.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span);
             lhs = match op {
@@ -1518,7 +1522,10 @@ impl<'a> Parser<'a> {
                 }
             } else if this.eat_keyword(exp!(While)) {
                 this.parse_expr_while(None, lo)
-            } else if let Some(label) = this.eat_label() {
+            } else if let (Some(label), err) = this.eat_label() {
+                if let Some(e) = err {
+                    e.emit();
+                }
                 this.parse_expr_labeled(label, true)
             } else if this.eat_keyword(exp!(Loop)) {
                 this.parse_expr_loop(None, lo).map_err(|mut err| {
@@ -1909,7 +1916,10 @@ impl<'a> Parser<'a> {
     /// with a labeled loop does not even get a warning because there is no ambiguity.
     fn parse_expr_break(&mut self) -> PResult<'a, Box<Expr>> {
         let lo = self.prev_token.span;
-        let mut label = self.eat_label();
+        let (mut label, err) = self.eat_label();
+        if let Some(e) = err {
+            e.emit();
+        }
         let kind = if self.token == token::Colon
             && let Some(label) = label.take()
         {
@@ -1976,7 +1986,10 @@ impl<'a> Parser<'a> {
 
     /// Parse `"continue" label?`.
     fn parse_expr_continue(&mut self, lo: Span) -> PResult<'a, Box<Expr>> {
-        let mut label = self.eat_label();
+        let (mut label, err) = self.eat_label();
+        if let Some(e) = err {
+            e.emit();
+        }
 
         // Recover `continue label` -> `continue 'label`
         if self.may_recover()
@@ -3162,17 +3175,18 @@ impl<'a> Parser<'a> {
         ))
     }
 
-    pub(crate) fn eat_label(&mut self) -> Option<Label> {
+    pub(crate) fn eat_label(&mut self) -> (Option<Label>, Option<Diag<'a>>) {
         if let Some((ident, is_raw)) = self.token.lifetime() {
             // Disallow `'fn`, but with a better error message than `expect_lifetime`.
-            if is_raw == IdentIsRaw::No && ident.without_first_quote().is_reserved() {
-                self.dcx().emit_err(diagnostics::KeywordLabel { span: ident.span });
-            }
-
+            let err = if is_raw == IdentIsRaw::No && ident.without_first_quote().is_reserved() {
+                Some(self.dcx().create_err(diagnostics::KeywordLabel { span: ident.span }))
+            } else {
+                None
+            };
             self.bump();
-            Some(Label { ident })
+            (Some(Label { ident }), err)
         } else {
-            None
+            (None, None)
         }
     }
 
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index b2afd1c51256a..0171ce57638c8 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -125,6 +125,8 @@ bitflags::bitflags! {
         /// expression, but halts parsing the expression when reaching certain
         /// tokens like `=`.
         const IS_PAT            = 1 << 5;
+        /// Used to detect missing turbofish `path < 'a >` inside the RHS of `<`.
+        const IS_RHS_OF_LT_AFTER_PATH = 1 << 6;
     }
 }
 

From 2e5a236af6e4f9b1c8d240834a93b8377b46d85c Mon Sep 17 00:00:00 2001
From: Raushan singh <raushansinghrajpoot687@gmail.com>
Date: Mon, 14 Sep 2026 04:35:09 +0000
Subject: [PATCH 3/3] fix(parser): recover missing turbofish for reserved
 keyword lifetimes

---
 compiler/rustc_parse/src/parser/expr.rs       | 123 +++++++++++++++++-
 compiler/rustc_parse/src/parser/mod.rs        |   9 +-
 compiler/rustc_parse/src/parser/stmt.rs       |   2 +-
 .../missing-turbofish-lifetime-run-pass.fixed |   9 ++
 .../missing-turbofish-lifetime-run-pass.rs    |   9 ++
 ...missing-turbofish-lifetime-run-pass.stderr |  13 ++
 .../recover/missing-turbofish-lifetime.rs     |   8 +-
 .../recover/missing-turbofish-lifetime.stderr |  46 ++-----
 .../require-parens-for-chained-comparison.rs  |   6 +-
 ...quire-parens-for-chained-comparison.stderr |  30 ++---
 10 files changed, 181 insertions(+), 74 deletions(-)
 create mode 100644 tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.fixed
 create mode 100644 tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.rs
 create mode 100644 tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.stderr

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 357de350ab4dc..1b1a98dba5ff7 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -280,7 +280,64 @@ impl<'a> Parser<'a> {
             {
                 rhs_restrictions |= Restrictions::IS_RHS_OF_LT_AFTER_PATH;
             }
-            let rhs = self.with_res(rhs_restrictions, |this| this.parse_expr_assoc(min_prec))?;
+            let rhs = if op == AssocOp::Binary(BinOpKind::Lt) {
+                // Make the path ident available to `parse_expr_labeled` so the turbofish
+                // suggestion can name the actual path (e.g. "for `Struct`").
+                if let ExprKind::Path(_, ref path) = lhs.kind {
+                    self.expected_turbofish_context =
+                        path.segments.last().map(|seg| (op_span, seg.ident));
+                }
+                let res = self.with_res(rhs_restrictions, |this| this.parse_expr_assoc(min_prec));
+                // Clear regardless of whether recovery fired; the context is only valid for
+                // this one `<` operator.
+                self.expected_turbofish_context = None;
+                res?
+            } else {
+                self.with_res(rhs_restrictions, |this| this.parse_expr_assoc(min_prec))?
+            };
+
+            // Recover `Struct<'_>` missing its turbofish `::`.
+            //
+            // `parse_expr_labeled` set `turbofish_missing_lifetime_recovery` and returned
+            // an `ExprKind::Err` sentinel after emitting the diagnostic. We now have all
+            // the information needed to rebuild a well-formed path with the lifetime grafted
+            // onto the last segment, and then resume normal postfix parsing.
+            if let Some((ident, span)) = self.turbofish_missing_lifetime_recovery.take() {
+                if let ExprKind::Err(_) = rhs.kind {
+                    let mut lhs_expr = *lhs;
+                    if let ExprKind::Path(qself, mut path) = lhs_expr.kind {
+                        // Graft the lifetime onto the `lhs` path.
+                        if let Some(last_segment) = path.segments.last_mut() {
+                            let arg = ast::GenericArg::Lifetime(ast::Lifetime {
+                                id: ast::DUMMY_NODE_ID,
+                                ident,
+                            });
+                            let args = ast::AngleBracketedArgs {
+                                span: op_span.to(span),
+                                args: thin_vec::thin_vec![ast::AngleBracketedArg::Arg(arg)],
+                            };
+                            last_segment.args =
+                                Some(Box::new(ast::GenericArgs::AngleBracketed(args)));
+                        }
+
+                        // Resume parsing as a struct literal.
+                        if self.token == token::OpenBrace {
+                            if let Some(expr) = self.maybe_parse_struct_expr(&qself, &path) {
+                                lhs = expr?;
+                                continue;
+                            }
+                        }
+
+                        // Otherwise, resume parsing as a postfix expression (e.g. function call).
+                        lhs_expr.kind = ExprKind::Path(qself, path);
+                        let span = lhs_expr.span;
+                        lhs = Box::new(lhs_expr);
+                        lhs = self.parse_expr_dot_or_call_with(ast::AttrVec::new(), lhs, span)?;
+                        continue;
+                    }
+                    lhs = Box::new(lhs_expr);
+                }
+            }
 
             let span = self.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span);
             lhs = match op {
@@ -684,7 +741,7 @@ impl<'a> Parser<'a> {
                                 segment.ident.span,
                             ),
                         };
-                        match self.parse_expr_labeled(label, false) {
+                        match self.parse_expr_labeled(label, false, None) {
                             Ok(expr) => {
                                 type_err.cancel();
                                 self.dcx().emit_err(diagnostics::MalformedLoopLabel {
@@ -878,6 +935,14 @@ impl<'a> Parser<'a> {
         mut e: Box<Expr>,
         lo: Span,
     ) -> PResult<'a, Box<Expr>> {
+        // When recovering a missing turbofish lifetime, `e` is an `ExprKind::Err` sentinel
+        // that `parse_expr_assoc_rest` will replace with the correctly-reconstructed node.
+        // Skip postfix parsing here so we don't attach method/call/index suffixes to the
+        // error node before the replacement happens.
+        if self.turbofish_missing_lifetime_recovery.is_some() {
+            return Ok(e);
+        }
+
         let mut res = loop {
             let has_question = if self.prev_token == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
                 // We are using noexpect here because we don't expect a `?` directly after
@@ -1523,10 +1588,7 @@ impl<'a> Parser<'a> {
             } else if this.eat_keyword(exp!(While)) {
                 this.parse_expr_while(None, lo)
             } else if let (Some(label), err) = this.eat_label() {
-                if let Some(e) = err {
-                    e.emit();
-                }
-                this.parse_expr_labeled(label, true)
+                this.parse_expr_labeled(label, true, err)
             } else if this.eat_keyword(exp!(Loop)) {
                 this.parse_expr_loop(None, lo).map_err(|mut err| {
                     err.span_label(lo, "while parsing this `loop` expression");
@@ -1721,10 +1783,57 @@ impl<'a> Parser<'a> {
         &mut self,
         label_: Label,
         mut consume_colon: bool,
+        mut label_err: Option<Diag<'a>>,
     ) -> PResult<'a, Box<Expr>> {
         let lo = label_.ident.span;
         let label = Some(label_);
         let ate_colon = self.eat(exp!(Colon));
+
+        // Intercept `Struct<'_>` / `Struct<'a>` / `Struct<'abc>` missing their turbofish `::`.
+        // Fires when the lifetime is on the RHS of `<` after a path, has no following `:`, and
+        // the next token is `>` — i.e. this was never a real label, just a mistyped type arg.
+        // Reserved-keyword lifetimes (`'_`) already carry a diag; named ones need a fresh one.
+        if !ate_colon
+            && self.restrictions.contains(Restrictions::IS_RHS_OF_LT_AFTER_PATH)
+            && self.check_noexpect(&token::Gt)
+        {
+            let mut err = if let Some(e) = label_err.take() {
+                e
+            } else {
+                self.dcx().create_err(diagnostics::UnexpectedTokenAfterLabel {
+                    span: self.token.span,
+                    remove_label: None,
+                    enclose_in_block: None,
+                })
+            };
+            let (op_span, ident) = self.expected_turbofish_context.take().expect(
+                "IS_RHS_OF_LT_AFTER_PATH is only ever set alongside expected_turbofish_context \
+                     in parse_expr_assoc_rest, so this must be Some here",
+            );
+            err.span_suggestion(
+                op_span.shrink_to_lo(),
+                format!(
+                    "use `::<...>` instead of `<...>` to specify lifetime arguments for `{ident}`"
+                ),
+                "::",
+                Applicability::MachineApplicable,
+            );
+            err.emit();
+            self.bump(); // consume `>`
+
+            // Return an `Err` sentinel so `parse_expr_assoc_rest` can detect the recovery and
+            // graft the lifetime onto the lhs path. We cannot build the final node here because
+            // `lhs` (the path being parameterized) is owned by the caller above us.
+            self.turbofish_missing_lifetime_recovery = Some((label_.ident, label_.ident.span));
+            return Ok(
+                self.mk_expr_err(lo, self.dcx().delayed_bug("turbofish_missing_lifetime_recovery"))
+            );
+        }
+
+        if let Some(e) = label_err.take() {
+            e.emit();
+        }
+
         let tok_sp = self.token.span;
         let expr = if self.eat_keyword(exp!(While)) {
             self.parse_expr_while(label, lo)
@@ -1925,7 +2034,7 @@ impl<'a> Parser<'a> {
         {
             // The value expression can be a labeled loop, see issue #86948, e.g.:
             // `loop { break 'label: loop { break 'label 42; }; }`
-            let lexpr = self.parse_expr_labeled(label, true)?;
+            let lexpr = self.parse_expr_labeled(label, true, None)?;
             self.dcx().emit_err(diagnostics::LabeledLoopInBreak {
                 span: lexpr.span,
                 sub: diagnostics::WrapInParentheses::Expression {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 0171ce57638c8..4d5d7b10812e1 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -243,13 +243,18 @@ pub struct Parser<'a> {
     in_fn_body: bool = false,
     /// Whether we have detected a missing semicolon in function body.
     pub fn_body_missing_semi_guar: Option<ErrorGuaranteed> = None,
+    /// Context passed down to `parse_expr_labeled` for turbofish recovery.
+    pub expected_turbofish_context: Option<(Span, Ident)> = None,
+    /// Recovery state when encountering a missing turbofish for a lifetime argument.
+    pub turbofish_missing_lifetime_recovery: Option<(Ident, Span)> = None,
 }
 
 // This type is used a lot, e.g. it's cloned when matching many declarative macro rules with
-// nonterminals. Make sure it doesn't unintentionally get bigger. We only check a few arches
+// `Parser::try_parse`. Ensure the `Parser` doesn't get excessively large, as it's passed around a lot.
+// We're excluding `i686` and `powerpc` here, as the assert fails due to alignment differences,
 // though, because `TokenTypeSet(u128)` alignment varies on others, changing the total size.
 #[cfg(all(target_pointer_width = "64", any(target_arch = "aarch64", target_arch = "x86_64")))]
-rustc_data_structures::static_assert_size!(Parser<'_>, 288);
+rustc_data_structures::static_assert_size!(Parser<'_>, 336);
 
 /// Stores span information about a closure.
 #[derive(Clone, Debug)]
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index ff057e61f7a04..4fe8d25e21b6c 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -1032,7 +1032,7 @@ impl<'a> Parser<'a> {
                                         segment.ident.span,
                                     ),
                                 };
-                                match self.parse_expr_labeled(label, false) {
+                                match self.parse_expr_labeled(label, false, None) {
                                     Ok(labeled_expr) => {
                                         e.cancel();
                                         self.dcx().emit_err(MalformedLoopLabel {
diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.fixed b/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.fixed
new file mode 100644
index 0000000000000..a6e74d1e2c0cc
--- /dev/null
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.fixed
@@ -0,0 +1,9 @@
+//@ run-rustfix
+struct Struct<'a>(&'a str);
+
+fn main() {
+    let s = Struct::<'_>("hi");
+    //~^ ERROR labels cannot use keyword names
+    //~| HELP use `::<...>` instead of `<...>` to specify lifetime arguments for `Struct`
+    println!("{}", s.0);
+}
diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.rs b/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.rs
new file mode 100644
index 0000000000000..2d6ad02bcadf1
--- /dev/null
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.rs
@@ -0,0 +1,9 @@
+//@ run-rustfix
+struct Struct<'a>(&'a str);
+
+fn main() {
+    let s = Struct<'_>("hi");
+    //~^ ERROR labels cannot use keyword names
+    //~| HELP use `::<...>` instead of `<...>` to specify lifetime arguments for `Struct`
+    println!("{}", s.0);
+}
diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.stderr b/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.stderr
new file mode 100644
index 0000000000000..d1c7249bfcdcb
--- /dev/null
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime-run-pass.stderr
@@ -0,0 +1,13 @@
+error: labels cannot use keyword names
+  --> $DIR/missing-turbofish-lifetime-run-pass.rs:5:20
+   |
+LL |     let s = Struct<'_>("hi");
+   |                    ^^
+   |
+help: use `::<...>` instead of `<...>` to specify lifetime arguments for `Struct`
+   |
+LL |     let s = Struct::<'_>("hi");
+   |                   ++
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime.rs b/tests/ui/parser/recover/missing-turbofish-lifetime.rs
index 596b197a317da..06bad04710c2f 100644
--- a/tests/ui/parser/recover/missing-turbofish-lifetime.rs
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime.rs
@@ -5,24 +5,20 @@ struct Struct<'a> {
 fn struct_with_reserved_lifetime() {
     let _ = Struct<'_> {
         //~^ ERROR labels cannot use keyword names
-        //~| ERROR expected `while`, `for`, `loop` or `{` after a label
-        //~| ERROR comparison operators cannot be chained
         string: "",
     };
 }
 
-fn struct_with_named_lifetime() {
+fn struct_with_named_lifetime<'a>() {
     let _ = Struct<'a> {
         //~^ ERROR expected `while`, `for`, `loop` or `{` after a label
-        //~| ERROR comparison operators cannot be chained
         string: "",
     };
 }
 
-fn struct_with_multichar_lifetime() {
+fn struct_with_multichar_lifetime<'abc>() {
     let _ = Struct<'abc> {
         //~^ ERROR expected `while`, `for`, `loop` or `{` after a label
-        //~| ERROR comparison operators cannot be chained
         string: "",
     };
 }
diff --git a/tests/ui/parser/recover/missing-turbofish-lifetime.stderr b/tests/ui/parser/recover/missing-turbofish-lifetime.stderr
index e14d9d6aa464c..ffad26ef4cf7c 100644
--- a/tests/ui/parser/recover/missing-turbofish-lifetime.stderr
+++ b/tests/ui/parser/recover/missing-turbofish-lifetime.stderr
@@ -3,55 +3,33 @@ error: labels cannot use keyword names
    |
 LL |     let _ = Struct<'_> {
    |                    ^^
-
-error: expected `while`, `for`, `loop` or `{` after a label
-  --> $DIR/missing-turbofish-lifetime.rs:6:22
    |
-LL |     let _ = Struct<'_> {
-   |                      ^ expected `while`, `for`, `loop` or `{` after a label
+help: use `::<...>` instead of `<...>` to specify lifetime arguments for `Struct`
    |
-help: add `'` to close the char literal
-   |
-LL |     let _ = Struct<'_'> {
-   |                      +
-
-error: comparison operators cannot be chained
-  --> $DIR/missing-turbofish-lifetime.rs:6:19
-   |
-LL |     let _ = Struct<'_> {
-   |                   ^  ^
+LL |     let _ = Struct::<'_> {
+   |                   ++
 
 error: expected `while`, `for`, `loop` or `{` after a label
-  --> $DIR/missing-turbofish-lifetime.rs:15:22
+  --> $DIR/missing-turbofish-lifetime.rs:13:22
    |
 LL |     let _ = Struct<'a> {
    |                      ^ expected `while`, `for`, `loop` or `{` after a label
    |
-help: add `'` to close the char literal
-   |
-LL |     let _ = Struct<'a'> {
-   |                      +
-
-error: comparison operators cannot be chained
-  --> $DIR/missing-turbofish-lifetime.rs:15:19
+help: use `::<...>` instead of `<...>` to specify lifetime arguments for `Struct`
    |
-LL |     let _ = Struct<'a> {
-   |                   ^  ^
+LL |     let _ = Struct::<'a> {
+   |                   ++
 
 error: expected `while`, `for`, `loop` or `{` after a label
-  --> $DIR/missing-turbofish-lifetime.rs:23:24
+  --> $DIR/missing-turbofish-lifetime.rs:20:24
    |
 LL |     let _ = Struct<'abc> {
    |                        ^ expected `while`, `for`, `loop` or `{` after a label
-
-error: comparison operators cannot be chained
-  --> $DIR/missing-turbofish-lifetime.rs:23:19
    |
-LL |     let _ = Struct<'abc> {
-   |                   ^    ^
+help: use `::<...>` instead of `<...>` to specify lifetime arguments for `Struct`
    |
-   = help: use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
-   = help: or use `(...)` if you meant to specify fn arguments
+LL |     let _ = Struct::<'abc> {
+   |                   ++
 
-error: aborting due to 7 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/parser/require-parens-for-chained-comparison.rs b/tests/ui/parser/require-parens-for-chained-comparison.rs
index 6152fff6c0365..f2f81e0318e2b 100644
--- a/tests/ui/parser/require-parens-for-chained-comparison.rs
+++ b/tests/ui/parser/require-parens-for-chained-comparison.rs
@@ -27,11 +27,9 @@ fn main() {
     //~| ERROR labels cannot use keyword names
 
     f<'_>();
-    //~^ ERROR comparison operators cannot be chained
-    //~| HELP use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
-    //~| ERROR expected
-    //~| HELP add `'` to close the char literal
+    //~^ ERROR cannot find function `f` in this scope
     //~| ERROR labels cannot use keyword names
+    //~| HELP use `::<...>` instead of `<...>` to specify lifetime arguments for `f`
 
     let _ = f<u8>;
     //~^ ERROR comparison operators cannot be chained
diff --git a/tests/ui/parser/require-parens-for-chained-comparison.stderr b/tests/ui/parser/require-parens-for-chained-comparison.stderr
index 9edfae3625027..df1195ab5c455 100644
--- a/tests/ui/parser/require-parens-for-chained-comparison.stderr
+++ b/tests/ui/parser/require-parens-for-chained-comparison.stderr
@@ -86,31 +86,14 @@ error: labels cannot use keyword names
    |
 LL |     f<'_>();
    |       ^^
-
-error: expected `while`, `for`, `loop` or `{` after a label
-  --> $DIR/require-parens-for-chained-comparison.rs:29:9
-   |
-LL |     f<'_>();
-   |         ^ expected `while`, `for`, `loop` or `{` after a label
    |
-help: add `'` to close the char literal
-   |
-LL |     f<'_'>();
-   |         +
-
-error: comparison operators cannot be chained
-  --> $DIR/require-parens-for-chained-comparison.rs:29:6
-   |
-LL |     f<'_>();
-   |      ^  ^
-   |
-help: use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
+help: use `::<...>` instead of `<...>` to specify lifetime arguments for `f`
    |
 LL |     f::<'_>();
    |      ++
 
 error: comparison operators cannot be chained
-  --> $DIR/require-parens-for-chained-comparison.rs:36:14
+  --> $DIR/require-parens-for-chained-comparison.rs:34:14
    |
 LL |     let _ = f<u8>;
    |              ^  ^
@@ -118,5 +101,12 @@ LL |     let _ = f<u8>;
    = help: use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
    = help: or use `(...)` if you meant to specify fn arguments
 
-error: aborting due to 12 previous errors
+error[E0425]: cannot find function `f` in this scope
+  --> $DIR/require-parens-for-chained-comparison.rs:29:5
+   |
+LL |     f<'_>();
+   |     ^ not found in this scope
+
+error: aborting due to 11 previous errors
 
+For more information about this error, try `rustc --explain E0425`.