Auto merge of #109128 - chenyukang:yukang/remove-type-ascription, r=estebank

Remove type ascription from parser and diagnostics

Mostly based on https://github.com/rust-lang/rust/pull/106826

Part of #101728

r? `@estebank`

compiler/rustc_ast/src/ast.rs

@@ -1589,7 +1589,6 @@ pub enum ClosureBinder {
 pub struct MacCall {
     pub path: Path,
     pub args: P<DelimArgs>,
-    pub prior_type_ascription: Option<(Span, bool)>,
 }
 
 impl MacCall {

compiler/rustc_ast/src/mut_visit.rs

@@ -631,7 +631,7 @@ pub fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
 }
 
 pub fn noop_visit_mac<T: MutVisitor>(mac: &mut MacCall, vis: &mut T) {
-    let MacCall { path, args, prior_type_ascription: _ } = mac;
+    let MacCall { path, args } = mac;
     vis.visit_path(path);
     visit_delim_args(args, vis);
 }

compiler/rustc_ast/src/util/parser.rs

@@ -53,8 +53,6 @@ pub enum AssocOp {
     DotDot,
     /// `..=` range
     DotDotEq,
-    /// `:`
-    Colon,
 }
 
 #[derive(PartialEq, Debug)]
@@ -96,7 +94,6 @@ pub fn from_token(t: &Token) -> Option<AssocOp> {
             token::DotDotEq => Some(DotDotEq),
             // DotDotDot is no longer supported, but we need some way to display the error
             token::DotDotDot => Some(DotDotEq),
-            token::Colon => Some(Colon),
             // `<-` should probably be `< -`
             token::LArrow => Some(Less),
             _ if t.is_keyword(kw::As) => Some(As),
@@ -133,7 +130,7 @@ pub fn from_ast_binop(op: BinOpKind) -> Self {
     pub fn precedence(&self) -> usize {
         use AssocOp::*;
         match *self {
-            As | Colon => 14,
+            As => 14,
             Multiply | Divide | Modulus => 13,
             Add | Subtract => 12,
             ShiftLeft | ShiftRight => 11,
@@ -156,7 +153,7 @@ pub fn fixity(&self) -> Fixity {
             Assign | AssignOp(_) => Fixity::Right,
             As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd
             | BitXor | BitOr | Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual
-            | LAnd | LOr | Colon => Fixity::Left,
+            | LAnd | LOr => Fixity::Left,
             DotDot | DotDotEq => Fixity::None,
         }
     }
@@ -166,8 +163,9 @@ pub fn is_comparison(&self) -> bool {
         match *self {
             Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => true,
             Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add | Subtract
-            | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq
+            | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq => {
-            | Colon => false,
+                false
+            }
         }
     }
 
@@ -177,7 +175,7 @@ pub fn is_assign_like(&self) -> bool {
             Assign | AssignOp(_) => true,
             Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply
             | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor
-            | BitOr | LAnd | LOr | DotDot | DotDotEq | Colon => false,
+            | BitOr | LAnd | LOr | DotDot | DotDotEq => false,
         }
     }
 
@@ -202,7 +200,7 @@ pub fn to_ast_binop(&self) -> Option<BinOpKind> {
             BitOr => Some(BinOpKind::BitOr),
             LAnd => Some(BinOpKind::And),
             LOr => Some(BinOpKind::Or),
-            Assign | AssignOp(_) | As | DotDot | DotDotEq | Colon => None,
+            Assign | AssignOp(_) | As | DotDot | DotDotEq => None,
         }
     }
 
@@ -223,10 +221,9 @@ pub fn can_continue_expr_unambiguously(&self) -> bool {
             Greater | // `{ 42 } > 3`
             GreaterEqual | // `{ 42 } >= 3`
             AssignOp(_) | // `{ 42 } +=`
-            As | // `{ 42 } as usize`
             // Equal | // `{ 42 } == { 42 }`    Accepting these here would regress incorrect
-            // NotEqual | // `{ 42 } != { 42 }` struct literals parser recovery.
+            // NotEqual | // `{ 42 } != { 42 }  struct literals parser recovery.
-            Colon, // `{ 42 }: usize`
+            As // `{ 42 } as usize`
         )
     }
 }
@@ -254,7 +251,6 @@ pub enum ExprPrecedence {
     Binary(BinOpKind),
 
     Cast,
-    Type,
 
     Assign,
     AssignOp,
@@ -313,7 +309,6 @@ pub fn order(self) -> i8 {
             // Binop-like expr kinds, handled by `AssocOp`.
             ExprPrecedence::Binary(op) => AssocOp::from_ast_binop(op).precedence() as i8,
             ExprPrecedence::Cast => AssocOp::As.precedence() as i8,
-            ExprPrecedence::Type => AssocOp::Colon.precedence() as i8,
 
             ExprPrecedence::Assign |
             ExprPrecedence::AssignOp => AssocOp::Assign.precedence() as i8,

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -341,10 +341,16 @@ pub(super) fn print_expr_outer_attr_style(&mut self, expr: &ast::Expr, is_inline
                 self.print_type(ty);
             }
             ast::ExprKind::Type(expr, ty) => {
-                let prec = AssocOp::Colon.precedence() as i8;
+                self.word("type_ascribe!(");
-                self.print_expr_maybe_paren(expr, prec);
+                self.ibox(0);
-                self.word_space(":");
+                self.print_expr(expr);
+
+                self.word(",");
+                self.space_if_not_bol();
                 self.print_type(ty);
+
+                self.end();
+                self.word(")");
             }
             ast::ExprKind::Let(pat, scrutinee, _) => {
                 self.print_let(pat, scrutinee);

compiler/rustc_builtin_macros/src/asm.rs

@@ -68,9 +68,7 @@ pub fn parse_asm_args<'a>(
         if !p.eat(&token::Comma) {
             if allow_templates {
                 // After a template string, we always expect *only* a comma...
-                let mut err = diag.create_err(errors::AsmExpectedComma { span: p.token.span });
+                return Err(diag.create_err(errors::AsmExpectedComma { span: p.token.span }));
-                p.maybe_annotate_with_ascription(&mut err, false);
-                return Err(err);
             } else {
                 // ...after that delegate to `expect` to also include the other expected tokens.
                 return Err(p.expect(&token::Comma).err().unwrap());

compiler/rustc_builtin_macros/src/assert.rs

@@ -61,7 +61,6 @@ pub fn expand_assert<'cx>(
                     delim: MacDelimiter::Parenthesis,
                     tokens,
                 }),
-                prior_type_ascription: None,
             })),
         );
         expr_if_not(cx, call_site_span, cond_expr, then, None)

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -182,7 +182,6 @@ fn build_panic(&self, expr_str: &str, panic_path: Path) -> P<Expr> {
                     delim: MacDelimiter::Parenthesis,
                     tokens: initial.into_iter().chain(captures).collect::<TokenStream>(),
                 }),
-                prior_type_ascription: None,
             })),
         )
     }

compiler/rustc_builtin_macros/src/edition_panic.rs

@@ -63,7 +63,6 @@ fn expand<'cx>(
                     delim: MacDelimiter::Parenthesis,
                     tokens: tts,
                 }),
-                prior_type_ascription: None,
             })),
         ),
     )

compiler/rustc_expand/src/base.rs

@@ -992,7 +992,6 @@ pub struct ExpansionData {
     pub depth: usize,
     pub module: Rc<ModuleData>,
     pub dir_ownership: DirOwnership,
-    pub prior_type_ascription: Option<(Span, bool)>,
     /// Some parent node that is close to this macro call
     pub lint_node_id: NodeId,
     pub is_trailing_mac: bool,
@@ -1043,7 +1042,6 @@ pub fn new(
                 depth: 0,
                 module: Default::default(),
                 dir_ownership: DirOwnership::Owned { relative: None },
-                prior_type_ascription: None,
                 lint_node_id: ast::CRATE_NODE_ID,
                 is_trailing_mac: false,
             },

compiler/rustc_expand/src/expand.rs

@@ -657,8 +657,6 @@ fn expand_invoc(
                     self.parse_ast_fragment(tok_result, fragment_kind, &mac.path, span)
                 }
                 SyntaxExtensionKind::LegacyBang(expander) => {
-                    let prev = self.cx.current_expansion.prior_type_ascription;
-                    self.cx.current_expansion.prior_type_ascription = mac.prior_type_ascription;
                     let tok_result = expander.expand(self.cx, span, mac.args.tokens.clone());
                     let result = if let Some(result) = fragment_kind.make_from(tok_result) {
                         result
@@ -666,7 +664,6 @@ fn expand_invoc(
                         self.error_wrong_fragment_kind(fragment_kind, &mac, span);
                         fragment_kind.dummy(span)
                     };
-                    self.cx.current_expansion.prior_type_ascription = prev;
                     result
                 }
                 _ => unreachable!(),

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -250,8 +250,7 @@ fn expand_macro<'cx>(
                 trace_macros_note(&mut cx.expansions, sp, msg);
             }
 
-            let mut p = Parser::new(sess, tts, false, None);
+            let p = Parser::new(sess, tts, false, None);
-            p.last_type_ascription = cx.current_expansion.prior_type_ascription;
 
             if is_local {
                 cx.resolver.record_macro_rule_usage(node_id, i);

compiler/rustc_expand/src/placeholders.rs

@@ -21,7 +21,6 @@ fn mac_placeholder() -> P<ast::MacCall> {
                 delim: ast::MacDelimiter::Parenthesis,
                 tokens: ast::tokenstream::TokenStream::new(Vec::new()),
             }),
-            prior_type_ascription: None,
         })
     }
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -1407,10 +1407,16 @@ pub fn print_expr(&mut self, expr: &hir::Expr<'_>) {
                 self.print_type(ty);
             }
             hir::ExprKind::Type(expr, ty) => {
-                let prec = AssocOp::Colon.precedence() as i8;
+                self.word("type_ascribe!(");
-                self.print_expr_maybe_paren(expr, prec);
+                self.ibox(0);
-                self.word_space(":");
+                self.print_expr(expr);
+
+                self.word(",");
+                self.space_if_not_bol();
                 self.print_type(ty);
+
+                self.end();
+                self.word(")");
             }
             hir::ExprKind::DropTemps(init) => {
                 // Print `{`:

compiler/rustc_mir_build/src/thir/pattern/usefulness.rs

@@ -685,10 +685,9 @@ enum ArmType {
 /// For example, if we are constructing a witness for the match against
 ///
 /// ```compile_fail,E0004
-/// # #![feature(type_ascription)]
 /// struct Pair(Option<(u32, u32)>, bool);
 /// # fn foo(p: Pair) {
-/// match (p: Pair) {
+/// match p {
 ///    Pair(None, _) => {}
 ///    Pair(_, false) => {}
 /// }

compiler/rustc_parse/messages.ftl

@@ -420,6 +420,15 @@ parse_maybe_fn_typo_with_impl = you might have meant to write `impl` instead of
 parse_expected_fn_path_found_fn_keyword = expected identifier, found keyword `fn`
     .suggestion = use `Fn` to refer to the trait
 
+parse_path_single_colon = path separator must be a double colon
+    .suggestion = use a double colon instead
+
+parse_colon_as_semi = statements are terminated with a semicolon
+    .suggestion = use a semicolon instead
+
+parse_type_ascription_removed =
+    if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+
 parse_where_clause_before_tuple_struct_body = where clauses are not allowed before tuple struct bodies
     .label = unexpected where clause
     .name_label = while parsing this tuple struct

compiler/rustc_parse/src/errors.rs

@@ -1340,6 +1340,28 @@ pub(crate) struct ExpectedFnPathFoundFnKeyword {
     pub fn_token_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_path_single_colon)]
+pub(crate) struct PathSingleColon {
+    #[primary_span]
+    #[suggestion(applicability = "machine-applicable", code = "::")]
+    pub span: Span,
+
+    #[note(parse_type_ascription_removed)]
+    pub type_ascription: Option<()>,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_colon_as_semi)]
+pub(crate) struct ColonAsSemi {
+    #[primary_span]
+    #[suggestion(applicability = "machine-applicable", code = ";")]
+    pub span: Span,
+
+    #[note(parse_type_ascription_removed)]
+    pub type_ascription: Option<()>,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_where_clause_before_tuple_struct_body)]
 pub(crate) struct WhereClauseBeforeTupleStructBody {

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -4,7 +4,7 @@
     TokenExpectType, TokenType,
 };
 use crate::errors::{
-    AmbiguousPlus, AttributeOnParamType, BadQPathStage2, BadTypePlus, BadTypePlusSub,
+    AmbiguousPlus, AttributeOnParamType, BadQPathStage2, BadTypePlus, BadTypePlusSub, ColonAsSemi,
     ComparisonOperatorsCannotBeChained, ComparisonOperatorsCannotBeChainedSugg,
     ConstGenericWithoutBraces, ConstGenericWithoutBracesSugg, DocCommentDoesNotDocumentAnything,
     DocCommentOnParamType, DoubleColonInBound, ExpectedIdentifier, ExpectedSemi, ExpectedSemiSugg,
@@ -84,6 +84,7 @@ fn recovered(qself: Option<P<QSelf>>, path: ast::Path) -> Self {
 }
 
 impl RecoverQPath for Pat {
+    const PATH_STYLE: PathStyle = PathStyle::Pat;
     fn to_ty(&self) -> Option<P<Ty>> {
         self.to_ty()
     }
@@ -663,7 +664,6 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
             err.span_label(sp, label_exp);
             err.span_label(self.token.span, "unexpected token");
         }
-        self.maybe_annotate_with_ascription(&mut err, false);
         Err(err)
     }
 
@@ -788,59 +788,6 @@ pub fn maybe_suggest_struct_literal(
         None
     }
 
