mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
Remove type ascription from parser and diagnostics

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

Part of #101728

r? `@estebank`
This commit is contained in:
bors 2023-05-02 09:41:35 +00:00
commit 98c33e47a4
97 changed files with 762 additions and 1150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
compiler/rustc_ast/src/ast.rs
View file

@ -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 {

2
compiler/rustc_ast/src/mut_visit.rs
View file

@ -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);
}

23
compiler/rustc_ast/src/util/parser.rs
View file

@ -53,8 +53,6 @@ pub enum AssocOp {
DotDot,
/// `..=` range
DotDotEq,
/// `:`
Colon,
}
#[derive(PartialEq, Debug)]
@ -96,7 +94,6 @@ impl 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 @@ impl AssocOp {
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 @@ impl AssocOp {
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 @@ impl AssocOp {
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
| Colon => false,
| ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq => {
false
}
}
}
@ -177,7 +175,7 @@ impl AssocOp {
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 @@ impl AssocOp {
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 @@ impl AssocOp {
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.
Colon, // `{ 42 }: usize`
// NotEqual | // `{ 42 } != { 42 } struct literals parser recovery.
As // `{ 42 } as usize`
)
}
}
@ -254,7 +251,6 @@ pub enum ExprPrecedence {
Binary(BinOpKind),
Cast,
Type,
Assign,
AssignOp,
@ -313,7 +309,6 @@ impl ExprPrecedence {
// 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,

12
compiler/rustc_ast_pretty/src/pprust/state/expr.rs
View file

@ -341,10 +341,16 @@ impl<'a> State<'a> {
self.print_type(ty);
}
ast::ExprKind::Type(expr, ty) => {
let prec = AssocOp::Colon.precedence() as i8;
self.print_expr_maybe_paren(expr, prec);
self.word_space(":");
self.word("type_ascribe!(");
self.ibox(0);
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);

4
compiler/rustc_builtin_macros/src/asm.rs
View file

@ -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 });
p.maybe_annotate_with_ascription(&mut err, false);
return Err(err);
return Err(diag.create_err(errors::AsmExpectedComma { span: p.token.span }));
} else {
// ...after that delegate to `expect` to also include the other expected tokens.
return Err(p.expect(&token::Comma).err().unwrap());

1
compiler/rustc_builtin_macros/src/assert.rs
View file

@ -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)

1
compiler/rustc_builtin_macros/src/assert/context.rs
View file

@ -182,7 +182,6 @@ impl<'cx, 'a> Context<'cx, 'a> {
delim: MacDelimiter::Parenthesis,
tokens: initial.into_iter().chain(captures).collect::<TokenStream>(),
}),
prior_type_ascription: None,
})),
)
}

1
compiler/rustc_builtin_macros/src/edition_panic.rs
View file

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

2
compiler/rustc_expand/src/base.rs
View file

@ -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 @@ impl<'a> ExtCtxt<'a> {
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,
},

3
compiler/rustc_expand/src/expand.rs
View file

@ -657,8 +657,6 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
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 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
self.error_wrong_fragment_kind(fragment_kind, &mac, span);
fragment_kind.dummy(span)
};
self.cx.current_expansion.prior_type_ascription = prev;
result
}
_ => unreachable!(),

3
compiler/rustc_expand/src/mbe/macro_rules.rs
View file

@ -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);
p.last_type_ascription = cx.current_expansion.prior_type_ascription;
let p = Parser::new(sess, tts, false, None);
if is_local {
cx.resolver.record_macro_rule_usage(node_id, i);

1
compiler/rustc_expand/src/placeholders.rs
View file

@ -21,7 +21,6 @@ pub fn placeholder(
delim: ast::MacDelimiter::Parenthesis,
tokens: ast::tokenstream::TokenStream::new(Vec::new()),
}),
prior_type_ascription: None,
})
}

12
compiler/rustc_hir_pretty/src/lib.rs
View file

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

3
compiler/rustc_mir_build/src/thir/pattern/usefulness.rs
View file

@ -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) => {}
/// }

9
compiler/rustc_parse/messages.ftl
View file

@ -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

22
compiler/rustc_parse/src/errors.rs
View file

@ -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 {

102
compiler/rustc_parse/src/parser/diagnostics.rs
View file

@ -4,7 +4,7 @@ use super::{
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 @@ impl RecoverQPath for Ty {
}
impl RecoverQPath for Pat {
const PATH_STYLE: PathStyle = PathStyle::Pat;
fn to_ty(&self) -> Option<P<Ty>> {
self.to_ty()
}
@ -663,7 +664,6 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
}
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 @@ impl<'a> Parser<'a> {
}
}
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 @@ impl<'a> Parser<'a> {
&& brace_depth == 0
&& bracket_depth == 0 =>
{
debug!("recover_stmt_ return - Semi");
break;
}
_ => self.bump(),

88
compiler/rustc_parse/src/parser/expr.rs
View file

@ -174,10 +174,8 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
break;
}
}
if last_type_ascription_set {
self.last_type_ascription = None;
}
Ok(lhs)
}
@ -743,7 +736,7 @@ impl<'a> Parser<'a> {
(
// `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 @@ impl<'a> Parser<'a> {
&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 @@ impl<'a> Parser<'a> {
);
};
// If type ascription is "likely an error", the user will already be getting a useful
// 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 @@ impl<'a> Parser<'a> {
};
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 @@ impl<'a> Parser<'a> {
}
}
fn look_ahead_type_ascription_as_field(&mut self) -> bool {
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>> {
fn parse_dot_suffix_expr(&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 @@ impl<'a> Parser<'a> {
/// 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)
&& self.look_ahead_type_ascription_as_field()
{
let snapshot = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
Some((self.create_snapshot_for_diagnostic(), fun.kind.clone()))
} else {
None
@ -1216,7 +1168,6 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
return Some(self.mk_expr_err(span));
}
Ok(_) => {}
Err(mut err) => {
err.emit();
}
Err(err) => err.cancel(),
}
}
_ => {}
@ -1516,7 +1465,6 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
}
/// 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 @@ impl<'a> Parser<'a> {
} 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 @@ impl<'a> Parser<'a> {
break;
}
}
None
}
};

2
compiler/rustc_parse/src/parser/item.rs
View file

@ -443,7 +443,7 @@ impl<'a> Parser<'a> {
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) => {

14
compiler/rustc_parse/src/parser/mod.rs
View file

@ -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 @@ impl<'a> Parser<'a> {
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,9 +937,12 @@ impl<'a> Parser<'a> {
// propagate the help message from sub error 'e' to main error 'expect_err;
expect_err.children.push(xx.clone());
}
expect_err.emit();
e.cancel();
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;
}
}
@ -951,6 +950,7 @@ impl<'a> Parser<'a> {
}
}
}
}
if sep.trailing_sep_allowed && self.expect_any_with_type(kets, expect) {
trailing = true;
break;

10
compiler/rustc_parse/src/parser/pat.rs
View file

@ -406,11 +406,11 @@ impl<'a> Parser<'a> {
// 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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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)))

66
compiler/rustc_parse/src/parser/path.rs
View file

@ -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 @@ use rustc_ast::{
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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
) -> 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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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(_)))

105
compiler/rustc_parse/src/parser/stmt.rs
View file

@ -10,6 +10,8 @@ use super::{
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::{Block, BlockCheckMode, Expr, ExprKind, HasAttrs, Local, Stmt};
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 @@ impl<'a> Parser<'a> {
_ => 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 @@ impl<'a> Parser<'a> {
}
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 @@ impl<'a> Parser<'a> {
};
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,
Err(mut e) => {
if let TokenKind::DocComment(..) = self.token.kind &&
let Ok(snippet) = self.span_to_snippet(self.token.span) {
if let TokenKind::DocComment(..) = self.token.kind
&& 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);
@ -608,6 +643,53 @@ impl<'a> Parser<'a> {
);
}
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)
{
@ -617,10 +699,14 @@ impl<'a> Parser<'a> {
e.emit();
self.recover_stmt();
}
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 @@ impl<'a> Parser<'a> {
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))
}