-    pub fn maybe_annotate_with_ascription(
-        &mut self,
-        err: &mut Diagnostic,
-        maybe_expected_semicolon: bool,
-    ) {
-        if let Some((sp, likely_path)) = self.last_type_ascription.take() {
-            let sm = self.sess.source_map();
-            let next_pos = sm.lookup_char_pos(self.token.span.lo());
-            let op_pos = sm.lookup_char_pos(sp.hi());
-
-            let allow_unstable = self.sess.unstable_features.is_nightly_build();
-
-            if likely_path {
-                err.span_suggestion(
-                    sp,
-                    "maybe write a path separator here",
-                    "::",
-                    if allow_unstable {
-                        Applicability::MaybeIncorrect
-                    } else {
-                        Applicability::MachineApplicable
-                    },
-                );
-                self.sess.type_ascription_path_suggestions.borrow_mut().insert(sp);
-            } else if op_pos.line != next_pos.line && maybe_expected_semicolon {
-                err.span_suggestion(
-                    sp,
-                    "try using a semicolon",
-                    ";",
-                    Applicability::MaybeIncorrect,
-                );
-            } else if allow_unstable {
-                err.span_label(sp, "tried to parse a type due to this type ascription");
-            } else {
-                err.span_label(sp, "tried to parse a type due to this");
-            }
-            if allow_unstable {
-                // Give extra information about type ascription only if it's a nightly compiler.
-                err.note(
-                    "`#![feature(type_ascription)]` lets you annotate an expression with a type: \
-                     `<expr>: <type>`",
-                );
-                if !likely_path {
-                    // Avoid giving too much info when it was likely an unrelated typo.
-                    err.note(
-                        "see issue #23416 <https://github.com/rust-lang/rust/issues/23416> \
-                        for more information",
-                    );
-                }
-            }
-        }
-    }
-
     /// Eats and discards tokens until one of `kets` is encountered. Respects token trees,
     /// passes through any errors encountered. Used for error recovery.
     pub(super) fn eat_to_tokens(&mut self, kets: &[&TokenKind]) {
@@ -1622,12 +1569,36 @@ pub(super) fn unexpected_try_recover(
     }
 
     pub(super) fn expect_semi(&mut self) -> PResult<'a, ()> {
-        if self.eat(&token::Semi) {
+        if self.eat(&token::Semi) || self.recover_colon_as_semi() {
             return Ok(());
         }
         self.expect(&token::Semi).map(drop) // Error unconditionally
     }
 
+    pub(super) fn recover_colon_as_semi(&mut self) -> bool {
+        let line_idx = |span: Span| {
+            self.sess
+                .source_map()
+                .span_to_lines(span)
+                .ok()
+                .and_then(|lines| Some(lines.lines.get(0)?.line_index))
+        };
+
+        if self.may_recover()
+            && self.token == token::Colon
+            && self.look_ahead(1, |next| line_idx(self.token.span) < line_idx(next.span))
+        {
+            self.sess.emit_err(ColonAsSemi {
+                span: self.token.span,
+                type_ascription: self.sess.unstable_features.is_nightly_build().then_some(()),
+            });
+            self.bump();
+            return true;
+        }
+
+        false
+    }
+
     /// Consumes alternative await syntaxes like `await!(<expr>)`, `await <expr>`,
     /// `await? <expr>`, `await(<expr>)`, and `await { <expr> }`.
     pub(super) fn recover_incorrect_await_syntax(
@@ -1790,24 +1761,6 @@ pub(super) fn recover_parens_around_for_head(
         }
     }
 
-    pub(super) fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool {
-        (self.token == token::Lt && // `foo:<bar`, likely a typoed turbofish.
-            self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident()))
-            || self.token.is_ident() &&
-            matches!(node, ast::ExprKind::Path(..) | ast::ExprKind::Field(..)) &&
-            !self.token.is_reserved_ident() &&           // v `foo:bar(baz)`
-            self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Parenthesis))
-            || self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Brace)) // `foo:bar {`
-            || self.look_ahead(1, |t| t == &token::Colon) &&     // `foo:bar::<baz`
-            self.look_ahead(2, |t| t == &token::Lt) &&
-            self.look_ahead(3, |t| t.is_ident())
-            || self.look_ahead(1, |t| t == &token::Colon) &&  // `foo:bar:baz`
-            self.look_ahead(2, |t| t.is_ident())
-            || self.look_ahead(1, |t| t == &token::ModSep)
-                && (self.look_ahead(2, |t| t.is_ident()) ||   // `foo:bar::baz`
-            self.look_ahead(2, |t| t == &token::Lt)) // `foo:bar::<baz>`
-    }
-
     pub(super) fn recover_seq_parse_error(
         &mut self,
         delim: Delimiter,
@@ -1902,7 +1855,6 @@ pub(super) fn recover_stmt_(
                         && brace_depth == 0
                         && bracket_depth == 0 =>
                 {
-                    debug!("recover_stmt_ return - Semi");
                     break;
                 }
                 _ => self.bump(),

compiler/rustc_parse/src/parser/expr.rs

@@ -174,10 +174,8 @@ pub(super) fn parse_expr_assoc_with(
                 self.parse_expr_prefix(attrs)?
             }
         };
-        let last_type_ascription_set = self.last_type_ascription.is_some();
 
         if !self.should_continue_as_assoc_expr(&lhs) {
-            self.last_type_ascription = None;
             return Ok(lhs);
         }
 
@@ -301,9 +299,6 @@ pub(super) fn parse_expr_assoc_with(
             if op == AssocOp::As {
                 lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Cast)?;
                 continue;
-            } else if op == AssocOp::Colon {
-                lhs = self.parse_assoc_op_ascribe(lhs, lhs_span)?;
-                continue;
             } else if op == AssocOp::DotDot || op == AssocOp::DotDotEq {
                 // If we didn't have to handle `x..`/`x..=`, it would be pretty easy to
                 // generalise it to the Fixity::None code.
@@ -364,7 +359,7 @@ pub(super) fn parse_expr_assoc_with(
                     let aopexpr = self.mk_assign_op(source_map::respan(cur_op_span, aop), lhs, rhs);
                     self.mk_expr(span, aopexpr)
                 }
-                AssocOp::As | AssocOp::Colon | AssocOp::DotDot | AssocOp::DotDotEq => {
+                AssocOp::As | AssocOp::DotDot | AssocOp::DotDotEq => {
                     self.span_bug(span, "AssocOp should have been handled by special case")
                 }
             };
@@ -373,9 +368,7 @@ pub(super) fn parse_expr_assoc_with(
                 break;
             }
         }
-        if last_type_ascription_set {
+
-            self.last_type_ascription = None;
-        }
         Ok(lhs)
     }
 