7
compiler/rustc_parse/src/parser/ty.rs
View file

@ -317,7 +317,6 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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 {
path,
args: self.parse_delim_args()?,
prior_type_ascription: self.last_type_ascription,
})))
Ok(TyKind::MacCall(P(MacCall { path, args: self.parse_delim_args()? })))
} else if allow_plus == AllowPlus::Yes && self.check_plus() {
// `Trait1 + Trait2 + 'a`
self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true)

8
compiler/rustc_resolve/src/ident.rs
View file

@ -1345,7 +1345,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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;

14
compiler/rustc_resolve/src/late.rs
View file

@ -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 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}
}
}
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));
ExprKind::Type(ref _type_expr, ref _ty) => {
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

119
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -28,7 +28,7 @@ use rustc_span::edit_distance::find_best_match_for_name;
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,9 +350,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
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
// for typos.
@ -362,7 +360,6 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
// Fallback label.
err.span_label(base_error.span, &base_error.fallback_label);
}
}
self.err_code_special_cases(&mut err, source, path, span);
(err, candidates)
@ -494,24 +491,6 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
.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 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
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 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
})
}
/// 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 {

3
compiler/rustc_session/src/parse.rs
View file

@ -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 @@ impl ParseSess {
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(),

11
src/tools/clippy/clippy_utils/src/sugg.rs
View file

@ -163,7 +163,8 @@ impl<'a> Sugg<'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 @@ impl<'a> Sugg<'a> {
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,

10
src/tools/rustfmt/tests/source/type-ascription.rs
View file

@ -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
}

8
src/tools/rustfmt/tests/target/configs/format_macro_bodies/true.rs
View file

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

8
src/tools/rustfmt/tests/target/configs/format_macro_matchers/false.rs
View file

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

8
src/tools/rustfmt/tests/target/configs/format_macro_matchers/true.rs
View file

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

10
src/tools/rustfmt/tests/target/macros.rs
View file

@ -156,17 +156,13 @@ fn issue1178() {
}
fn issue1739() {
sql_function!(
add_rss_item,
sql_function!(add_rss_item,
add_rss_item_t,
(
a: types::Integer,
(a: types::Integer,
b: types::Timestamptz,
c: types::Text,
d: types::Text,
e: types::Text
)
);
e: types::Text));
w.slice_mut(s![
..,

12
src/tools/rustfmt/tests/target/type-ascription.rs
View file

@ -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
}

2
tests/ui/consts/auxiliary/external_macro.rs
View file

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

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

@ -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()

2
tests/ui/feature-gates/feature-gate-type_ascription.rs
View file

@ -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
}

6
tests/ui/feature-gates/feature-gate-type_ascription.stderr
View file

@ -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

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

@ -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 _: () = {

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

@ -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
--> $DIR/trait-path-missing-gen_arg.rs:6:23
|
LL | fn f1<'a>(arg : Box<dyn X< : 32 >>) {}
| ^^^^^^^^^^^
error: aborting due to 2 previous errors
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0747`.

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

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

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

@ -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>,
| ^
| |
| expected one of `,` or `>`
| help: write a path separator here: `::`
| ^ help: use a double colon instead: `::`
|
= 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

8
tests/ui/issues/issue-22644.rs
View file

@ -1,5 +1,3 @@
#![feature(type_ascription)]
fn main() {
let a: usize = 0;
let long_name: usize = 0;
@ -9,10 +7,6 @@ fn main() {
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`
}

51
tests/ui/issues/issue-22644.stderr
View file

@ -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
|
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
--> $DIR/issue-22644.rs:14: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`
--> $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
error: aborting due to 6 previous errors

3
tests/ui/macros/stringify.rs
View file

@ -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");
assert_eq!(stringify_expr!(expr: T<u8>), "expr: T<u8>");
// There is no syntax for type ascription.
// ExprKind::If
assert_eq!(stringify_expr!(if true {}), "if true {}");

5
tests/ui/or-patterns/or-patterns-syntactic-fail.rs
View file

@ -8,9 +8,12 @@ use E::*;
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

33
tests/ui/or-patterns/or-patterns-syntactic-fail.stderr
View file

@ -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`.

1
tests/ui/parser/attr-stmt-expr-attr-bad.rs
View file

@ -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

107
tests/ui/parser/attr-stmt-expr-attr-bad.stderr
View file

@ -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`.

1
tests/ui/parser/issue-103869.rs
View file

@ -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>
}

10
tests/ui/parser/issue-103869.stderr
View file

@ -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 `:`
--> $DIR/issue-103869.rs:2:8
|
LL | vec: Vec<usize>,
| ^ expected item
error: aborting due to 2 previous errors
error: aborting due to previous error

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

@ -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();
//~^ 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
let _ = 0i32: i32 as i32.count_ones();
//~^ ERROR: cast cannot be followed by a method call
let _ = 0i32: i32: i32.count_ones(); //~ ERROR expected one of
}
pub fn cast_cast_method_call_2() {
let _ = 0 as i32: i32.count_ones(); //~ ERROR expected one of
}
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;
//~^ ERROR: cast cannot be followed by a method call
let _ = 0i32: i32.count_ones() as u32;
//~^ ERROR: type ascription cannot be followed by a method call
}
pub fn cast_cast_method_call_8() {
let _ = 0i32: i32.count_ones() as u32; //~ ERROR expected one of
}
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);
//~^ ERROR: type ascription cannot be followed by a method call
0: i32.max(0); //~ ERROR expected one of
}
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 @@ static bar: &[i32] = &(&[1,2,3] as &[i32][0..1]);
//~^ 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
}

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

@ -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
--> $DIR/issue-35813-postfix-after-cast.rs:12:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:12:18
|
LL | vec![1, 2, 3]: Vec<i32>[0];
| ^^^^^^^^^^^^^^^^^^^^^^^
|
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];
|
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
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
--> $DIR/issue-35813-postfix-after-cast.rs:19:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:19:14
|
LL | (&[0i32]): &[i32; 1][0];
| ^^^^^^^^^^^^^^^^^^^^
|
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];
|
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
error: type ascription cannot be followed by a method call
--> $DIR/issue-35813-postfix-after-cast.rs:39:13
error: expected `{`, found `:`
--> $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();
| ^^^^^^^^^^^^^^
|
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();
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
= 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
--> $DIR/issue-35813-postfix-after-cast.rs:41:13
error: expected one of `!`, `(`, `.`, `::`, `;`, `<`, `?`, or `else`, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:43:21
|
LL | let _ = 0 as i32: i32.count_ones();
| ^^^^^^^^^^^^^
|
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();
| ^ expected one of 8 possible tokens
|
= 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:43:13
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
--> $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
|
LL | let _ = (0i32: i32 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
--> $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
--> $DIR/issue-35813-postfix-after-cast.rs:47:13
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
--> $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
|
LL | let _ = (0i32: i32: i32 as u32 as 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
--> $DIR/issue-35813-postfix-after-cast.rs:49:13
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:60:17
|
LL | let _ = 0i32: i32.count_ones(): u32;
| ^^^^^^^^^
|
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;
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
= 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
--> $DIR/issue-35813-postfix-after-cast.rs:53:13
error: expected one of `.`, `;`, `?`, or `else`, found `:`
--> $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;
| ^^^^^^^^^
|
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;
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
= 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
--> $DIR/issue-35813-postfix-after-cast.rs:57:13
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:78:17
|
LL | let _ = 0i32: i32: i32.count_ones() as u32 as i32;
| ^^^^^^^^^^^^^^
|
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;
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
= 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
--> $DIR/issue-35813-postfix-after-cast.rs:77:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:97:6
|
LL | 0: i32.max(0);
| ^^^^^^
|
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);
|
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
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
--> $DIR/issue-35813-postfix-after-cast.rs:95:8
error: expected `{`, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:114:12
|
LL | if 5u64: u64.max(0) == 0 {
| ^^^^^^^^^
| ^ expected `{`
|
help: try surrounding the expression in parentheses
|
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 {
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 {
| ^^^^
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
--> $DIR/issue-35813-postfix-after-cast.rs:106:9
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:125:13
|
LL | 5u64: u64.max(0) == 0
| ^^^^^^^^^
|
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
|
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
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
--> $DIR/issue-35813-postfix-after-cast.rs:114:25
error: expected one of `)`, `,`, `.`, `?`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:133:36
|
LL | static bar2: &[i32] = &(&[1i32,2,3]: &[i32; 3][0..1]);
| ^^^^^^^^^^^^^^^^^^^^^^
|
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]);
|
| ^ expected one of `)`, `,`, `.`, `?`, or an operator
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 `?`
--> $DIR/issue-35813-postfix-after-cast.rs:121:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $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>)?;
| + +
help: alternatively, remove the type ascription
|
LL - Err(0u64): Result<u64,u64>?;
LL + Err(0u64)?;
= 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/issue-35813-postfix-after-cast.rs:159:13
|
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
--> $DIR/issue-35813-postfix-after-cast.rs:147:5
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:167:13
|
LL | drop_ptr: fn(u8)(0);
| ^^^^^^^^^^^^^^^^
|
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);
|
| ^ expected one of 8 possible tokens
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`
--> $DIR/issue-35813-postfix-after-cast.rs:155:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:175:21
|
LL | Box::pin(noop()): Pin<Box<_>>.await;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
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;
|
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
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
--> $DIR/issue-35813-postfix-after-cast.rs:169:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:189:19
|
LL | Foo::default(): Foo.bar;
| ^^^^^^^^^^^^^^^^^^^
|
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;
|
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
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
--> $DIR/issue-35813-postfix-after-cast.rs:86:9
error: expected one of `,`, `.`, `?`, or an operator, found `:`
--> $DIR/issue-35813-postfix-after-cast.rs:105:35
|
LL | if true { 33 } else { 44 }: i32.max(0)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
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)
|
| ^ expected one of `,`, `.`, `?`, or an operator
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
--> $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
error: aborting due to 39 previous errors
For more information about this error, try `rustc --explain E0214`.

1
tests/ui/parser/issues/issue-44406.rs
View file

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

13
tests/ui/parser/issues/issue-44406.stderr
View file

@ -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

5
tests/ui/parser/issues/issue-91461.rs
View file

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

25
tests/ui/parser/issues/issue-91461.stderr
View file

@ -4,28 +4,11 @@ error: expected identifier, found reserved identifier `_`
LL | a(_:b:,)
| ^ expected identifier, found reserved identifier
error: expected type, found `,`
--> $DIR/issue-91461.rs:2:11
error: expected one of `)`, `,`, `.`, `?`, or an operator, found `:`
--> $DIR/issue-91461.rs:2:8
|
LL | a(_:b:,)
| - -^ expected type
| | |
| | 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
| ^ expected one of `)`, `,`, `.`, `?`, or an operator
error: expected type, found `,`
--> $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
error: aborting due to 2 previous errors

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

@ -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)]

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

@ -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);
| ^ expected one of 7 possible tokens
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
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

2
tests/ui/suggestions/many-type-ascription.rs
View file

@ -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)
}

10
tests/ui/suggestions/many-type-ascription.stderr
View file

@ -1,12 +1,10 @@
error[E0658]: type ascription is experimental
--> $DIR/many-type-ascription.rs:2:13
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
--> $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
= help: add `#![feature(type_ascription)]` to the crate attributes to enable
= note: 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 E0658`.

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

@ -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
};
}

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

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

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

@ -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
}

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

@ -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
}

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

@ -1,12 +1,10 @@
error: expected type, found `"foo"`
--> $DIR/type-ascription-instead-of-method.rs:3:21
error: path separator must be a double colon
--> $DIR/type-ascription-instead-of-method.rs:3:16
|
LL | let _ = Box:new("foo".to_string());
| - ^^^^^ expected type
| |
| help: maybe write a path separator here: `::`
| ^ help: use a double colon instead: `::`
|
= 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

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

@ -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(())
}

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

@ -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(())
}

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

@ -1,12 +1,14 @@
error: expected `::`, found `(`
--> $DIR/type-ascription-instead-of-path-2.rs:3:63
error: expected one of `(`, `.`, `::`, `;`, `?`, `else`, or an operator, found `:`
--> $DIR/type-ascription-instead-of-path-2.rs:3:44
|
LL | let _ = vec![Ok(2)].into_iter().collect:<Result<Vec<_>,_>>()?;
| - ^ expected `::`
| |
| help: maybe write a path separator here: `::`
| ^ expected one of 7 possible tokens
|
= 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

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

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

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

@ -1,18 +1,10 @@
error[E0433]: failed to resolve: use of undeclared crate or module `io`
--> $DIR/type-ascription-instead-of-path.rs:2:9
error: path separator must be a double colon
--> $DIR/type-ascription-instead-of-path.rs:2:8
|
LL | std:io::stdin();
| ^^ use of undeclared crate or module `io`
error[E0423]: expected value, found crate `std`
--> $DIR/type-ascription-instead-of-path.rs:2:5
| ^ help: use a double colon instead: `::`
|
LL | std:io::stdin();
| ^^^- help: maybe you meant to write a path separator here: `::`
| |
| not a value
= 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 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`.

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

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

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

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

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

@ -1,12 +1,10 @@
error: expected type, found `""`
--> $DIR/type-ascription-instead-of-variant.rs:3:25
error: path separator must be a double colon
--> $DIR/type-ascription-instead-of-variant.rs:3:19
|
LL | let _ = Option:Some("");
| - ^^ expected type
| |
| help: maybe write a path separator here: `::`
| ^ help: use a double colon instead: `::`
|
= 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

7
tests/ui/type/ascription/issue-34255-1.rs
View file

@ -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`
}
}

36
tests/ui/type/ascription/issue-34255-1.stderr
View file

@ -1,36 +1,18 @@
error[E0425]: cannot find value `input_cells` in this scope
--> $DIR/issue-34255-1.rs:7:9
error: struct literal body without path
--> $DIR/issue-34255-1.rs:8:26
|
LL | input_cells: Vec::new()
| ^^^^^^^^^^^ a field by this name exists in `Self`
LL | pub fn new() -> 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 ~ } }
|
error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
--> $DIR/issue-34255-1.rs:7:27
|
LL | input_cells: Vec::new()
| ^^^^^ only `Fn` traits may use parentheses
error: aborting due to previous error
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`.

2
tests/ui/type/ascription/issue-47666.fixed
View file

@ -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
}

2
tests/ui/type/ascription/issue-47666.rs
View file

@ -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
}