@@ -743,7 +736,7 @@ fn parse_assoc_op_cast(
                     (
                         // `foo: `
                         ExprKind::Path(None, ast::Path { segments, .. }),
-                        TokenKind::Ident(kw::For | kw::Loop | kw::While, false),
+                        token::Ident(kw::For | kw::Loop | kw::While, false),
                     ) if segments.len() == 1 => {
                         let snapshot = self.create_snapshot_for_diagnostic();
                         let label = Label {
@@ -838,21 +831,19 @@ fn parse_and_disallow_postfix_after_cast(
         &mut self,
         cast_expr: P<Expr>,
     ) -> PResult<'a, P<Expr>> {
+        if let ExprKind::Type(_, _) = cast_expr.kind {
+            panic!("ExprKind::Type must not be parsed");
+        }
+
         let span = cast_expr.span;
-        let (cast_kind, maybe_ascription_span) =
-            if let ExprKind::Type(ascripted_expr, _) = &cast_expr.kind {
-                ("type ascription", Some(ascripted_expr.span.shrink_to_hi().with_hi(span.hi())))
-            } else {
-                ("cast", None)
-            };
 
         let with_postfix = self.parse_expr_dot_or_call_with_(cast_expr, span)?;
 
         // Check if an illegal postfix operator has been added after the cast.
         // If the resulting expression is not a cast, it is an illegal postfix operator.
-        if !matches!(with_postfix.kind, ExprKind::Cast(_, _) | ExprKind::Type(_, _)) {
+        if !matches!(with_postfix.kind, ExprKind::Cast(_, _)) {
             let msg = format!(
-                "{cast_kind} cannot be followed by {}",
+                "cast cannot be followed by {}",
                 match with_postfix.kind {
                     ExprKind::Index(_, _) => "indexing",
                     ExprKind::Try(_) => "`?`",
@@ -878,44 +869,13 @@ fn parse_and_disallow_postfix_after_cast(
                 );
             };
 
-            // If type ascription is "likely an error", the user will already be getting a useful
+            suggest_parens(&mut err);
-            // help message, and doesn't need a second.
+
-            if self.last_type_ascription.map_or(false, |last_ascription| last_ascription.1) {
-                self.maybe_annotate_with_ascription(&mut err, false);
-            } else if let Some(ascription_span) = maybe_ascription_span {
-                let is_nightly = self.sess.unstable_features.is_nightly_build();
-                if is_nightly {
-                    suggest_parens(&mut err);
-                }
-                err.span_suggestion(
-                    ascription_span,
-                    &format!(
-                        "{}remove the type ascription",
-                        if is_nightly { "alternatively, " } else { "" }
-                    ),
-                    "",
-                    if is_nightly {
-                        Applicability::MaybeIncorrect
-                    } else {
-                        Applicability::MachineApplicable
-                    },
-                );
-            } else {
-                suggest_parens(&mut err);
-            }
             err.emit();
         };
         Ok(with_postfix)
     }
 
-    fn parse_assoc_op_ascribe(&mut self, lhs: P<Expr>, lhs_span: Span) -> PResult<'a, P<Expr>> {
-        let maybe_path = self.could_ascription_be_path(&lhs.kind);
-        self.last_type_ascription = Some((self.prev_token.span, maybe_path));
-        let lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Type)?;
-        self.sess.gated_spans.gate(sym::type_ascription, lhs.span);
-        Ok(lhs)
-    }
-
     /// Parse `& mut? <expr>` or `& raw [ const | mut ] <expr>`.
     fn parse_expr_borrow(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
         self.expect_and()?;
@@ -1010,7 +970,7 @@ fn parse_expr_dot_or_call_with_(&mut self, mut e: P<Expr>, lo: Span) -> PResult<
             };
             if has_dot {
                 // expr.f
-                e = self.parse_expr_dot_suffix(lo, e)?;
+                e = self.parse_dot_suffix_expr(lo, e)?;
                 continue;
             }
             if self.expr_is_complete(&e) {
@@ -1024,13 +984,7 @@ fn parse_expr_dot_or_call_with_(&mut self, mut e: P<Expr>, lo: Span) -> PResult<
         }
     }
 
-    fn look_ahead_type_ascription_as_field(&mut self) -> bool {
+    fn parse_dot_suffix_expr(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>> {
-        self.look_ahead(1, |t| t.is_ident())
-            && self.look_ahead(2, |t| t == &token::Colon)
-            && self.look_ahead(3, |t| t.can_begin_expr())
-    }
-
-    fn parse_expr_dot_suffix(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>> {
         match self.token.uninterpolate().kind {
             token::Ident(..) => self.parse_dot_suffix(base, lo),
             token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) => {
@@ -1183,9 +1137,7 @@ fn parse_expr_tuple_field_access(
 
     /// Parse a function call expression, `expr(...)`.
     fn parse_expr_fn_call(&mut self, lo: Span, fun: P<Expr>) -> P<Expr> {
-        let snapshot = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
+        let snapshot = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
-            && self.look_ahead_type_ascription_as_field()
-        {
             Some((self.create_snapshot_for_diagnostic(), fun.kind.clone()))
         } else {
             None
@@ -1216,7 +1168,6 @@ fn maybe_recover_struct_lit_bad_delims(
         if !self.may_recover() {
             return None;
         }
-
         match (seq.as_mut(), snapshot) {
             (Err(err), Some((mut snapshot, ExprKind::Path(None, path)))) => {
                 snapshot.bump(); // `(`
@@ -1260,9 +1211,7 @@ fn maybe_recover_struct_lit_bad_delims(
                         return Some(self.mk_expr_err(span));
                     }
                     Ok(_) => {}
-                    Err(mut err) => {
+                    Err(err) => err.cancel(),
-                        err.emit();
-                    }
                 }
             }
             _ => {}
@@ -1516,7 +1465,6 @@ fn parse_expr_path_start(&mut self) -> PResult<'a, P<Expr>> {
             let mac = P(MacCall {
                 path,
                 args: self.parse_delim_args()?,
-                prior_type_ascription: self.last_type_ascription,
             });
             (lo.to(self.prev_token.span), ExprKind::MacCall(mac))
         } else if self.check(&token::OpenDelim(Delimiter::Brace))
@@ -1535,7 +1483,7 @@ fn parse_expr_path_start(&mut self) -> PResult<'a, P<Expr>> {
     }
 
     /// Parse `'label: $expr`. The label is already parsed.
-    fn parse_expr_labeled(
+    pub(super) fn parse_expr_labeled(
         &mut self,
         label_: Label,
         mut consume_colon: bool,
@@ -3013,6 +2961,11 @@ pub(super) fn parse_struct_fields(
                     } else {
                         e.span_label(pth.span, "while parsing this struct");
                     }
+
+                    if !recover {
+                        return Err(e);
+                    }
+
                     e.emit();
 
                     // If the next token is a comma, then try to parse
@@ -3024,6 +2977,7 @@ pub(super) fn parse_struct_fields(
                             break;
                         }
                     }
+
                     None
                 }
             };

compiler/rustc_parse/src/parser/item.rs

@@ -443,7 +443,7 @@ fn parse_item_macro(&mut self, vis: &Visibility) -> PResult<'a, MacCall> {
             Ok(args) => {
                 self.eat_semi_for_macro_if_needed(&args);
                 self.complain_if_pub_macro(vis, false);
-                Ok(MacCall { path, args, prior_type_ascription: self.last_type_ascription })
+                Ok(MacCall { path, args })
             }
 
             Err(mut err) => {

compiler/rustc_parse/src/parser/mod.rs

@@ -148,9 +148,6 @@ pub struct Parser<'a> {
     max_angle_bracket_count: u32,
 
     last_unexpected_token_span: Option<Span>,
-    /// Span pointing at the `:` for the last type ascription the parser has seen, and whether it
-    /// looked like it could have been a mistyped path or literal `Option:Some(42)`).
-    pub last_type_ascription: Option<(Span, bool /* likely path typo */)>,
     /// If present, this `Parser` is not parsing Rust code but rather a macro call.
     subparser_name: Option<&'static str>,
     capture_state: CaptureState,
@@ -165,7 +162,7 @@ pub struct Parser<'a> {
 // 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.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Parser<'_>, 288);
+rustc_data_structures::static_assert_size!(Parser<'_>, 272);
 
 /// Stores span information about a closure.
 #[derive(Clone)]
@@ -470,7 +467,6 @@ pub fn new(
             unmatched_angle_bracket_count: 0,
             max_angle_bracket_count: 0,
             last_unexpected_token_span: None,
-            last_type_ascription: None,
             subparser_name,
             capture_state: CaptureState {
                 capturing: Capturing::No,
@@ -941,10 +937,14 @@ fn parse_seq_to_before_tokens<T>(
                                         // propagate the help message from sub error 'e' to main error 'expect_err;
                                         expect_err.children.push(xx.clone());
                                     }
-                                    expect_err.emit();
-
                                     e.cancel();
-                                    break;
+                                    if self.token == token::Colon {
+                                        // we will try to recover in `maybe_recover_struct_lit_bad_delims`
+                                        return Err(expect_err);
+                                    } else {
+                                        expect_err.emit();
+                                        break;
+                                    }
                                 }
                             }
                         }

compiler/rustc_parse/src/parser/pat.rs

@@ -406,11 +406,11 @@ fn parse_pat_with_range_pat(
             // Parse pattern starting with a path
             let (qself, path) = if self.eat_lt() {
                 // Parse a qualified path
-                let (qself, path) = self.parse_qpath(PathStyle::Expr)?;
+                let (qself, path) = self.parse_qpath(PathStyle::Pat)?;
                 (Some(qself), path)
             } else {
                 // Parse an unqualified path
-                (None, self.parse_path(PathStyle::Expr)?)
+                (None, self.parse_path(PathStyle::Pat)?)
             };
             let span = lo.to(self.prev_token.span);
 
@@ -666,7 +666,7 @@ fn recover_additional_muts(&mut self) {
     fn parse_pat_mac_invoc(&mut self, path: Path) -> PResult<'a, PatKind> {
         self.bump();
         let args = self.parse_delim_args()?;
-        let mac = P(MacCall { path, args, prior_type_ascription: self.last_type_ascription });
+        let mac = P(MacCall { path, args });
         Ok(PatKind::MacCall(mac))
     }
 
@@ -789,11 +789,11 @@ fn parse_pat_range_end(&mut self) -> PResult<'a, P<Expr>> {
             let lo = self.token.span;
             let (qself, path) = if self.eat_lt() {
                 // Parse a qualified path
-                let (qself, path) = self.parse_qpath(PathStyle::Expr)?;
+                let (qself, path) = self.parse_qpath(PathStyle::Pat)?;
                 (Some(qself), path)
             } else {
                 // Parse an unqualified path
-                (None, self.parse_path(PathStyle::Expr)?)
+                (None, self.parse_path(PathStyle::Pat)?)
             };
             let hi = self.prev_token.span;
             Ok(self.mk_expr(lo.to(hi), ExprKind::Path(qself, path)))

compiler/rustc_parse/src/parser/path.rs

@@ -1,5 +1,6 @@
 use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
 use super::{Parser, Restrictions, TokenType};
+use crate::errors::PathSingleColon;
 use crate::{errors, maybe_whole};
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter, Token, TokenKind};
@@ -8,7 +9,7 @@
     AssocConstraintKind, BlockCheckMode, GenericArg, GenericArgs, Generics, ParenthesizedArgs,
     Path, PathSegment, QSelf,
 };
-use rustc_errors::{Applicability, PResult};
+use rustc_errors::{Applicability, IntoDiagnostic, PResult};
 use rustc_span::source_map::{BytePos, Span};
 use rustc_span::symbol::{kw, sym, Ident};
 use std::mem;
@@ -24,7 +25,19 @@ pub enum PathStyle {
     /// In all such contexts the non-path interpretation is preferred by default for practical
     /// reasons, but the path interpretation can be forced by the disambiguator `::`, e.g.
     /// `x<y>` - comparisons, `x::<y>` - unambiguously a path.
+    ///
+    /// Also, a path may never be followed by a `:`. This means that we can eagerly recover if
+    /// we encounter it.
     Expr,
+    /// The same as `Expr`, but may be followed by a `:`.
+    /// For example, this code:
+    /// ```rust
+    /// struct S;
+    ///
+    /// let S: S;
+    /// //  ^ Followed by a `:`
+    /// ```
+    Pat,
     /// In other contexts, notably in types, no ambiguity exists and paths can be written
     /// without the disambiguator, e.g., `x<y>` - unambiguously a path.
     /// Paths with disambiguators are still accepted, `x::<Y>` - unambiguously a path too.
@@ -38,6 +51,12 @@ pub enum PathStyle {
     Mod,
 }
 
+impl PathStyle {
+    fn has_generic_ambiguity(&self) -> bool {
+        matches!(self, Self::Expr | Self::Pat)
+    }
+}
+
 impl<'a> Parser<'a> {
     /// Parses a qualified path.
     /// Assumes that the leading `<` has been parsed already.
@@ -183,7 +202,6 @@ pub(super) fn parse_path_inner(
             segments.push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
         }
         self.parse_path_segments(&mut segments, style, ty_generics)?;
-
         Ok(Path { segments, span: lo.to(self.prev_token.span), tokens: None })
     }
 
@@ -195,7 +213,7 @@ pub(super) fn parse_path_segments(
     ) -> PResult<'a, ()> {
         loop {
             let segment = self.parse_path_segment(style, ty_generics)?;
-            if style == PathStyle::Expr {
+            if style.has_generic_ambiguity() {
                 // In order to check for trailing angle brackets, we must have finished
                 // recursing (`parse_path_segment` can indirectly call this function),
                 // that is, the next token must be the highlighted part of the below example:
@@ -217,6 +235,29 @@ pub(super) fn parse_path_segments(
             segments.push(segment);
 
             if self.is_import_coupler() || !self.eat(&token::ModSep) {
+                if style == PathStyle::Expr
+                    && self.may_recover()
+                    && self.token == token::Colon
+                    && self.look_ahead(1, |token| token.is_ident() && !token.is_reserved_ident())
+                {
+                    // Emit a special error message for `a::b:c` to help users
+                    // otherwise, `a: c` might have meant to introduce a new binding
+                    if self.token.span.lo() == self.prev_token.span.hi()
+                        && self.look_ahead(1, |token| self.token.span.hi() == token.span.lo())
+                    {
+                        self.bump(); // bump past the colon
+                        self.sess.emit_err(PathSingleColon {
+                            span: self.prev_token.span,
+                            type_ascription: self
+                                .sess
+                                .unstable_features
+                                .is_nightly_build()
+                                .then_some(()),
+                        });
+                    }
+                    continue;
+                }
+
                 return Ok(());
             }
         }
@@ -270,8 +311,25 @@ pub(super) fn parse_path_segment(
                         ty_generics,
                     )?;
                     self.expect_gt().map_err(|mut err| {
+                        // Try to recover a `:` into a `::`
+                        if self.token == token::Colon
+                            && self.look_ahead(1, |token| {
+                                token.is_ident() && !token.is_reserved_ident()
+                            })
+                        {
+                            err.cancel();
+                            err = PathSingleColon {
+                                span: self.token.span,
+                                type_ascription: self
+                                    .sess
+                                    .unstable_features
+                                    .is_nightly_build()
+                                    .then_some(()),
+                            }
+                            .into_diagnostic(self.diagnostic());
+                        }
                         // Attempt to find places where a missing `>` might belong.
-                        if let Some(arg) = args
+                        else if let Some(arg) = args
                             .iter()
                             .rev()
                             .find(|arg| !matches!(arg, AngleBracketedArg::Constraint(_)))

compiler/rustc_parse/src/parser/stmt.rs

@@ -10,6 +10,8 @@
 use crate::errors;
 use crate::maybe_whole;
 
+use crate::errors::MalformedLoopLabel;
+use ast::Label;
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter, TokenKind};
@@ -19,7 +21,8 @@
 use rustc_ast::{StmtKind, DUMMY_NODE_ID};
 use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed, PResult};
 use rustc_span::source_map::{BytePos, Span};
-use rustc_span::symbol::{kw, sym};
+use rustc_span::symbol::{kw, sym, Ident};
+
 use std::mem;
 use thin_vec::{thin_vec, ThinVec};
 
@@ -186,7 +189,7 @@ fn parse_stmt_mac(&mut self, lo: Span, attrs: AttrVec, path: ast::Path) -> PResu
             _ => MacStmtStyle::NoBraces,
         };
 
-        let mac = P(MacCall { path, args, prior_type_ascription: self.last_type_ascription });
+        let mac = P(MacCall { path, args });
 
         let kind = if (style == MacStmtStyle::Braces
             && self.token != token::Dot
@@ -546,10 +549,36 @@ pub(crate) fn parse_block_tail(
             }
             let stmt = match self.parse_full_stmt(recover) {
                 Err(mut err) if recover.yes() => {
-                    self.maybe_annotate_with_ascription(&mut err, false);
                     if let Some(ref mut snapshot) = snapshot {
                         snapshot.recover_diff_marker();
                     }
+                    if self.token == token::Colon {
+                        // if next token is following a colon, it's likely a path
+                        // and we can suggest a path separator
+                        let ident_span = self.prev_token.span;
+                        self.bump();
+                        if self.token.span.lo() == self.prev_token.span.hi() {
+                            err.span_suggestion_verbose(
+                                self.prev_token.span,
+                                "maybe write a path separator here",
+                                "::",
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                        if self.look_ahead(1, |token| token == &token::Eq) {
+                            err.span_suggestion_verbose(
+                                ident_span.shrink_to_lo(),
+                                "you might have meant to introduce a new binding",
+                                "let ",
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                        if self.sess.unstable_features.is_nightly_build() {
+                            // FIXME(Nilstrieb): Remove this again after a few months.
+                            err.note("type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>");
+                        }
+                    }
+
                     err.emit();
                     self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
                     Some(self.mk_stmt_err(self.token.span))
@@ -580,19 +609,25 @@ pub fn parse_full_stmt(
         };
 
         let mut eat_semi = true;
+        let mut add_semi_to_stmt = false;
+
         match &mut stmt.kind {
             // Expression without semicolon.
             StmtKind::Expr(expr)
                 if self.token != token::Eof && classify::expr_requires_semi_to_be_stmt(expr) => {
                 // Just check for errors and recover; do not eat semicolon yet.
                 // `expect_one_of` returns PResult<'a, bool /* recovered */>
-                let replace_with_err =
+
-                    match self.expect_one_of(&[], &[token::Semi, token::CloseDelim(Delimiter::Brace)]) {
+                let expect_result = self.expect_one_of(&[], &[token::Semi, token::CloseDelim(Delimiter::Brace)]);
+
+                let replace_with_err = 'break_recover: {
+                    match expect_result {
                     // Recover from parser, skip type error to avoid extra errors.
-                    Ok(true) => true,
+                        Ok(true) => true,
-                    Err(mut e) => {
+                        Err(mut e) => {
-                        if let TokenKind::DocComment(..) = self.token.kind &&
+                            if let TokenKind::DocComment(..) = self.token.kind
-                            let Ok(snippet) = self.span_to_snippet(self.token.span) {
+                                && let Ok(snippet) = self.span_to_snippet(self.token.span)
+                            {
                                 let sp = self.token.span;
                                 let marker = &snippet[..3];
                                 let (comment_marker, doc_comment_marker) = marker.split_at(2);
@@ -606,21 +641,72 @@ pub fn parse_full_stmt(
                                     format!("{} {}", comment_marker, doc_comment_marker),
                                     Applicability::MaybeIncorrect,
                                 );
-                        }
-
-                        if let Err(mut e) =
-                            self.check_mistyped_turbofish_with_multiple_type_params(e, expr)
-                        {
-                            if recover.no() {
-                                return Err(e);
                             }
-                            e.emit();
+
-                            self.recover_stmt();
+                            if self.recover_colon_as_semi() {
+                                // recover_colon_as_semi has already emitted a nicer error.
+                                e.delay_as_bug();
+                                add_semi_to_stmt = true;
+                                eat_semi = false;
+
+                                break 'break_recover false;
+                            }
+
+                            match &expr.kind {
+                                ExprKind::Path(None, ast::Path { segments, .. }) if segments.len() == 1 => {
+                                    if self.token == token::Colon
+                                        && self.look_ahead(1, |token| {
+                                            token.is_whole_block() || matches!(
+                                                token.kind,
+                                                token::Ident(kw::For | kw::Loop | kw::While, false)
+                                                    | token::OpenDelim(Delimiter::Brace)
+                                            )
+                                        })
+                                    {
+                                        let snapshot = self.create_snapshot_for_diagnostic();
+                                        let label = Label {
+                                            ident: Ident::from_str_and_span(
+                                                &format!("'{}", segments[0].ident),
+                                                segments[0].ident.span,
+                                            ),
+                                        };
+                                        match self.parse_expr_labeled(label, false) {
+                                            Ok(labeled_expr) => {
+                                                e.delay_as_bug();
+                                                self.sess.emit_err(MalformedLoopLabel {
+                                                    span: label.ident.span,
+                                                    correct_label: label.ident,
+                                                });
+                                                *expr = labeled_expr;
+                                                break 'break_recover false;
+                                            }
+                                            Err(err) => {
+                                                err.cancel();
+                                                self.restore_snapshot(snapshot);
+                                            }
+                                        }
+                                    }
+                                }
+                                _ => {}
+                            }
+
+                            if let Err(mut e) =
+                                self.check_mistyped_turbofish_with_multiple_type_params(e, expr)
+                            {
+                                if recover.no() {
+                                    return Err(e);
+                                }
+                                e.emit();
+                                self.recover_stmt();
+                            }
+
+                            true
+
                         }
-                        true
+                        Ok(false) => false
                     }
-                    _ => false
                 };
+
                 if replace_with_err {
                     // We already emitted an error, so don't emit another type error
                     let sp = expr.span.to(self.prev_token.span);
@@ -643,9 +729,10 @@ pub fn parse_full_stmt(
             StmtKind::Empty | StmtKind::Item(_) | StmtKind::Local(_) | StmtKind::Semi(_) => eat_semi = false,
         }
 
-        if eat_semi && self.eat(&token::Semi) {
+        if add_semi_to_stmt || (eat_semi && self.eat(&token::Semi)) {
             stmt = stmt.add_trailing_semicolon();
         }
+
         stmt.span = stmt.span.to(self.prev_token.span);
         Ok(Some(stmt))
     }

compiler/rustc_parse/src/parser/ty.rs

@@ -317,7 +317,6 @@ fn parse_ty_common(
             let msg = format!("expected type, found {}", super::token_descr(&self.token));
             let mut err = self.struct_span_err(self.token.span, &msg);
             err.span_label(self.token.span, "expected type");
-            self.maybe_annotate_with_ascription(&mut err, true);
             return Err(err);
         };
 
@@ -651,11 +650,7 @@ fn parse_path_start_ty(
         let path = self.parse_path_inner(PathStyle::Type, ty_generics)?;
         if self.eat(&token::Not) {
             // Macro invocation in type position
-            Ok(TyKind::MacCall(P(MacCall {
+            Ok(TyKind::MacCall(P(MacCall { path, args: self.parse_delim_args()? })))
-                path,
-                args: self.parse_delim_args()?,
-                prior_type_ascription: self.last_type_ascription,
-            })))
         } else if allow_plus == AllowPlus::Yes && self.check_plus() {
             // `Trait1 + Trait2 + 'a`
             self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true)

compiler/rustc_resolve/src/ident.rs

@@ -1345,7 +1345,13 @@ pub(crate) fn resolve_path_with_ribs(
         ribs: Option<&PerNS<Vec<Rib<'a>>>>,
         ignore_binding: Option<&'a NameBinding<'a>>,
     ) -> PathResult<'a> {
-        debug!("resolve_path(path={:?}, opt_ns={:?}, finalize={:?})", path, opt_ns, finalize);
+        debug!(
+            "resolve_path(path={:?}, opt_ns={:?}, finalize={:?}) path_len: {}",
+            path,
+            opt_ns,
+            finalize,
+            path.len()
+        );
 
         let mut module = None;
         let mut allow_super = true;

compiler/rustc_resolve/src/late.rs

@@ -548,9 +548,6 @@ struct DiagnosticMetadata<'ast> {
     /// they are used (in a `break` or `continue` statement)
     unused_labels: FxHashMap<NodeId, Span>,
 
-    /// Only used for better errors on `fn(): fn()`.
-    current_type_ascription: Vec<Span>,
-
     /// Only used for better errors on `let x = { foo: bar };`.
     /// In the case of a parse error with `let x = { foo: bar, };`, this isn't needed, it's only
     /// needed for cases where this parses as a correct type ascription.
@@ -4064,17 +4061,8 @@ fn resolve_expr(&mut self, expr: &'ast Expr, parent: Option<&'ast Expr>) {
                     }
                 }
             }
-            ExprKind::Type(ref type_expr, ref ty) => {
+            ExprKind::Type(ref _type_expr, ref _ty) => {
-                // `ParseSess::type_ascription_path_suggestions` keeps spans of colon tokens in
-                // type ascription. Here we are trying to retrieve the span of the colon token as
-                // well, but only if it's written without spaces `expr:Ty` and therefore confusable
-                // with `expr::Ty`, only in this case it will match the span from
-                // `type_ascription_path_suggestions`.
-                self.diagnostic_metadata
-                    .current_type_ascription
-                    .push(type_expr.span.between(ty.span));
                 visit::walk_expr(self, expr);
-                self.diagnostic_metadata.current_type_ascription.pop();
             }
             // `async |x| ...` gets desugared to `|x| async {...}`, so we need to
             // resolve the arguments within the proper scopes so that usages of them inside the

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -28,7 +28,7 @@
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::{BytePos, Span};
+use rustc_span::Span;
 
 use std::iter;
 use std::ops::Deref;
@@ -350,18 +350,15 @@ pub(crate) fn smart_resolve_report_errors(
             return (err, candidates);
         }
 
-        if !self.type_ascription_suggestion(&mut err, base_error.span) {
+        let mut fallback = self.suggest_trait_and_bounds(&mut err, source, res, span, &base_error);
-            let mut fallback =
-                self.suggest_trait_and_bounds(&mut err, source, res, span, &base_error);
 
-            // if we have suggested using pattern matching, then don't add needless suggestions
+        // if we have suggested using pattern matching, then don't add needless suggestions
-            // for typos.
+        // for typos.
-            fallback |= self.suggest_typo(&mut err, source, path, span, &base_error);
+        fallback |= self.suggest_typo(&mut err, source, path, span, &base_error);
 
-            if fallback {
+        if fallback {
-                // Fallback label.
+            // Fallback label.
-                err.span_label(base_error.span, &base_error.fallback_label);
+            err.span_label(base_error.span, &base_error.fallback_label);
-            }
         }
         self.err_code_special_cases(&mut err, source, path, span);
 
@@ -494,24 +491,6 @@ fn try_lookup_name_relaxed(
                 .filter(|(_, enum_ty_path)| !enum_ty_path.starts_with("std::prelude::"))
                 .collect();
             if !enum_candidates.is_empty() {
-                if let (PathSource::Type, Some(span)) =
-                    (source, self.diagnostic_metadata.current_type_ascription.last())
-                {
-                    if self
-                        .r
-                        .tcx
-                        .sess
-                        .parse_sess
-                        .type_ascription_path_suggestions
-                        .borrow()
-                        .contains(span)
-                    {
-                        // Already reported this issue on the lhs of the type ascription.
-                        err.downgrade_to_delayed_bug();
-                        return (true, candidates);
-                    }
-                }
-
                 enum_candidates.sort();
 
                 // Contextualize for E0412 "cannot find type", but don't belabor the point
@@ -1393,26 +1372,6 @@ fn smart_resolve_context_dependent_help(
                 Res::Def(DefKind::Enum, def_id),
                 PathSource::TupleStruct(..) | PathSource::Expr(..),
             ) => {
-                if self
-                    .diagnostic_metadata
-                    .current_type_ascription
-                    .last()
-                    .map(|sp| {
-                        self.r
-                            .tcx
-                            .sess
-                            .parse_sess
-                            .type_ascription_path_suggestions
-                            .borrow()
-                            .contains(&sp)
-                    })
-                    .unwrap_or(false)
-                {
-                    err.downgrade_to_delayed_bug();
-                    // We already suggested changing `:` into `::` during parsing.
-                    return false;
-                }
-
                 self.suggest_using_enum_variant(err, source, def_id, span);
             }
             (Res::Def(DefKind::Struct, def_id), source) if ns == ValueNS => {
@@ -1817,80 +1776,6 @@ fn likely_rust_type(path: &[Segment]) -> Option<Symbol> {
         })
     }
 
-    /// Only used in a specific case of type ascription suggestions
-    fn get_colon_suggestion_span(&self, start: Span) -> Span {
-        let sm = self.r.tcx.sess.source_map();
-        start.to(sm.next_point(start))
-    }
-
-    fn type_ascription_suggestion(&self, err: &mut Diagnostic, base_span: Span) -> bool {
-        let sm = self.r.tcx.sess.source_map();
-        let base_snippet = sm.span_to_snippet(base_span);
-        if let Some(&sp) = self.diagnostic_metadata.current_type_ascription.last() {
-            if let Ok(snippet) = sm.span_to_snippet(sp) {
-                let len = snippet.trim_end().len() as u32;
-                if snippet.trim() == ":" {
-                    let colon_sp =
-                        sp.with_lo(sp.lo() + BytePos(len - 1)).with_hi(sp.lo() + BytePos(len));
-                    let mut show_label = true;
-                    if sm.is_multiline(sp) {
-                        err.span_suggestion_short(
-                            colon_sp,
-                            "maybe you meant to write `;` here",
-                            ";",
-                            Applicability::MaybeIncorrect,
-                        );
-                    } else {
-                        let after_colon_sp =
-                            self.get_colon_suggestion_span(colon_sp.shrink_to_hi());
-                        if snippet.len() == 1 {
-                            // `foo:bar`
-                            err.span_suggestion(
-                                colon_sp,
-                                "maybe you meant to write a path separator here",
-                                "::",
-                                Applicability::MaybeIncorrect,
-                            );
-                            show_label = false;
-                            if !self
-                                .r
-                                .tcx
-                                .sess
-                                .parse_sess
-                                .type_ascription_path_suggestions
-                                .borrow_mut()
-                                .insert(colon_sp)
-                            {
-                                err.downgrade_to_delayed_bug();
-                            }
-                        }
-                        if let Ok(base_snippet) = base_snippet {
-                            // Try to find an assignment
-                            let eq_span = sm.span_look_ahead(after_colon_sp, Some("="), Some(50));
-                            if let Ok(ref snippet) = sm.span_to_snippet(eq_span) && snippet == "=" {
-                                err.span_suggestion(
-                                    base_span,
-                                    "maybe you meant to write an assignment here",
-                                    format!("let {}", base_snippet),
-                                    Applicability::MaybeIncorrect,
-                                );
-                                show_label = false;
-                            }
-                        }
-                    }
-                    if show_label {
-                        err.span_label(
-                            base_span,
-                            "expecting a type here because of type ascription",
-                        );
-                    }
-                    return show_label;
-                }
-            }
-        }
-        false
-    }
-
     // try to give a suggestion for this pattern: `name = blah`, which is common in other languages
     // suggest `let name = blah` to introduce a new binding
     fn let_binding_suggestion(&mut self, err: &mut Diagnostic, ident_span: Span) -> bool {

compiler/rustc_session/src/parse.rs

@@ -214,8 +214,6 @@ pub struct ParseSess {
     pub env_depinfo: Lock<FxHashSet<(Symbol, Option<Symbol>)>>,
     /// File paths accessed during the build.
     pub file_depinfo: Lock<FxHashSet<Symbol>>,
-    /// All the type ascriptions expressions that have had a suggestion for likely path typo.
-    pub type_ascription_path_suggestions: Lock<FxHashSet<Span>>,
     /// Whether cfg(version) should treat the current release as incomplete
     pub assume_incomplete_release: bool,
     /// Spans passed to `proc_macro::quote_span`. Each span has a numerical
@@ -258,7 +256,6 @@ pub fn with_span_handler(handler: Handler, source_map: Lrc<SourceMap>) -> Self {
             reached_eof: AtomicBool::new(false),
             env_depinfo: Default::default(),
             file_depinfo: Default::default(),
-            type_ascription_path_suggestions: Default::default(),
             assume_incomplete_release: false,
             proc_macro_quoted_spans: Default::default(),
             attr_id_generator: AttrIdGenerator::new(),

src/tools/clippy/clippy_utils/src/sugg.rs

@@ -163,7 +163,8 @@ fn hir_from_snippet(expr: &hir::Expr<'_>, get_snippet: impl Fn(Span) -> Cow<'a,
                 get_snippet(rhs.span),
             ),
             hir::ExprKind::Cast(lhs, ty) => Sugg::BinOp(AssocOp::As, get_snippet(lhs.span), get_snippet(ty.span)),
-            hir::ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::Colon, get_snippet(lhs.span), get_snippet(ty.span)),
+            //FIXME(chenyukang), remove this after type ascription is removed from AST
+            hir::ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::As, get_snippet(lhs.span), get_snippet(ty.span)),
         }
     }
 
@@ -258,8 +259,9 @@ pub fn ast(
                 snippet_with_context(cx, lhs.span, ctxt, default, app).0,
                 snippet_with_context(cx, ty.span, ctxt, default, app).0,
             ),
+            //FIXME(chenyukang), remove this after type ascription is removed from AST
             ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
-                AssocOp::Colon,
+                AssocOp::As,
                 snippet_with_context(cx, lhs.span, ctxt, default, app).0,
                 snippet_with_context(cx, ty.span, ctxt, default, app).0,
             ),
@@ -392,7 +394,6 @@ fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
         AssocOp::As => format!("{lhs} as {rhs}"),
         AssocOp::DotDot => format!("{lhs}..{rhs}"),
         AssocOp::DotDotEq => format!("{lhs}..={rhs}"),
-        AssocOp::Colon => format!("{lhs}: {rhs}"),
     }
 }
 
@@ -602,13 +603,13 @@ enum Associativity {
 #[must_use]
 fn associativity(op: AssocOp) -> Associativity {
     use rustc_ast::util::parser::AssocOp::{
-        Add, As, Assign, AssignOp, BitAnd, BitOr, BitXor, Colon, Divide, DotDot, DotDotEq, Equal, Greater,
+        Add, As, Assign, AssignOp, BitAnd, BitOr, BitXor, Divide, DotDot, DotDotEq, Equal, Greater,
         GreaterEqual, LAnd, LOr, Less, LessEqual, Modulus, Multiply, NotEqual, ShiftLeft, ShiftRight, Subtract,
     };
 
     match op {
         Assign | AssignOp(_) => Associativity::Right,
-        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As | Colon => Associativity::Both,
+        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As => Associativity::Both,
         Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft | ShiftRight
         | Subtract => Associativity::Left,
         DotDot | DotDotEq => Associativity::None,

src/tools/rustfmt/tests/source/type-ascription.rs

@@ -1,10 +0,0 @@
-
-fn main() {
-    let xxxxxxxxxxx = yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy  :  SomeTrait<AA, BB, CC>;
-
-    let xxxxxxxxxxxxxxx = yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA;
-
-    let z = funk(yyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzz, wwwwww): AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA;
-
-    x : u32 - 1u32 / 10f32 : u32
-}

src/tools/rustfmt/tests/target/configs/format_macro_bodies/true.rs

@@ -1,10 +1,6 @@
 // rustfmt-format_macro_bodies: true
 
 macro_rules! foo {
-    ($a: ident : $b: ty) => {
+    ($a: ident : $b: ty) => { $a(42): $b; };
-        $a(42): $b;
+    ($a: ident $b: ident $c: ident) => { $a=$b+$c; };
-    };
-    ($a: ident $b: ident $c: ident) => {
-        $a = $b + $c;
-    };
 }

src/tools/rustfmt/tests/target/configs/format_macro_matchers/false.rs

@@ -1,10 +1,6 @@
 // rustfmt-format_macro_matchers: false
 
 macro_rules! foo {
-    ($a: ident : $b: ty) => {
+    ($a: ident : $b: ty) => { $a(42): $b; };
-        $a(42): $b;
+    ($a: ident $b: ident $c: ident) => { $a=$b+$c; };
-    };
-    ($a: ident $b: ident $c: ident) => {
-        $a = $b + $c;
-    };
 }

src/tools/rustfmt/tests/target/configs/format_macro_matchers/true.rs

@@ -1,10 +1,6 @@
 // rustfmt-format_macro_matchers: true
 
 macro_rules! foo {
-    ($a:ident : $b:ty) => {
+    ($a: ident : $b: ty) => { $a(42): $b; };
-        $a(42): $b;
+    ($a: ident $b: ident $c: ident) => { $a=$b+$c; };
-    };
-    ($a:ident $b:ident $c:ident) => {
-        $a = $b + $c;
-    };
 }

src/tools/rustfmt/tests/target/macros.rs

@@ -122,7 +122,7 @@ fn main() {
         20, 21, 22);
 
     // #1092
-    chain!(input, a: take!(max_size), || []);
+    chain!(input, a:take!(max_size), || []);
 
     // #2727
     foo!("bar");
@@ -156,17 +156,13 @@ macro_rules! foo {
 }
 
 fn issue1739() {
-    sql_function!(
+    sql_function!(add_rss_item,
-        add_rss_item,
+                  add_rss_item_t,
-        add_rss_item_t,
+                  (a: types::Integer,
-        (
+                   b: types::Timestamptz,
-            a: types::Integer,
+                   c: types::Text,
-            b: types::Timestamptz,
+                   d: types::Text,
-            c: types::Text,
+                   e: types::Text));
-            d: types::Text,
-            e: types::Text
-        )
-    );
 
     w.slice_mut(s![
         ..,
@@ -232,7 +228,7 @@ fn issue_3174() {
             "debugMessage": debug.message,
         })
     } else {
-        json!({ "errorKind": format!("{:?}", error.err_kind()) })
+        json!({"errorKind": format!("{:?}", error.err_kind())})
     };
 }
 

src/tools/rustfmt/tests/target/type-ascription.rs

@@ -1,12 +0,0 @@
-fn main() {
-    let xxxxxxxxxxx =
-        yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy: SomeTrait<AA, BB, CC>;
-
-    let xxxxxxxxxxxxxxx =
-        yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA;
-
-    let z = funk(yyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzz, wwwwww):
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA;
-
-    x: u32 - 1u32 / 10f32: u32
-}

src/tools/rustfmt/tests/target/type.rs

@@ -129,7 +129,7 @@ fn issue3117() {
 fn issue3139() {
     assert_eq!(
         to_json_value(&None::<i32>).unwrap(),
-        json!({ "test": None::<i32> })
+        json!(  { "test": None  ::  <i32> }  )
     );
 }
 

tests/ui/consts/auxiliary/external_macro.rs

@@ -9,6 +9,6 @@
 macro_rules! static_assert {
     ($test:expr) => {
         #[allow(dead_code)]
-        const _: () = [()][!($test: bool) as usize];
+        const _: () = [()][!($test) as usize];
     }
 }

tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr

@@ -65,6 +65,7 @@ error: unexpected `,` in pattern
 LL |     let women, men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
    |              ^
    |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 help: try adding parentheses to match on a tuple
    |
 LL |     let (women, men): (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()

tests/ui/feature-gates/feature-gate-type_ascription.rs

@@ -1,5 +1,5 @@
 // Type ascription is unstable
 
 fn main() {
-    let a = 10: u8; //~ ERROR type ascription is experimental
+    let a = type_ascribe!(10, u8); //~ ERROR use of unstable library feature 'type_ascription': placeholder syntax for type ascription
 }

tests/ui/feature-gates/feature-gate-type_ascription.stderr

@@ -1,8 +1,8 @@
-error[E0658]: type ascription is experimental
+error[E0658]: use of unstable library feature 'type_ascription': placeholder syntax for type ascription
   --> $DIR/feature-gate-type_ascription.rs:4:13
    |
-LL |     let a = 10: u8;
+LL |     let a = type_ascribe!(10, u8);
-   |             ^^^^^^
+   |             ^^^^^^^^^^^^
    |
    = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
    = help: add `#![feature(type_ascription)]` to the crate attributes to enable

tests/ui/generic-associated-types/parse/trait-path-missing-gen_arg.rs

@@ -5,9 +5,6 @@ trait X {
 const _: () = {
   fn f1<'a>(arg : Box<dyn X< : 32 >>) {}
       //~^ ERROR: expected one of `>`, a const expression, lifetime, or type, found `:`
-      //~| ERROR: expected parameter name, found `>`
-      //~| ERROR: expected one of `!`, `)`, `+`, `,`, or `::`, found `>`
-      //~| ERROR: constant provided when a type was expected
 };
 
 const _: () = {

tests/ui/generic-associated-types/parse/trait-path-missing-gen_arg.stderr

@@ -3,41 +3,14 @@ error: expected one of `>`, a const expression, lifetime, or type, found `:`
    |
 LL |   fn f1<'a>(arg : Box<dyn X< : 32 >>) {}
    |                              ^ expected one of `>`, a const expression, lifetime, or type
-   |
-help: expressions must be enclosed in braces to be used as const generic arguments
-   |
-LL |   fn f1<'a>(arg : Box<{ dyn X< : 32 } >>) {}
-   |                       +             +
-
-error: expected parameter name, found `>`
-  --> $DIR/trait-path-missing-gen_arg.rs:6:36
-   |
-LL |   fn f1<'a>(arg : Box<dyn X< : 32 >>) {}
-   |                                    ^ expected parameter name
-
-error: expected one of `!`, `)`, `+`, `,`, or `::`, found `>`
-  --> $DIR/trait-path-missing-gen_arg.rs:6:36
-   |
-LL |   fn f1<'a>(arg : Box<dyn X< : 32 >>) {}
-   |                                    ^
-   |                                    |
-   |                                    expected one of `!`, `)`, `+`, `,`, or `::`
-   |                                    help: missing `,`
 
 error: expected one of `>`, a const expression, lifetime, or type, found `=`
-  --> $DIR/trait-path-missing-gen_arg.rs:14:30
+  --> $DIR/trait-path-missing-gen_arg.rs:11:30
    |
 LL |   fn f1<'a>(arg : Box<dyn X< = 32 >>) {}
    |                            - ^ expected one of `>`, a const expression, lifetime, or type
    |                            |
    |                            maybe try to close unmatched angle bracket
 
-error[E0747]: constant provided when a type was expected
+error: aborting due to 2 previous errors
-  --> $DIR/trait-path-missing-gen_arg.rs:6:23
-   |
-LL |   fn f1<'a>(arg : Box<dyn X< : 32 >>) {}
-   |                       ^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0747`.

tests/ui/generics/single-colon-path-not-const-generics.rs

@@ -6,8 +6,8 @@ pub mod bar {
 
 pub struct Foo {
   a: Vec<foo::bar:A>,
-  //~^ ERROR expected
+  //~^ ERROR path separator must be a double colon
-  //~| HELP path separator
+  //~| HELP use a double colon instead
 }
 
 fn main() {}

tests/ui/generics/single-colon-path-not-const-generics.stderr

@@ -1,11 +1,12 @@
-error: expected one of `,` or `>`, found `:`
+error: path separator must be a double colon
   --> $DIR/single-colon-path-not-const-generics.rs:8:18
    |
+LL | pub struct Foo {
+   |            --- while parsing this struct
 LL |   a: Vec<foo::bar:A>,
-   |                  ^
+   |                  ^ help: use a double colon instead: `::`
-   |                  |
+   |
-   |                  expected one of `,` or `>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   |                  help: write a path separator here: `::`
 
 error: aborting due to previous error
 

tests/ui/issues/issue-22644.rs

@@ -1,18 +1,12 @@
-#![feature(type_ascription)]
-
 fn main() {
-    let a : usize = 0;
+    let a: usize = 0;
-    let long_name : usize = 0;
+    let long_name: usize = 0;
 
     println!("{}", a as usize > long_name);
     println!("{}", a as usize < long_name); //~ ERROR `<` is interpreted as a start of generic
     println!("{}{}", a as usize < long_name, long_name);
     //~^ ERROR `<` is interpreted as a start of generic
     println!("{}", a as usize < 4); //~ ERROR `<` is interpreted as a start of generic
-    println!("{}", a: usize > long_name);
-    println!("{}{}", a: usize < long_name, long_name);
-    //~^ ERROR `<` is interpreted as a start of generic
-    println!("{}", a: usize < 4); //~ ERROR `<` is interpreted as a start of generic
 
     println!("{}", a
                    as
@@ -30,6 +24,4 @@ fn main() {
                    5);
 
     println!("{}", a as usize << long_name); //~ ERROR `<<` is interpreted as a start of generic
-
-    println!("{}", a: &mut 4); //~ ERROR expected type, found `4`
 }

tests/ui/issues/issue-22644.stderr

@@ -1,5 +1,5 @@
 error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:8:31
+  --> $DIR/issue-22644.rs:6:31
    |
 LL |     println!("{}", a as usize < long_name);
    |                               ^ --------- interpreted as generic arguments
@@ -12,7 +12,7 @@ LL |     println!("{}", (a as usize) < long_name);
    |                    +          +
 
 error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:9:33
+  --> $DIR/issue-22644.rs:7:33
    |
 LL |     println!("{}{}", a as usize < long_name, long_name);
    |                                 ^ -------------------- interpreted as generic arguments
@@ -25,7 +25,7 @@ LL |     println!("{}{}", (a as usize) < long_name, long_name);
    |                      +          +
 
 error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:11:31
+  --> $DIR/issue-22644.rs:9:31
    |
 LL |     println!("{}", a as usize < 4);
    |                               ^ - interpreted as generic arguments
@@ -38,33 +38,7 @@ LL |     println!("{}", (a as usize) < 4);
    |                    +          +
 
 error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:13:31
+  --> $DIR/issue-22644.rs:14:20
-   |
-LL |     println!("{}{}", a: usize < long_name, long_name);
-   |                               ^ -------------------- interpreted as generic arguments
-   |                               |
-   |                               not interpreted as comparison
-   |
-help: try comparing the cast value
-   |
-LL |     println!("{}{}", (a: usize) < long_name, long_name);
-   |                      +        +
-
-error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:15:29
-   |
-LL |     println!("{}", a: usize < 4);
-   |                             ^ - interpreted as generic arguments
-   |                             |
-   |                             not interpreted as comparison
-   |
-help: try comparing the cast value
-   |
-LL |     println!("{}", (a: usize) < 4);
-   |                    +        +
-
-error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:20:20
    |
 LL |                    <
    |                    ^ not interpreted as comparison
@@ -79,7 +53,7 @@ LL ~                    usize)
    |
 
 error: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
-  --> $DIR/issue-22644.rs:29:20
+  --> $DIR/issue-22644.rs:23:20
    |
 LL |                    <
    |                    ^ not interpreted as comparison
@@ -96,7 +70,7 @@ LL ~                    usize)
    |
 
 error: `<<` is interpreted as a start of generic arguments for `usize`, not a shift
-  --> $DIR/issue-22644.rs:32:31
+  --> $DIR/issue-22644.rs:26:31
    |
 LL |     println!("{}", a as usize << long_name);
    |                               ^^ --------- interpreted as generic arguments
@@ -108,16 +82,5 @@ help: try shifting the cast value
 LL |     println!("{}", (a as usize) << long_name);
    |                    +          +
 
-error: expected type, found `4`
+error: aborting due to 6 previous errors
-  --> $DIR/issue-22644.rs:34:28
-   |
-LL |     println!("{}", a: &mut 4);
-   |                     -      ^ expected type
-   |                     |
-   |                     tried to parse a type due to this type ascription
-   |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
-
-error: aborting due to 9 previous errors
 

tests/ui/macros/stringify.rs

@@ -134,8 +134,7 @@ fn test_expr() {
     assert_eq!(stringify_expr!(expr as T<u8>), "expr as T<u8>");
 
     // ExprKind::Type
-    assert_eq!(stringify_expr!(expr: T), "expr: T");
+    // There is no syntax for type ascription.
-    assert_eq!(stringify_expr!(expr: T<u8>), "expr: T<u8>");
 
     // ExprKind::If
     assert_eq!(stringify_expr!(if true {}), "if true {}");

tests/ui/or-patterns/or-patterns-syntactic-fail.rs

@@ -8,9 +8,12 @@ enum E { A, B }
 
 fn no_top_level_or_patterns() {
     // We do *not* allow or-patterns at the top level of lambdas...
-    let _ = |A | B: E| (); //~ ERROR no implementation for `E | ()`
+    let _ = |A | B: E| ();
+                           //~^ ERROR expected identifier, found
     //           -------- This looks like an or-pattern but is in fact `|A| (B: E | ())`.
+}
 
+fn no_top_level_or_patterns_2() {
     // ...and for now neither do we allow or-patterns at the top level of functions.
     fn fun1(A | B: E) {}
     //~^ ERROR top-level or-patterns are not allowed

tests/ui/or-patterns/or-patterns-syntactic-fail.stderr

@@ -1,43 +1,34 @@
+error: expected identifier, found `:`
+  --> $DIR/or-patterns-syntactic-fail.rs:11:19
+   |
+LL |     let _ = |A | B: E| ();
+   |                   ^ expected identifier
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+
 error: top-level or-patterns are not allowed in function parameters
-  --> $DIR/or-patterns-syntactic-fail.rs:15:13
+  --> $DIR/or-patterns-syntactic-fail.rs:18:13
    |
 LL |     fn fun1(A | B: E) {}
    |             ^^^^^ help: wrap the pattern in parentheses: `(A | B)`
 
 error: top-level or-patterns are not allowed in function parameters
-  --> $DIR/or-patterns-syntactic-fail.rs:18:13
+  --> $DIR/or-patterns-syntactic-fail.rs:21:13
    |
 LL |     fn fun2(| A | B: E) {}
    |             ^^^^^^^ help: wrap the pattern in parentheses: `(A | B)`
 
 error: top-level or-patterns are not allowed in `let` bindings
-  --> $DIR/or-patterns-syntactic-fail.rs:23:9
+  --> $DIR/or-patterns-syntactic-fail.rs:26:9
    |
 LL |     let A | B: E = A;
    |         ^^^^^ help: wrap the pattern in parentheses: `(A | B)`
 
 error: top-level or-patterns are not allowed in `let` bindings
-  --> $DIR/or-patterns-syntactic-fail.rs:26:9
+  --> $DIR/or-patterns-syntactic-fail.rs:29:9
    |
 LL |     let | A | B: E = A;
    |         ^^^^^^^ help: wrap the pattern in parentheses: `(A | B)`
 
-error[E0369]: no implementation for `E | ()`
-  --> $DIR/or-patterns-syntactic-fail.rs:11:22
-   |
-LL |     let _ = |A | B: E| ();
-   |                  ----^ -- ()
-   |                  |
-   |                  E
-   |
-note: an implementation of `BitOr<()>` might be missing for `E`
-  --> $DIR/or-patterns-syntactic-fail.rs:6:1
-   |
-LL | enum E { A, B }
-   | ^^^^^^ must implement `BitOr<()>`
-note: the trait `BitOr` must be implemented
-  --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-
 error: aborting due to 5 previous errors
 
-For more information about this error, try `rustc --explain E0369`.

tests/ui/parser/attr-stmt-expr-attr-bad.rs

@@ -6,6 +6,7 @@ fn main() {}
 //~^ ERROR expected one of
 #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
 //~^ ERROR an inner attribute is not permitted in this context
+//~| ERROR an inner attribute is not permitted in this context
 //~| ERROR expected expression, found `)`
 #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
 //~^ ERROR an inner attribute is not permitted in this context

tests/ui/parser/attr-stmt-expr-attr-bad.stderr

@@ -19,6 +19,15 @@ LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
    = note: outer attributes, like `#[test]`, annotate the item following them
 
+error: an inner attribute is not permitted in this context
+  --> $DIR/attr-stmt-expr-attr-bad.rs:7:36
+   |
+LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
+   |                                    ^^^^^^^^
+   |
+   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
+   = note: outer attributes, like `#[test]`, annotate the item following them
+
 error: expected expression, found `)`
   --> $DIR/attr-stmt-expr-attr-bad.rs:7:44
    |
@@ -26,7 +35,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
    |                                            ^ expected expression
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:10:38
+  --> $DIR/attr-stmt-expr-attr-bad.rs:11:38
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
    |                                      ^^^^^^^^
@@ -35,13 +44,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: expected expression, found `)`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:10:46
+  --> $DIR/attr-stmt-expr-attr-bad.rs:11:46
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
    |                                              ^ expected expression
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:13:36
+  --> $DIR/attr-stmt-expr-attr-bad.rs:14:36
    |
 LL | #[cfg(FALSE)] fn e() { let _ = 0 + #![attr] 0; }
    |                                    ^^^^^^^^
@@ -50,7 +59,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = 0 + #![attr] 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:15:33
+  --> $DIR/attr-stmt-expr-attr-bad.rs:16:33
    |
 LL | #[cfg(FALSE)] fn e() { let _ = !#![attr] 0; }
    |                                 ^^^^^^^^
@@ -59,7 +68,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = !#![attr] 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:17:33
+  --> $DIR/attr-stmt-expr-attr-bad.rs:18:33
    |
 LL | #[cfg(FALSE)] fn e() { let _ = -#![attr] 0; }
    |                                 ^^^^^^^^
@@ -68,13 +77,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = -#![attr] 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:19:34
+  --> $DIR/attr-stmt-expr-attr-bad.rs:20:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x #![attr] as Y; }
    |                                  ^ expected one of 8 possible tokens
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:21:35
+  --> $DIR/attr-stmt-expr-attr-bad.rs:22:35
    |
 LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] foo; }
    |                                   ^^^^^^^^
@@ -83,7 +92,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] foo; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:23:40
+  --> $DIR/attr-stmt-expr-attr-bad.rs:24:40
    |
 LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] foo; }
    |                                        ^^^^^^^^
@@ -92,7 +101,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] foo; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:25:35
+  --> $DIR/attr-stmt-expr-attr-bad.rs:26:35
    |
 LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] {foo}; }
    |                                   ^^^^^^^^
@@ -101,7 +110,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] {foo}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:27:40
+  --> $DIR/attr-stmt-expr-attr-bad.rs:28:40
    |
 LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
    |                                        ^^^^^^^^
@@ -110,19 +119,19 @@ LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: expected expression, found `..`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:29:40
+  --> $DIR/attr-stmt-expr-attr-bad.rs:30:40
    |
 LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..#[attr] 0; }
    |                                        ^^ expected expression
 
 error: expected expression, found `..`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:31:40
+  --> $DIR/attr-stmt-expr-attr-bad.rs:32:40
    |
 LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..; }
    |                                        ^^ expected expression
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:33:41
+  --> $DIR/attr-stmt-expr-attr-bad.rs:34:41
    |
 LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &#![attr] 0; }
    |                                         ^^^^^^^^
@@ -131,7 +140,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &#![attr] 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:35:45
+  --> $DIR/attr-stmt-expr-attr-bad.rs:36:45
    |
 LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &mut #![attr] 0; }
    |                                             ^^^^^^^^
@@ -140,7 +149,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &mut #![attr] 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:37:37
+  --> $DIR/attr-stmt-expr-attr-bad.rs:38:37
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 #[attr] {}; }
    |                                --   ^^^^^^^ -- the attributes are attached to this branch
@@ -149,7 +158,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 #[attr] {}; }
    |                                the branch belongs to this `if`
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:39:38
+  --> $DIR/attr-stmt-expr-attr-bad.rs:40:38
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {#![attr]}; }
    |                                      ^^^^^^^^
@@ -158,13 +167,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {#![attr]}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:41:40
+  --> $DIR/attr-stmt-expr-attr-bad.rs:42:40
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} #[attr] else {}; }
    |                                        ^ expected one of `.`, `;`, `?`, `else`, or an operator
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:43:45
+  --> $DIR/attr-stmt-expr-attr-bad.rs:44:45
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] {}; }
    |                                        ---- ^^^^^^^ -- the attributes are attached to this branch
@@ -173,7 +182,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] {}; }
    |                                        the branch belongs to this `else`
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:45:46
+  --> $DIR/attr-stmt-expr-attr-bad.rs:46:46
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else {#![attr]}; }
    |                                              ^^^^^^^^
@@ -182,7 +191,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else {#![attr]}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:47:45
+  --> $DIR/attr-stmt-expr-attr-bad.rs:48:45
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] if 0 {}; }
    |                                        ---- ^^^^^^^ ------- the attributes are attached to this branch
@@ -191,7 +200,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] if 0 {}; }
    |                                        the branch belongs to this `else`
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:49:50
+  --> $DIR/attr-stmt-expr-attr-bad.rs:50:50
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 #[attr] {}; }
    |                                             --   ^^^^^^^ -- the attributes are attached to this branch
@@ -200,7 +209,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 #[attr] {}; }
    |                                             the branch belongs to this `if`
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:51:51
+  --> $DIR/attr-stmt-expr-attr-bad.rs:52:51
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 {#![attr]}; }
    |                                                   ^^^^^^^^
@@ -209,7 +218,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 {#![attr]}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:53:45
+  --> $DIR/attr-stmt-expr-attr-bad.rs:54:45
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 #[attr] {}; }
    |                                --           ^^^^^^^ -- the attributes are attached to this branch
@@ -218,7 +227,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 #[attr] {}; }
    |                                the branch belongs to this `if`
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:55:46
+  --> $DIR/attr-stmt-expr-attr-bad.rs:56:46
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {#![attr]}; }
    |                                              ^^^^^^^^
@@ -227,13 +236,13 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {#![attr]}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:57:48
+  --> $DIR/attr-stmt-expr-attr-bad.rs:58:48
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} #[attr] else {}; }
    |                                                ^ expected one of `.`, `;`, `?`, `else`, or an operator
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:59:53
+  --> $DIR/attr-stmt-expr-attr-bad.rs:60:53
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] {}; }
    |                                                ---- ^^^^^^^ -- the attributes are attached to this branch
@@ -242,7 +251,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] {}; }
    |                                                the branch belongs to this `else`
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:61:54
+  --> $DIR/attr-stmt-expr-attr-bad.rs:62:54
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else {#![attr]}; }
    |                                                      ^^^^^^^^
@@ -251,7 +260,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else {#![attr]}; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:63:53
+  --> $DIR/attr-stmt-expr-attr-bad.rs:64:53
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] if let _ = 0 {}; }
    |                                                ---- ^^^^^^^ --------------- the attributes are attached to this branch
@@ -260,7 +269,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] if let _ = 0 {}
    |                                                the branch belongs to this `else`
 
 error: outer attributes are not allowed on `if` and `else` branches
-  --> $DIR/attr-stmt-expr-attr-bad.rs:65:66
+  --> $DIR/attr-stmt-expr-attr-bad.rs:66:66
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 #[attr] {}; }
    |                                                     --           ^^^^^^^ -- the attributes are attached to this branch
@@ -269,7 +278,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 #[attr] {}
    |                                                     the branch belongs to this `if`
 
 error: an inner attribute is not permitted in this context
-  --> $DIR/attr-stmt-expr-attr-bad.rs:67:67
+  --> $DIR/attr-stmt-expr-attr-bad.rs:68:67
    |
 LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 {#![attr]}; }
    |                                                                   ^^^^^^^^
@@ -278,7 +287,7 @@ LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 {#![attr]}
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted following an outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:70:32
+  --> $DIR/attr-stmt-expr-attr-bad.rs:71:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] let _ = 0; }
    |                        ------- ^^^^^^^^ not permitted following an outer attribute
@@ -289,7 +298,7 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] let _ = 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted following an outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:72:32
+  --> $DIR/attr-stmt-expr-attr-bad.rs:73:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] 0; }
    |                        ------- ^^^^^^^^ not permitted following an outer attribute
@@ -300,7 +309,7 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] 0; }
    = note: outer attributes, like `#[test]`, annotate the item following them
 
 error: an inner attribute is not permitted following an outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:74:32
+  --> $DIR/attr-stmt-expr-attr-bad.rs:75:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
    |                        ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
@@ -316,7 +325,7 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!(); }
    |
 
 error: an inner attribute is not permitted following an outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:76:32
+  --> $DIR/attr-stmt-expr-attr-bad.rs:77:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
    |                        ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
@@ -332,7 +341,7 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo![]; }
    |
 
 error: an inner attribute is not permitted following an outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:78:32
+  --> $DIR/attr-stmt-expr-attr-bad.rs:79:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
    |                        ------- ^^^^^^^^ ------ the inner attribute doesn't annotate this item macro invocation
@@ -348,7 +357,7 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!{}; }
    |
 
 error[E0586]: inclusive range with no end
-  --> $DIR/attr-stmt-expr-attr-bad.rs:84:35
+  --> $DIR/attr-stmt-expr-attr-bad.rs:85:35
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
    |                                   ^^^ help: use `..` instead
@@ -356,13 +365,13 @@ LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 
 error: expected one of `=>`, `if`, or `|`, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:84:38
+  --> $DIR/attr-stmt-expr-attr-bad.rs:85:38
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
    |                                      ^ expected one of `=>`, `if`, or `|`
 
 error[E0586]: inclusive range with no end
-  --> $DIR/attr-stmt-expr-attr-bad.rs:87:35
+  --> $DIR/attr-stmt-expr-attr-bad.rs:88:35
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
    |                                   ^^^ help: use `..` instead
@@ -370,19 +379,19 @@ LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 
 error: expected one of `=>`, `if`, or `|`, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:87:38
+  --> $DIR/attr-stmt-expr-attr-bad.rs:88:38
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
    |                                      ^ expected one of `=>`, `if`, or `|`
 
 error: unexpected token: `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:90:39
+  --> $DIR/attr-stmt-expr-attr-bad.rs:91:39
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=-#[attr] 10 => () } }
    |                                       ^
 
 error[E0586]: inclusive range with no end
-  --> $DIR/attr-stmt-expr-attr-bad.rs:92:35
+  --> $DIR/attr-stmt-expr-attr-bad.rs:93:35
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
    |                                   ^^^ help: use `..` instead
@@ -390,47 +399,47 @@ LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 
 error: expected one of `=>`, `if`, or `|`, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:92:38
+  --> $DIR/attr-stmt-expr-attr-bad.rs:93:38
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
    |                                      ^ expected one of `=>`, `if`, or `|`
 
 error: unexpected token: `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:96:34
+  --> $DIR/attr-stmt-expr-attr-bad.rs:97:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
    |                                  ^
 
 error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:96:34
+  --> $DIR/attr-stmt-expr-attr-bad.rs:97:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
    |                                  ^ expected one of `.`, `;`, `?`, `else`, or an operator
 
 error: unexpected token: `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:99:34
+  --> $DIR/attr-stmt-expr-attr-bad.rs:100:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
    |                                  ^
 
 error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
-  --> $DIR/attr-stmt-expr-attr-bad.rs:99:34
+  --> $DIR/attr-stmt-expr-attr-bad.rs:100:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
    |                                  ^ expected one of `.`, `;`, `?`, `else`, or an operator
 
 error: expected statement after outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:104:37
+  --> $DIR/attr-stmt-expr-attr-bad.rs:105:37
    |
 LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr]; } } }
    |                                     ^^^^^^^
 
 error: expected statement after outer attribute
-  --> $DIR/attr-stmt-expr-attr-bad.rs:106:37
+  --> $DIR/attr-stmt-expr-attr-bad.rs:107:37
    |
 LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr] } } }
    |                                     ^^^^^^^
 
-error: aborting due to 52 previous errors
+error: aborting due to 53 previous errors
 
 For more information about this error, try `rustc --explain E0586`.

tests/ui/parser/issue-103869.rs

@@ -2,7 +2,6 @@ enum VecOrMap{
     vec: Vec<usize>,
     //~^ ERROR expected one of `(`, `,`, `=`, `{`, or `}`, found `:`
     //~| HELP: enum variants can be `Variant`, `Variant = <integer>`, `Variant(Type, ..., TypeN)` or `Variant { fields: Types }`
-    //~| ERROR expected item, found `:`
     map: HashMap<String,usize>
 }
 

tests/ui/parser/issue-103869.stderr

@@ -1,16 +1,12 @@
 error: expected one of `(`, `,`, `=`, `{`, or `}`, found `:`
   --> $DIR/issue-103869.rs:2:8
    |
+LL | enum VecOrMap{
+   |      -------- while parsing this enum
 LL |     vec: Vec<usize>,
    |        ^ expected one of `(`, `,`, `=`, `{`, or `}`
    |
    = help: enum variants can be `Variant`, `Variant = <integer>`, `Variant(Type, ..., TypeN)` or `Variant { fields: Types }`
 
-error: expected item, found `:`
+error: aborting due to previous error
-  --> $DIR/issue-103869.rs:2:8
-   |
-LL |     vec: Vec<usize>,
-   |        ^ expected item
-
-error: aborting due to 2 previous errors
 

tests/ui/parser/issues/issue-35813-postfix-after-cast.rs

@@ -10,14 +10,14 @@ pub fn index_after_as_cast() {
     vec![1, 2, 3] as Vec<i32>[0];
     //~^ ERROR: cast cannot be followed by indexing
     vec![1, 2, 3]: Vec<i32>[0];
-    //~^ ERROR: type ascription cannot be followed by indexing
+    //~^ ERROR: expected one of
 }
 
 pub fn index_after_cast_to_index() {
     (&[0]) as &[i32][0];
     //~^ ERROR: cast cannot be followed by indexing
     (&[0i32]): &[i32; 1][0];
-    //~^ ERROR: type ascription cannot be followed by indexing
+    //~^ ERROR: expected one of
 }
 
 pub fn cast_after_cast() {
@@ -25,7 +25,7 @@ pub fn cast_after_cast() {
 
     }
     if 5u64: u64: u64 == 0u64 {
-
+        //~^ ERROR expected `{`, found `:`
     }
     let _ = 5u64: u64: u64 as u8 as i8 == 9i8;
     let _ = 0i32: i32: i32;
@@ -36,26 +36,46 @@ pub fn cast_after_cast() {
 }
 
 pub fn cast_cast_method_call() {
-    let _ = 0i32: i32: i32.count_ones();
+    let _ = 0i32: i32: i32.count_ones(); //~ ERROR expected one of
-    //~^ ERROR: type ascription cannot be followed by a method call
+}
-    let _ = 0 as i32: i32.count_ones();
+
-    //~^ ERROR: type ascription cannot be followed by a method call
+pub fn cast_cast_method_call_2() {
-    let _ = 0i32: i32 as i32.count_ones();
+    let _ = 0 as i32: i32.count_ones(); //~ ERROR expected one of
-    //~^ ERROR: cast cannot be followed by a method call
+}
+
+pub fn cast_cast_method_call_3() {
+    let _ = 0i32: i32 as i32.count_ones(); //~ ERROR expected one of
+}
+
+pub fn cast_cast_method_call_4() {
     let _ = 0 as i32 as i32.count_ones();
     //~^ ERROR: cast cannot be followed by a method call
-    let _ = 0i32: i32: i32 as u32 as i32.count_ones();
+}
+
+pub fn cast_cast_method_call_5() {
+    let _ = 0i32: i32: i32 as u32 as i32.count_ones(); //~ ERROR expected one of
+}
+
+pub fn cast_cast_method_call_6() {
+    let _ = 0i32: i32.count_ones(): u32; //~ ERROR expected one of
+}
+
+pub fn cast_cast_method_call_7() {
+    let _ = 0 as i32.count_ones(): u32; //~ ERROR expected one of
     //~^ ERROR: cast cannot be followed by a method call
-    let _ = 0i32: i32.count_ones(): u32;
+}
-    //~^ ERROR: type ascription cannot be followed by a method call
+
-    let _ = 0 as i32.count_ones(): u32;
+pub fn cast_cast_method_call_8() {
-    //~^ ERROR: cast cannot be followed by a method call
+    let _ = 0i32: i32.count_ones() as u32; //~ ERROR expected one of
-    let _ = 0i32: i32.count_ones() as u32;
+}
-    //~^ ERROR: type ascription cannot be followed by a method call
+
+pub fn cast_cast_method_call_9() {
     let _ = 0 as i32.count_ones() as u32;
     //~^ ERROR: cast cannot be followed by a method call
-    let _ = 0i32: i32: i32.count_ones() as u32 as i32;
+}
-    //~^ ERROR: type ascription cannot be followed by a method call
+
+pub fn cast_cast_method_call_10() {
+    let _ = 0i32: i32: i32.count_ones() as u32 as i32; //~ ERROR expected one of
 }
 
 pub fn multiline_error() {
@@ -74,8 +94,7 @@ pub fn precedence() {
 pub fn method_calls() {
     0 as i32.max(0);
     //~^ ERROR: cast cannot be followed by a method call
-    0: i32.max(0);
+    0: i32.max(0); //~ ERROR expected one of
-    //~^ ERROR: type ascription cannot be followed by a method call
 }
 
 pub fn complex() {
@@ -84,7 +103,7 @@ pub fn complex() {
         if true { 33 } else { 44 } as i32.max(0),
         //~^ ERROR: cast cannot be followed by a method call
         if true { 33 } else { 44 }: i32.max(0)
-        //~^ ERROR: type ascription cannot be followed by a method call
+        //~^ ERROR: expected one of
     );
 }
 
@@ -93,7 +112,7 @@ pub fn in_condition() {
         //~^ ERROR: cast cannot be followed by a method call
     }
     if 5u64: u64.max(0) == 0 {
-        //~^ ERROR: type ascription cannot be followed by a method call
+        //~^ ERROR: expected `{`, found `:`
     }
 }
 
@@ -104,7 +123,7 @@ pub fn inside_block() {
     } else { false };
     let _ = if true {
         5u64: u64.max(0) == 0
-        //~^ ERROR: type ascription cannot be followed by a method call
+        //~^ ERROR: expected one of
     } else { false };
 }
 
@@ -112,14 +131,14 @@ pub fn inside_block() {
 //~^ ERROR: cast cannot be followed by indexing
 
 static bar2: &[i32] = &(&[1i32,2,3]: &[i32; 3][0..1]);
-//~^ ERROR: type ascription cannot be followed by indexing
+//~^ ERROR: expected one of
 
 
 pub fn cast_then_try() -> Result<u64,u64> {
     Err(0u64) as Result<u64,u64>?;
     //~^ ERROR: cast cannot be followed by `?`
     Err(0u64): Result<u64,u64>?;
-    //~^ ERROR: type ascription cannot be followed by `?`
+    //~^ ERROR: expected one of
     Ok(1)
 }
 
@@ -131,13 +150,14 @@ pub fn cast_then_call() {
     drop as F();
     //~^ ERROR: parenthesized type parameters may only be used with a `Fn` trait [E0214]
     drop_ptr: F();
-    //~^ ERROR: parenthesized type parameters may only be used with a `Fn` trait [E0214]
+    //~^ ERROR: expected identifier, found `:`
 }
 
 pub fn cast_to_fn_should_work() {
     let drop_ptr = drop as fn(u8);
     drop as fn(u8);
     drop_ptr: fn(u8);
+    //~^ ERROR expected one of
 }
 
 pub fn parens_after_cast_error() {
@@ -145,7 +165,7 @@ pub fn parens_after_cast_error() {
     drop as fn(u8)(0);
     //~^ ERROR: cast cannot be followed by a function call
     drop_ptr: fn(u8)(0);
-    //~^ ERROR: type ascription cannot be followed by a function call
+    //~^ ERROR: expected one of
 }
 
 pub async fn cast_then_await() {
@@ -153,7 +173,7 @@ pub async fn cast_then_await() {
     //~^ ERROR: cast cannot be followed by `.await`
 
     Box::pin(noop()): Pin<Box<_>>.await;
-    //~^ ERROR: type ascription cannot be followed by `.await`
+    //~^ ERROR: expected one of
 }
 
 pub async fn noop() {}
@@ -167,5 +187,5 @@ pub fn struct_field() {
     Foo::default() as Foo.bar;
     //~^ ERROR: cannot be followed by a field access
     Foo::default(): Foo.bar;
-    //~^ ERROR: type ascription cannot be followed by a field access
+    //~^ ERROR expected one of
 }

tests/ui/parser/issues/issue-35813-postfix-after-cast.stderr

@@ -9,21 +9,11 @@ help: try surrounding the expression in parentheses
 LL |     (vec![1, 2, 3] as Vec<i32>)[0];
    |     +                         +
 
-error: type ascription cannot be followed by indexing
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:12:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:12:18
    |
 LL |     vec![1, 2, 3]: Vec<i32>[0];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |                  ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     (vec![1, 2, 3]: Vec<i32>)[0];
-   |     +                       +
-help: alternatively, remove the type ascription
-   |
-LL -     vec![1, 2, 3]: Vec<i32>[0];
-LL +     vec![1, 2, 3][0];
-   |
 
 error: cast cannot be followed by indexing
   --> $DIR/issue-35813-postfix-after-cast.rs:17:5
@@ -36,67 +26,50 @@ help: try surrounding the expression in parentheses
 LL |     ((&[0]) as &[i32])[0];
    |     +                +
 
-error: type ascription cannot be followed by indexing
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:19:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:19:14
    |
 LL |     (&[0i32]): &[i32; 1][0];
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |              ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     ((&[0i32]): &[i32; 1])[0];
-   |     +                    +
-help: alternatively, remove the type ascription
-   |
-LL -     (&[0i32]): &[i32; 1][0];
-LL +     (&[0i32])[0];
-   |
 
-error: type ascription cannot be followed by a method call
+error: expected `{`, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:39:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:27:12
+   |
+LL |     if 5u64: u64: u64 == 0u64 {
+   |            ^ expected `{`
+   |
+note: the `if` expression is missing a block after this condition
+  --> $DIR/issue-35813-postfix-after-cast.rs:27:8
+   |
+LL |     if 5u64: u64: u64 == 0u64 {
+   |        ^^^^
+
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
+  --> $DIR/issue-35813-postfix-after-cast.rs:39:17
    |
 LL |     let _ = 0i32: i32: i32.count_ones();
-   |             ^^^^^^^^^^^^^^
+   |                 ^ expected one of `.`, `;`, `?`, `else`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     let _ = (0i32: i32: i32).count_ones();
-   |             +              +
-help: alternatively, remove the type ascription
-   |
-LL -     let _ = 0i32: i32: i32.count_ones();
-LL +     let _ = 0i32: i32.count_ones();
    |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: type ascription cannot be followed by a method call
+error: expected one of `!`, `(`, `.`, `::`, `;`, `<`, `?`, or `else`, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:41:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:43:21
    |
 LL |     let _ = 0 as i32: i32.count_ones();
-   |             ^^^^^^^^^^^^^
+   |                     ^ expected one of 8 possible tokens
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     let _ = (0 as i32: i32).count_ones();
-   |             +             +
-help: alternatively, remove the type ascription
-   |
-LL -     let _ = 0 as i32: i32.count_ones();
-LL +     let _ = 0 as i32.count_ones();
    |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: cast cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:43:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:47:17
    |
 LL |     let _ = 0i32: i32 as i32.count_ones();
-   |             ^^^^^^^^^^^^^^^^
+   |                 ^ expected one of `.`, `;`, `?`, `else`, or an operator
    |
-help: try surrounding the expression in parentheses
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   |
-LL |     let _ = (0i32: i32 as i32).count_ones();
-   |             +                +
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:45:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:51:13
    |
 LL |     let _ = 0 as i32 as i32.count_ones();
    |             ^^^^^^^^^^^^^^^
@@ -106,35 +79,24 @@ help: try surrounding the expression in parentheses
 LL |     let _ = (0 as i32 as i32).count_ones();
    |             +               +
 
-error: cast cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:47:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:56:17
    |
 LL |     let _ = 0i32: i32: i32 as u32 as i32.count_ones();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                 ^ expected one of `.`, `;`, `?`, `else`, or an operator
    |
-help: try surrounding the expression in parentheses
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   |
-LL |     let _ = (0i32: i32: i32 as u32 as i32).count_ones();
-   |             +                            +
 
-error: type ascription cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:49:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:60:17
    |
 LL |     let _ = 0i32: i32.count_ones(): u32;
-   |             ^^^^^^^^^
+   |                 ^ expected one of `.`, `;`, `?`, `else`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     let _ = (0i32: i32).count_ones(): u32;
-   |             +         +
-help: alternatively, remove the type ascription
-   |
-LL -     let _ = 0i32: i32.count_ones(): u32;
-LL +     let _ = 0i32.count_ones(): u32;
    |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:51:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:64:13
    |
 LL |     let _ = 0 as i32.count_ones(): u32;
    |             ^^^^^^^^
@@ -144,24 +106,24 @@ help: try surrounding the expression in parentheses
 LL |     let _ = (0 as i32).count_ones(): u32;
    |             +        +
 
-error: type ascription cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, or `else`, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:53:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:64:34
+   |
+LL |     let _ = 0 as i32.count_ones(): u32;
+   |                                  ^ expected one of `.`, `;`, `?`, or `else`
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
+  --> $DIR/issue-35813-postfix-after-cast.rs:69:17
    |
 LL |     let _ = 0i32: i32.count_ones() as u32;
-   |             ^^^^^^^^^
+   |                 ^ expected one of `.`, `;`, `?`, `else`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     let _ = (0i32: i32).count_ones() as u32;
-   |             +         +
-help: alternatively, remove the type ascription
-   |
-LL -     let _ = 0i32: i32.count_ones() as u32;
-LL +     let _ = 0i32.count_ones() as u32;
    |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:55:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:73:13
    |
 LL |     let _ = 0 as i32.count_ones() as u32;
    |             ^^^^^^^^
@@ -171,24 +133,16 @@ help: try surrounding the expression in parentheses
 LL |     let _ = (0 as i32).count_ones() as u32;
    |             +        +
 
-error: type ascription cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:57:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:78:17
    |
 LL |     let _ = 0i32: i32: i32.count_ones() as u32 as i32;
-   |             ^^^^^^^^^^^^^^
+   |                 ^ expected one of `.`, `;`, `?`, `else`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     let _ = (0i32: i32: i32).count_ones() as u32 as i32;
-   |             +              +
-help: alternatively, remove the type ascription
-   |
-LL -     let _ = 0i32: i32: i32.count_ones() as u32 as i32;
-LL +     let _ = 0i32: i32.count_ones() as u32 as i32;
    |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:62:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:82:13
    |
 LL |       let _ = 0
    |  _____________^
@@ -202,7 +156,7 @@ LL ~         as i32)
    |
 
 error: cast cannot be followed by indexing
-  --> $DIR/issue-35813-postfix-after-cast.rs:70:18
+  --> $DIR/issue-35813-postfix-after-cast.rs:90:18
    |
 LL |     let x: i32 = &vec![1, 2, 3] as &Vec<i32>[0];
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -213,7 +167,7 @@ LL |     let x: i32 = (&vec![1, 2, 3] as &Vec<i32>)[0];
    |                  +                           +
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:75:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:95:5
    |
 LL |     0 as i32.max(0);
    |     ^^^^^^^^
@@ -223,24 +177,14 @@ help: try surrounding the expression in parentheses
 LL |     (0 as i32).max(0);
    |     +        +
 
-error: type ascription cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:77:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:97:6
    |
 LL |     0: i32.max(0);
-   |     ^^^^^^
+   |      ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     (0: i32).max(0);
-   |     +      +
-help: alternatively, remove the type ascription
-   |
-LL -     0: i32.max(0);
-LL +     0.max(0);
-   |
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:92:8
+  --> $DIR/issue-35813-postfix-after-cast.rs:111:8
    |
 LL |     if 5u64 as i32.max(0) == 0 {
    |        ^^^^^^^^^^^
@@ -250,24 +194,20 @@ help: try surrounding the expression in parentheses
 LL |     if (5u64 as i32).max(0) == 0 {
    |        +           +
 
-error: type ascription cannot be followed by a method call
+error: expected `{`, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:95:8
+  --> $DIR/issue-35813-postfix-after-cast.rs:114:12
    |
 LL |     if 5u64: u64.max(0) == 0 {
-   |        ^^^^^^^^^
+   |            ^ expected `{`
    |
-help: try surrounding the expression in parentheses
+note: the `if` expression is missing a block after this condition
-   |
+  --> $DIR/issue-35813-postfix-after-cast.rs:114:8
-LL |     if (5u64: u64).max(0) == 0 {
-   |        +         +
-help: alternatively, remove the type ascription
-   |
-LL -     if 5u64: u64.max(0) == 0 {
-LL +     if 5u64.max(0) == 0 {
    |
+LL |     if 5u64: u64.max(0) == 0 {
+   |        ^^^^
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:102:9
+  --> $DIR/issue-35813-postfix-after-cast.rs:121:9
    |
 LL |         5u64 as u32.max(0) == 0
    |         ^^^^^^^^^^^
@@ -277,24 +217,14 @@ help: try surrounding the expression in parentheses
 LL |         (5u64 as u32).max(0) == 0
    |         +           +
 
-error: type ascription cannot be followed by a method call
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:106:9
+  --> $DIR/issue-35813-postfix-after-cast.rs:125:13
    |
 LL |         5u64: u64.max(0) == 0
-   |         ^^^^^^^^^
+   |             ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |         (5u64: u64).max(0) == 0
-   |         +         +
-help: alternatively, remove the type ascription
-   |
-LL -         5u64: u64.max(0) == 0
-LL +         5u64.max(0) == 0
-   |
 
 error: cast cannot be followed by indexing
-  --> $DIR/issue-35813-postfix-after-cast.rs:111:24
+  --> $DIR/issue-35813-postfix-after-cast.rs:130:24
    |
 LL | static bar: &[i32] = &(&[1,2,3] as &[i32][0..1]);
    |                        ^^^^^^^^^^^^^^^^^^
@@ -304,24 +234,14 @@ help: try surrounding the expression in parentheses
 LL | static bar: &[i32] = &((&[1,2,3] as &[i32])[0..1]);
    |                        +                  +
 
-error: type ascription cannot be followed by indexing
+error: expected one of `)`, `,`, `.`, `?`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:114:25
+  --> $DIR/issue-35813-postfix-after-cast.rs:133:36
    |
 LL | static bar2: &[i32] = &(&[1i32,2,3]: &[i32; 3][0..1]);
-   |                         ^^^^^^^^^^^^^^^^^^^^^^
+   |                                    ^ expected one of `)`, `,`, `.`, `?`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL | static bar2: &[i32] = &((&[1i32,2,3]: &[i32; 3])[0..1]);
-   |                         +                      +
-help: alternatively, remove the type ascription
-   |
-LL - static bar2: &[i32] = &(&[1i32,2,3]: &[i32; 3][0..1]);
-LL + static bar2: &[i32] = &(&[1i32,2,3][0..1]);
-   |
 
 error: cast cannot be followed by `?`
-  --> $DIR/issue-35813-postfix-after-cast.rs:119:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:138:5
    |
 LL |     Err(0u64) as Result<u64,u64>?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -331,24 +251,28 @@ help: try surrounding the expression in parentheses
 LL |     (Err(0u64) as Result<u64,u64>)?;
    |     +                            +
 
-error: type ascription cannot be followed by `?`
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:121:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:140:14
    |
 LL |     Err(0u64): Result<u64,u64>?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |              ^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: expected identifier, found `:`
+  --> $DIR/issue-35813-postfix-after-cast.rs:152:13
    |
-help: try surrounding the expression in parentheses
+LL |     drop_ptr: F();
+   |             ^ expected identifier
    |
-LL |     (Err(0u64): Result<u64,u64>)?;
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   |     +                          +
+
-help: alternatively, remove the type ascription
+error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
-   |
+  --> $DIR/issue-35813-postfix-after-cast.rs:159:13
-LL -     Err(0u64): Result<u64,u64>?;
-LL +     Err(0u64)?;
    |
+LL |     drop_ptr: fn(u8);
+   |             ^ expected one of 8 possible tokens
 
 error: cast cannot be followed by a function call
-  --> $DIR/issue-35813-postfix-after-cast.rs:145:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:165:5
    |
 LL |     drop as fn(u8)(0);
    |     ^^^^^^^^^^^^^^
@@ -358,24 +282,14 @@ help: try surrounding the expression in parentheses
 LL |     (drop as fn(u8))(0);
    |     +              +
 
-error: type ascription cannot be followed by a function call
+error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:147:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:167:13
    |
 LL |     drop_ptr: fn(u8)(0);
-   |     ^^^^^^^^^^^^^^^^
+   |             ^ expected one of 8 possible tokens
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     (drop_ptr: fn(u8))(0);
-   |     +                +
-help: alternatively, remove the type ascription
-   |
-LL -     drop_ptr: fn(u8)(0);
-LL +     drop_ptr(0);
-   |
 
 error: cast cannot be followed by `.await`
-  --> $DIR/issue-35813-postfix-after-cast.rs:152:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:172:5
    |
 LL |     Box::pin(noop()) as Pin<Box<dyn Future<Output = ()>>>.await;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -385,24 +299,14 @@ help: try surrounding the expression in parentheses
 LL |     (Box::pin(noop()) as Pin<Box<dyn Future<Output = ()>>>).await;
    |     +                                                     +
 
-error: type ascription cannot be followed by `.await`
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:155:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:175:21
    |
 LL |     Box::pin(noop()): Pin<Box<_>>.await;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     (Box::pin(noop()): Pin<Box<_>>).await;
-   |     +                             +
-help: alternatively, remove the type ascription
-   |
-LL -     Box::pin(noop()): Pin<Box<_>>.await;
-LL +     Box::pin(noop()).await;
-   |
 
 error: cast cannot be followed by a field access
-  --> $DIR/issue-35813-postfix-after-cast.rs:167:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:187:5
    |
 LL |     Foo::default() as Foo.bar;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -412,24 +316,14 @@ help: try surrounding the expression in parentheses
 LL |     (Foo::default() as Foo).bar;
    |     +                     +
 
-error: type ascription cannot be followed by a field access
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:169:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:189:19
    |
 LL |     Foo::default(): Foo.bar;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |                   ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |     (Foo::default(): Foo).bar;
-   |     +                   +
-help: alternatively, remove the type ascription
-   |
-LL -     Foo::default(): Foo.bar;
-LL +     Foo::default().bar;
-   |
 
 error: cast cannot be followed by a method call
-  --> $DIR/issue-35813-postfix-after-cast.rs:84:9
+  --> $DIR/issue-35813-postfix-after-cast.rs:103:9
    |
 LL |         if true { 33 } else { 44 } as i32.max(0),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -439,34 +333,18 @@ help: try surrounding the expression in parentheses
 LL |         (if true { 33 } else { 44 } as i32).max(0),
    |         +                                 +
 
-error: type ascription cannot be followed by a method call
+error: expected one of `,`, `.`, `?`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:86:9
+  --> $DIR/issue-35813-postfix-after-cast.rs:105:35
    |
 LL |         if true { 33 } else { 44 }: i32.max(0)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^ expected one of `,`, `.`, `?`, or an operator
-   |
-help: try surrounding the expression in parentheses
-   |
-LL |         (if true { 33 } else { 44 }: i32).max(0)
-   |         +                               +
-help: alternatively, remove the type ascription
-   |
-LL -         if true { 33 } else { 44 }: i32.max(0)
-LL +         if true { 33 } else { 44 }.max(0)
-   |
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-35813-postfix-after-cast.rs:131:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:150:13
    |
 LL |     drop as F();
    |             ^^^ only `Fn` traits may use parentheses
 
-error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+error: aborting due to 39 previous errors
-  --> $DIR/issue-35813-postfix-after-cast.rs:133:15
-   |
-LL |     drop_ptr: F();
-   |               ^^^ only `Fn` traits may use parentheses
-
-error: aborting due to 36 previous errors
 
 For more information about this error, try `rustc --explain E0214`.

tests/ui/parser/issues/issue-44406.rs

@@ -6,5 +6,4 @@ macro_rules! foo {
 
 fn main() {
     foo!(true);
-    //~^ ERROR expected identifier, found keyword
 }

tests/ui/parser/issues/issue-44406.stderr

@@ -1,14 +1,3 @@
-error: expected identifier, found keyword `true`
-  --> $DIR/issue-44406.rs:8:10
-   |
-LL |     foo!(true);
-   |          ^^^^ expected identifier, found keyword
-   |
-help: escape `true` to use it as an identifier
-   |
-LL |     foo!(r#true);
-   |          ++
-
 error: invalid `struct` delimiters or `fn` call arguments
   --> $DIR/issue-44406.rs:3:9
    |
@@ -29,5 +18,5 @@ LL -         bar(baz: $rest)
 LL +         bar(: $rest)
    |
 
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 

tests/ui/parser/issues/issue-91461.rs

@@ -1,6 +1,5 @@
 fn main() {
     a(_:b:,)
-    //~^ ERROR: expected identifier, found reserved identifier `_`
+    //~^ ERROR expected identifier, found reserved identifier
-    //~| ERROR: expected type, found `,`
+    //~| ERROR: expected one of
-    //~| ERROR: expected type, found `,`
 }

tests/ui/parser/issues/issue-91461.stderr

@@ -4,28 +4,11 @@ error: expected identifier, found reserved identifier `_`
 LL |     a(_:b:,)
    |       ^ expected identifier, found reserved identifier
 
-error: expected type, found `,`
+error: expected one of `)`, `,`, `.`, `?`, or an operator, found `:`
-  --> $DIR/issue-91461.rs:2:11
+  --> $DIR/issue-91461.rs:2:8
    |
 LL |     a(_:b:,)
-   |     -    -^ expected type
+   |        ^ expected one of `)`, `,`, `.`, `?`, or an operator
-   |     |    |
-   |     |    tried to parse a type due to this type ascription
-   |     while parsing this struct
-   |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
 
-error: expected type, found `,`
+error: aborting due to 2 previous errors
-  --> $DIR/issue-91461.rs:2:11
-   |
-LL |     a(_:b:,)
-   |          -^ expected type
-   |          |
-   |          tried to parse a type due to this type ascription
-   |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
-
-error: aborting due to 3 previous errors
 

tests/ui/pattern/bindings-after-at/nested-type-ascription-syntactically-invalid.rs

@@ -22,8 +22,7 @@ fn case_1() {
 #[cfg(FALSE)]
 fn case_2() {
     let a @ (b: u8);
-    //~^ ERROR expected one of `!`
+    //~^ ERROR expected one of `)`
-    //~| ERROR expected one of `)`
 }
 
 #[cfg(FALSE)]

tests/ui/pattern/bindings-after-at/nested-type-ascription-syntactically-invalid.stderr

@@ -9,18 +9,14 @@ error: expected one of `)`, `,`, `@`, or `|`, found `:`
    |
 LL |     let a @ (b: u8);
    |               ^ expected one of `)`, `,`, `@`, or `|`
-
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `=`, found `)`
-  --> $DIR/nested-type-ascription-syntactically-invalid.rs:24:19
    |
-LL |     let a @ (b: u8);
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   |                   ^ expected one of 7 possible tokens
 
 error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `=`, found `@`
-  --> $DIR/nested-type-ascription-syntactically-invalid.rs:31:15
+  --> $DIR/nested-type-ascription-syntactically-invalid.rs:30:15
    |
 LL |     let a: T1 @ Outer(b: T2);
    |               ^ expected one of 7 possible tokens
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 

tests/ui/suggestions/many-type-ascription.rs

@@ -1,4 +1,4 @@
 fn main() {
-    let _ = 0: i32; //~ ERROR: type ascription is experimental
+    let _ = 0: i32; //~ ERROR: expected one of
     let _ = 0: i32; // (error only emitted once)
 }

tests/ui/suggestions/many-type-ascription.stderr

@@ -1,12 +1,10 @@
-error[E0658]: type ascription is experimental
+error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
-  --> $DIR/many-type-ascription.rs:2:13
+  --> $DIR/many-type-ascription.rs:2:14
    |
 LL |     let _ = 0: i32;
-   |             ^^^^^^
+   |              ^ expected one of `.`, `;`, `?`, `else`, or an operator
    |
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   = help: add `#![feature(type_ascription)]` to the crate attributes to enable
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0658`.

tests/ui/suggestions/type-ascription-instead-of-let.rs

@@ -3,8 +3,7 @@ fn fun(x: i32) -> i32 { x }
 fn main() {
     let closure_annotated = |value: i32| -> i32 {
         temp: i32 = fun(5i32);
-        //~^ ERROR cannot find value `temp` in this scope
+        //~^ ERROR expected identifier, found `:`
         temp + value + 1
-        //~^ ERROR cannot find value `temp` in this scope
     };
 }

tests/ui/suggestions/type-ascription-instead-of-let.stderr

@@ -1,18 +1,8 @@
-error[E0425]: cannot find value `temp` in this scope
+error: expected identifier, found `:`
-  --> $DIR/type-ascription-instead-of-let.rs:5:9
+  --> $DIR/type-ascription-instead-of-let.rs:5:13
    |
 LL |         temp: i32 = fun(5i32);
-   |         ^^^^
+   |             ^ expected identifier
-   |         |
-   |         not found in this scope
-   |         help: maybe you meant to write an assignment here: `let temp`
 
-error[E0425]: cannot find value `temp` in this scope
+error: aborting due to previous error
-  --> $DIR/type-ascription-instead-of-let.rs:7:9
-   |
-LL |         temp + value + 1
-   |         ^^^^ not found in this scope
 
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0425`.

tests/ui/suggestions/type-ascription-instead-of-method.fixed

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let _ = Box::new("foo".to_string());
-    //~^ ERROR expected type, found
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/suggestions/type-ascription-instead-of-method.rs

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let _ = Box:new("foo".to_string());
-    //~^ ERROR expected type, found
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/suggestions/type-ascription-instead-of-method.stderr

@@ -1,12 +1,10 @@
-error: expected type, found `"foo"`
+error: path separator must be a double colon
-  --> $DIR/type-ascription-instead-of-method.rs:3:21
+  --> $DIR/type-ascription-instead-of-method.rs:3:16
    |
 LL |     let _ = Box:new("foo".to_string());
-   |                -    ^^^^^ expected type
+   |                ^ help: use a double colon instead: `::`
-   |                |
-   |                help: maybe write a path separator here: `::`
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: aborting due to previous error
 

tests/ui/suggestions/type-ascription-instead-of-path-2.fixed

@@ -1,6 +1,6 @@
 // run-rustfix
 fn main() -> Result<(), ()> {
     let _ = vec![Ok(2)].into_iter().collect::<Result<Vec<_>,_>>()?;
-    //~^ ERROR expected `::`, found `(`
+    //~^ ERROR expected one of
     Ok(())
 }

tests/ui/suggestions/type-ascription-instead-of-path-2.rs

@@ -1,6 +1,6 @@
 // run-rustfix
 fn main() -> Result<(), ()> {
     let _ = vec![Ok(2)].into_iter().collect:<Result<Vec<_>,_>>()?;
-    //~^ ERROR expected `::`, found `(`
+    //~^ ERROR expected one of
     Ok(())
 }

tests/ui/suggestions/type-ascription-instead-of-path-2.stderr

@@ -1,12 +1,14 @@
-error: expected `::`, found `(`
+error: expected one of `(`, `.`, `::`, `;`, `?`, `else`, or an operator, found `:`
-  --> $DIR/type-ascription-instead-of-path-2.rs:3:63
+  --> $DIR/type-ascription-instead-of-path-2.rs:3:44
    |
 LL |     let _ = vec![Ok(2)].into_iter().collect:<Result<Vec<_>,_>>()?;
-   |                                            -                  ^ expected `::`
+   |                                            ^ expected one of 7 possible tokens
-   |                                            |
-   |                                            help: maybe write a path separator here: `::`
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+help: maybe write a path separator here
+   |
+LL |     let _ = vec![Ok(2)].into_iter().collect::<Result<Vec<_>,_>>()?;
+   |                                            ~~
 
 error: aborting due to previous error
 

tests/ui/suggestions/type-ascription-instead-of-path.rs

@@ -1,5 +1,4 @@
 fn main() {
     std:io::stdin();
-    //~^ ERROR failed to resolve: use of undeclared crate or module `io`
+    //~^ ERROR path separator must be a double colon
-    //~| ERROR expected value, found crate
 }

tests/ui/suggestions/type-ascription-instead-of-path.stderr

@@ -1,18 +1,10 @@
-error[E0433]: failed to resolve: use of undeclared crate or module `io`
+error: path separator must be a double colon
-  --> $DIR/type-ascription-instead-of-path.rs:2:9
+  --> $DIR/type-ascription-instead-of-path.rs:2:8
    |
 LL |     std:io::stdin();
-   |         ^^ use of undeclared crate or module `io`
+   |        ^ help: use a double colon instead: `::`
-
-error[E0423]: expected value, found crate `std`
-  --> $DIR/type-ascription-instead-of-path.rs:2:5
    |
-LL |     std:io::stdin();
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   |     ^^^- help: maybe you meant to write a path separator here: `::`
-   |     |
-   |     not a value
 
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-Some errors have detailed explanations: E0423, E0433.
-For more information about an error, try `rustc --explain E0423`.

tests/ui/suggestions/type-ascription-instead-of-variant.fixed

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let _ = Option::Some("");
-    //~^ ERROR expected type, found
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/suggestions/type-ascription-instead-of-variant.rs

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let _ = Option:Some("");
-    //~^ ERROR expected type, found
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/suggestions/type-ascription-instead-of-variant.stderr

@@ -1,12 +1,10 @@
-error: expected type, found `""`
+error: path separator must be a double colon
-  --> $DIR/type-ascription-instead-of-variant.rs:3:25
+  --> $DIR/type-ascription-instead-of-variant.rs:3:19
    |
 LL |     let _ = Option:Some("");
-   |                   -     ^^ expected type
+   |                   ^ help: use a double colon instead: `::`
-   |                   |
-   |                   help: maybe write a path separator here: `::`
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: aborting due to previous error
 

tests/ui/type/ascription/issue-34255-1.rs

@@ -1,13 +1,12 @@
+// rustfix
+
 struct Reactor {
     input_cells: Vec<usize>,
 }
 
 impl Reactor {
-    pub fn new() -> Self {
+    pub fn new() -> Self { //~ ERROR struct literal body without path
         input_cells: Vec::new()
-        //~^ ERROR cannot find value `input_cells` in this scope
-        //~| ERROR parenthesized type parameters may only be used with a `Fn` trait
-        //~| ERROR missing generics for struct `Vec`
     }
 }
 

tests/ui/type/ascription/issue-34255-1.stderr

@@ -1,36 +1,18 @@
-error[E0425]: cannot find value `input_cells` in this scope
+error: struct literal body without path
-  --> $DIR/issue-34255-1.rs:7:9
+  --> $DIR/issue-34255-1.rs:8:26
    |
-LL |         input_cells: Vec::new()
+LL |       pub fn new() -> Self {
-   |         ^^^^^^^^^^^ a field by this name exists in `Self`
+   |  __________________________^
+LL | |         input_cells: Vec::new()
+LL | |     }
+   | |_____^
    |
-help: you might have meant to write a `struct` literal
+help: you might have forgotten to add the struct literal inside the block
    |
 LL ~     pub fn new() -> Self { SomeStruct {
 LL |         input_cells: Vec::new()
- ...
+LL ~     } }
-LL |
-LL ~     }}
    |
 
-error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+error: aborting due to previous error
-  --> $DIR/issue-34255-1.rs:7:27
-   |
-LL |         input_cells: Vec::new()
-   |                           ^^^^^ only `Fn` traits may use parentheses
 
-error[E0107]: missing generics for struct `Vec`
-  --> $DIR/issue-34255-1.rs:7:22
-   |
-LL |         input_cells: Vec::new()
-   |                      ^^^ expected at least 1 generic argument
-   |
-help: add missing generic argument
-   |
-LL |         input_cells: Vec<T>::new()
-   |                         +++
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0107, E0214, E0425.
-For more information about an error, try `rustc --explain E0107`.

tests/ui/type/ascription/issue-47666.fixed

@@ -1,4 +1,4 @@
 // run-rustfix
 fn main() {
-    let _ = Option::Some(vec![0, 1]); //~ ERROR expected type, found
+    let _ = Option::Some(vec![0, 1]); //~ ERROR path separator must be a double colon
 }

tests/ui/type/ascription/issue-47666.rs

@@ -1,4 +1,4 @@
 // run-rustfix
 fn main() {
-    let _ = Option:Some(vec![0, 1]); //~ ERROR expected type, found
+    let _ = Option:Some(vec![0, 1]); //~ ERROR path separator must be a double colon
 }

tests/ui/type/ascription/issue-47666.stderr

@@ -1,16 +1,10 @@
-error: expected type, found `<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([0, 1]))`
+error: path separator must be a double colon
-  --> $DIR/issue-47666.rs:3:25
+  --> $DIR/issue-47666.rs:3:19
    |
 LL |     let _ = Option:Some(vec![0, 1]);
-   |                   -     ^^^^^^^^^^
+   |                   ^ help: use a double colon instead: `::`
-   |                   |     |
-   |                   |     expected type
-   |                   |     in this macro invocation
-   |                   |     this macro call doesn't expand to a type
-   |                   help: maybe write a path separator here: `::`
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   = note: this error originates in the macro `$crate::__rust_force_expr` which comes from the expansion of the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to previous error
 

tests/ui/type/ascription/issue-54516.fixed

@@ -3,5 +3,5 @@ use std::collections::BTreeMap;
 
 fn main() {
     println!("{}", std::mem::size_of::<BTreeMap<u32, u32>>());
-    //~^ ERROR type ascription cannot be followed by a function call
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/type/ascription/issue-54516.rs

@@ -3,5 +3,5 @@
 
 fn main() {
     println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
-    //~^ ERROR type ascription cannot be followed by a function call
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/type/ascription/issue-54516.stderr

@@ -1,12 +1,10 @@
-error: type ascription cannot be followed by a function call
+error: path separator must be a double colon
-  --> $DIR/issue-54516.rs:5:20
+  --> $DIR/issue-54516.rs:5:28
    |
 LL |     println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
-   |                    ^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^ help: use a double colon instead: `::`
-   |                            |
-   |                            help: maybe write a path separator here: `::`
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: aborting due to previous error
 

tests/ui/type/ascription/issue-60933.fixed

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let _: usize = std::mem::size_of::<u32>();
-    //~^ ERROR type ascription cannot be followed by a function call
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/type/ascription/issue-60933.rs

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let _: usize = std::mem:size_of::<u32>();
-    //~^ ERROR type ascription cannot be followed by a function call
+    //~^ ERROR path separator must be a double colon
 }

tests/ui/type/ascription/issue-60933.stderr

@@ -1,12 +1,10 @@
-error: type ascription cannot be followed by a function call
+error: path separator must be a double colon
-  --> $DIR/issue-60933.rs:3:20
+  --> $DIR/issue-60933.rs:3:28
    |
 LL |     let _: usize = std::mem:size_of::<u32>();
-   |                    ^^^^^^^^-^^^^^^^^^^^^^^
+   |                            ^ help: use a double colon instead: `::`
-   |                            |
-   |                            help: maybe write a path separator here: `::`
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: aborting due to previous error
 

tests/ui/type/missing-let-in-binding.fixed

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let mut _foo: i32 = 1;
-    let _foo: i32 = 4; //~ ERROR type ascription is experimental
+    let _foo: i32 = 4; //~ ERROR expected identifier, found `:`
 }

tests/ui/type/missing-let-in-binding.rs

@@ -1,5 +1,5 @@
 // run-rustfix
 fn main() {
     let mut _foo: i32 = 1;
-    _foo: i32 = 4; //~ ERROR type ascription is experimental
+    _foo: i32 = 4; //~ ERROR expected identifier, found `:`
 }

tests/ui/type/missing-let-in-binding.stderr

@@ -1,11 +1,10 @@
-error[E0658]: type ascription is experimental
+error: expected identifier, found `:`
-  --> $DIR/missing-let-in-binding.rs:4:5
+  --> $DIR/missing-let-in-binding.rs:4:9
    |
 LL |     _foo: i32 = 4;
-   |     ^^^^^^^^^
+   |         ^ expected identifier
    |
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   = help: add `#![feature(type_ascription)]` to the crate attributes to enable
 help: you might have meant to introduce a new binding
    |
 LL |     let _foo: i32 = 4;
@@ -13,4 +12,3 @@ LL |     let _foo: i32 = 4;
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0658`.

tests/ui/type/type-ascription-instead-of-statement-end.rs

@@ -1,10 +1,8 @@
-#![feature(type_ascription)]
-
 fn main() {
-    println!("test"):
+    println!("test"): //~ ERROR statements are terminated with a semicolon
-    0; //~ ERROR expected type, found `0`
+    0;
 }
 
 fn foo() {
-    println!("test"): 0; //~ ERROR expected type, found `0`
+    println!("test"): 0; //~ ERROR expected one of
 }

tests/ui/type/type-ascription-instead-of-statement-end.stderr

@@ -1,24 +1,16 @@
-error: expected type, found `0`
+error: statements are terminated with a semicolon
-  --> $DIR/type-ascription-instead-of-statement-end.rs:5:5
+  --> $DIR/type-ascription-instead-of-statement-end.rs:2:21
    |
 LL |     println!("test"):
-   |                     - help: try using a semicolon: `;`
+   |                     ^ help: use a semicolon instead: `;`
-LL |     0;
-   |     ^ expected type
    |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
 
-error: expected type, found `0`
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/type-ascription-instead-of-statement-end.rs:9:23
+  --> $DIR/type-ascription-instead-of-statement-end.rs:7:21
    |
 LL |     println!("test"): 0;
-   |                     - ^ expected type
+   |                     ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |                     |
-   |                     tried to parse a type due to this type ascription
-   |
-   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
-   = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
 
 error: aborting due to 2 previous errors
 

tests/ui/type/type-ascription-precedence.rs

@@ -1,10 +1,8 @@
 // Operator precedence of type ascription
 // Type ascription has very high precedence, the same as operator `as`
-
 #![feature(type_ascription)]
 
 use std::ops::*;
-
 struct S;
 struct Z;
 
@@ -25,30 +23,34 @@ impl Deref for S {
     fn deref(&self) -> &Z { panic!() }
 }
 
-fn main() {
+fn test1() {
-    &S: &S; // OK
+    &S: &S; //~ ERROR expected one of
-    (&S): &S; // OK
+    (&S): &S;
-    &(S: &S); //~ ERROR mismatched types
+    &(S: &S);
-
-    *S: Z; // OK
-    (*S): Z; // OK
-    *(S: Z); //~ ERROR mismatched types
-    //~^ ERROR type `Z` cannot be dereferenced
-
-    -S: Z; // OK
-    (-S): Z; // OK
-    -(S: Z); //~ ERROR mismatched types
-    //~^ ERROR cannot apply unary operator `-` to type `Z`
-
-    S + Z: Z; // OK
-    S + (Z: Z); // OK
-    (S + Z): Z; //~ ERROR mismatched types
-
-    S * Z: Z; // OK
-    S * (Z: Z); // OK
-    (S * Z): Z; //~ ERROR mismatched types
-
-    S .. S: S; // OK
-    S .. (S: S); // OK
-    (S .. S): S; //~ ERROR mismatched types
 }
+
+fn test2() {
+    *(S: Z); //~ ERROR expected identifier
+}
+
+fn test3() {
+    -(S: Z); //~ ERROR expected identifier
+}
+
+fn test4() {
+    (S + Z): Z; //~ ERROR expected one of
+}
+
+fn test5() {
+    (S * Z): Z; //~ ERROR expected one of
+}
+
+fn test6() {
+    S .. S: S; //~ ERROR expected identifier, found `:`
+}
+
+fn test7() {
+    (S .. S): S; //~ ERROR expected one of
+}
+
+fn main() {}

tests/ui/type/type-ascription-precedence.stderr

@@ -1,63 +1,46 @@
-error[E0308]: mismatched types
+error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
-  --> $DIR/type-ascription-precedence.rs:31:7
+  --> $DIR/type-ascription-precedence.rs:27:7
    |
-LL |     &(S: &S);
+LL |     &S: &S;
-   |       ^ expected `&S`, found `S`
+   |       ^ expected one of 8 possible tokens
 
-error[E0308]: mismatched types
+error: expected identifier, found `:`
-  --> $DIR/type-ascription-precedence.rs:35:7
+  --> $DIR/type-ascription-precedence.rs:33:8
    |
 LL |     *(S: Z);
-   |       ^ expected `Z`, found `S`
+   |        ^ expected identifier
 
-error[E0614]: type `Z` cannot be dereferenced
+error: expected identifier, found `:`
-  --> $DIR/type-ascription-precedence.rs:35:5
+  --> $DIR/type-ascription-precedence.rs:37:8
-   |
-LL |     *(S: Z);
-   |     ^^^^^^^
-
-error[E0308]: mismatched types
-  --> $DIR/type-ascription-precedence.rs:40:7
    |
 LL |     -(S: Z);
-   |       ^ expected `Z`, found `S`
+   |        ^ expected identifier
 
-error[E0600]: cannot apply unary operator `-` to type `Z`
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/type-ascription-precedence.rs:40:5
+  --> $DIR/type-ascription-precedence.rs:41:12
-   |
-LL |     -(S: Z);
-   |     ^^^^^^^ cannot apply unary operator `-`
-   |
-note: an implementation of `std::ops::Neg` might be missing for `Z`
-  --> $DIR/type-ascription-precedence.rs:9:1
-   |
-LL | struct Z;
-   | ^^^^^^^^ must implement `std::ops::Neg`
-note: the trait `std::ops::Neg` must be implemented
-  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-
-error[E0308]: mismatched types
-  --> $DIR/type-ascription-precedence.rs:45:5
    |
 LL |     (S + Z): Z;
-   |     ^^^^^^^ expected `Z`, found `S`
+   |            ^ expected one of `.`, `;`, `?`, `}`, or an operator
 
-error[E0308]: mismatched types
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/type-ascription-precedence.rs:49:5
+  --> $DIR/type-ascription-precedence.rs:45:12
    |
 LL |     (S * Z): Z;
-   |     ^^^^^^^ expected `Z`, found `S`
+   |            ^ expected one of `.`, `;`, `?`, `}`, or an operator
 
-error[E0308]: mismatched types
+error: expected identifier, found `:`
-  --> $DIR/type-ascription-precedence.rs:53:5
+  --> $DIR/type-ascription-precedence.rs:49:11
+   |
+LL |     S .. S: S;
+   |           ^ expected identifier
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
+  --> $DIR/type-ascription-precedence.rs:53:13
    |
 LL |     (S .. S): S;
-   |     ^^^^^^^^ expected `S`, found `Range<S>`
+   |             ^ expected one of `.`, `;`, `?`, `}`, or an operator
-   |
-   = note: expected struct `S`
-              found struct `std::ops::Range<S>`
 
-error: aborting due to 8 previous errors
+error: aborting due to 7 previous errors
 
-Some errors have detailed explanations: E0308, E0600, E0614.
-For more information about an error, try `rustc --explain E0308`.

tests/ui/type/type-ascription-with-fn-call.fixed

@@ -1,9 +1,7 @@
 // run-rustfix
-#![feature(type_ascription)]
-
 fn main() {
-    f()  ;
+    f()  ; //~ ERROR statements are terminated with a semicolon
-    f(); //~ ERROR expected type, found function
+    f();
 }
 
 fn f() {}

tests/ui/type/type-ascription-with-fn-call.rs

@@ -1,9 +1,7 @@
 // run-rustfix
-#![feature(type_ascription)]
-
 fn main() {
-    f()  :
+    f()  : //~ ERROR statements are terminated with a semicolon
-    f(); //~ ERROR expected type, found function
+    f();
 }
 
 fn f() {}

tests/ui/type/type-ascription-with-fn-call.stderr

@@ -1,11 +1,10 @@
-error[E0573]: expected type, found function `f`
+error: statements are terminated with a semicolon
-  --> $DIR/type-ascription-with-fn-call.rs:6:5
+  --> $DIR/type-ascription-with-fn-call.rs:3:10
    |
 LL |     f()  :
-   |          - help: maybe you meant to write `;` here
+   |          ^ help: use a semicolon instead: `;`
-LL |     f();
+   |
-   |     ^^^ expecting a type here because of type ascription
+   = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0573`.