14
tests/ui/type/ascription/issue-47666.stderr
View file

@ -1,16 +1,10 @@
error: expected type, found `<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([0, 1]))`
--> $DIR/issue-47666.rs:3:25
error: path separator must be a double colon
--> $DIR/issue-47666.rs:3:19
|
LL | let _ = Option:Some(vec![0, 1]);
| - ^^^^^^^^^^
| | |
| | expected type
| | in this macro invocation
| | this macro call doesn't expand to a type
| help: maybe write a path separator here: `::`
| ^ help: use a double colon instead: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
= 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)
= 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

2
tests/ui/type/ascription/issue-54516.fixed
View file

@ -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
}

2
tests/ui/type/ascription/issue-54516.rs
View file

@ -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
}

10
tests/ui/type/ascription/issue-54516.stderr
View file

@ -1,12 +1,10 @@
error: type ascription cannot be followed by a function call
--> $DIR/issue-54516.rs:5:20
error: path separator must be a double colon
--> $DIR/issue-54516.rs:5:28
|
LL | println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
| ^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| help: maybe write a path separator here: `::`
| ^ help: use a double colon instead: `::`
|
= 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

2
tests/ui/type/ascription/issue-60933.fixed
View file

@ -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
}

2
tests/ui/type/ascription/issue-60933.rs
View file

@ -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
}

10
tests/ui/type/ascription/issue-60933.stderr
View file

@ -1,12 +1,10 @@
error: type ascription cannot be followed by a function call
--> $DIR/issue-60933.rs:3:20
error: path separator must be a double colon
--> $DIR/issue-60933.rs:3:28
|
LL | let _: usize = std::mem:size_of::<u32>();
| ^^^^^^^^-^^^^^^^^^^^^^^
| |
| help: maybe write a path separator here: `::`
| ^ help: use a double colon instead: `::`
|
= 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

2
tests/ui/type/missing-let-in-binding.fixed
View file

@ -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 `:`
}

2
tests/ui/type/missing-let-in-binding.rs
View file

@ -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 `:`
}

10
tests/ui/type/missing-let-in-binding.stderr
View file

@ -1,11 +1,10 @@
error[E0658]: type ascription is experimental
--> $DIR/missing-let-in-binding.rs:4:5
error: expected identifier, found `:`
--> $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
= help: add `#![feature(type_ascription)]` to the crate attributes to enable
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
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`.

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

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

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

@ -1,24 +1,16 @@
error: expected type, found `0`
--> $DIR/type-ascription-instead-of-statement-end.rs:5:5
error: statements are terminated with a semicolon
--> $DIR/type-ascription-instead-of-statement-end.rs:2:21
|
LL | println!("test"):
| - help: try using a semicolon: `;`
LL | 0;
| ^ expected type
| ^ help: use a semicolon instead: `;`
|
= 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
= 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: expected type, found `0`
--> $DIR/type-ascription-instead-of-statement-end.rs:9:23
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/type-ascription-instead-of-statement-end.rs:7:21
|
LL | println!("test"): 0;
| - ^ 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
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
error: aborting due to 2 previous errors

58
tests/ui/type/type-ascription-precedence.rs
View file

@ -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() {
&S: &S; // OK
(&S): &S; // OK
&(S: &S); //~ ERROR mismatched types
*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 test1() {
&S: &S; //~ ERROR expected one of
(&S): &S;
&(S: &S);
}
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() {}

73
tests/ui/type/type-ascription-precedence.stderr
View file

@ -1,63 +1,46 @@
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:31:7
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
--> $DIR/type-ascription-precedence.rs:27:7
|
LL | &(S: &S);
| ^ expected `&S`, found `S`
LL | &S: &S;
| ^ expected one of 8 possible tokens
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:35:7
error: expected identifier, found `:`
--> $DIR/type-ascription-precedence.rs:33:8
|
LL | *(S: Z);
| ^ expected `Z`, found `S`
| ^ expected identifier
error[E0614]: type `Z` cannot be dereferenced
--> $DIR/type-ascription-precedence.rs:35:5
|
LL | *(S: Z);
| ^^^^^^^
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:40:7
error: expected identifier, found `:`
--> $DIR/type-ascription-precedence.rs:37:8
|
LL | -(S: Z);
| ^ expected `Z`, found `S`
| ^ expected identifier
error[E0600]: cannot apply unary operator `-` to type `Z`
--> $DIR/type-ascription-precedence.rs:40:5
|
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
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $DIR/type-ascription-precedence.rs:41:12
|
LL | (S + Z): Z;
| ^^^^^^^ expected `Z`, found `S`
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:49:5
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
--> $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
--> $DIR/type-ascription-precedence.rs:53:5
error: expected identifier, found `:`
--> $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>`
|
= note: expected struct `S`
found struct `std::ops::Range<S>`
| ^ expected one of `.`, `;`, `?`, `}`, or an operator
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`.

4
tests/ui/type/type-ascription-with-fn-call.fixed
View file

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

6
tests/ui/type/type-ascription-with-fn-call.rs
View file

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

11
tests/ui/type/type-ascription-with-fn-call.stderr
View file

@ -1,11 +1,10 @@
error[E0573]: expected type, found function `f`
--> $DIR/type-ascription-with-fn-call.rs:6:5
error: statements are terminated with a semicolon
--> $DIR/type-ascription-with-fn-call.rs:3:10
|
LL | f() :
| - help: maybe you meant to write `;` here
LL | f();
| ^^^ expecting a type here because of type ascription
| ^ help: use a semicolon instead: `;`
|
= 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`.