dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rip it out 

My type ascription
Oh rip it out
Ah
If you think we live too much then
You can sacrifice diagnostics
Don't mix your garbage
Into my syntax
So many weird hacks keep diagnostics alive
Yet I don't even step outside
So many bad diagnostics keep tyasc alive
Yet tyasc doesn't even bother to survive!
This commit is contained in:
Nilstrieb 2022-11-16 21:46:06 +01:00 committed by yukang
parent 2034b6d23c
commit c63b6a437e
97 changed files with 951 additions and 954 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);

1
compiler/rustc_builtin_macros/src/asm.rs
View File

@ -69,7 +69,6 @@ pub fn parse_asm_args<'a>(
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);
} else {
// ...after that delegate to `expect` to also include the other expected tokens.

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 `{`:

8
compiler/rustc_parse/messages.ftl
View File

@ -420,6 +420,14 @@ 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 = 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 {

119
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()
}
@ -237,6 +238,7 @@ impl<'a> DerefMut for SnapshotParser<'a> {
impl<'a> Parser<'a> {
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_span_err<S: Into<MultiSpan>>(
&self,
sp: S,
@ -663,7 +665,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 +789,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]) {
@ -1625,9 +1573,40 @@ impl<'a> Parser<'a> {
if self.eat(&token::Semi) {
return Ok(());
}
if 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,37 +1769,27 @@ 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,
lo: Span,
result: PResult<'a, P<Expr>>,
) -> P<Expr> {
use crate::parser::DUMMY_NODE_ID;
match result {
Ok(x) => x,
Err(mut err) => {
err.emit();
// Recover from parse error, callers expect the closing delim to be consumed.
self.consume_block(delim, ConsumeClosingDelim::Yes);
self.mk_expr(lo.to(self.prev_token.span), ExprKind::Err)
debug!("recover_seq_parse_error: consumed tokens until {:?} {:?}", lo, self.token);
let res = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Err);
if res.id == DUMMY_NODE_ID {
//panic!("debug now ....: {:?}", res);
res
} else {
res
}
}
}
}
@ -1902,7 +1871,7 @@ impl<'a> Parser<'a> {
&& brace_depth == 0
&& bracket_depth == 0 =>
{
debug!("recover_stmt_ return - Semi");
debug!("recover_stmt_ return - Comma");
break;
}
_ => self.bump(),

105
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);
}
@ -296,14 +294,22 @@ impl<'a> Parser<'a> {
continue;
}
// Special cases:
if op.node == AssocOp::As {
lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Cast)?;
continue;
} else if op.node == AssocOp::DotDot || op.node == AssocOp::DotDotEq {
// If we didn't have to handle `x..`/`x..=`, it would be pretty easy to
// generalise it to the Fixity::None code.
lhs = self.parse_expr_range(prec, lhs, op.node, cur_op_span)?;
break;
}
let op = op.node;
// Special cases:
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 +370,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 +379,7 @@ impl<'a> Parser<'a> {
break;
}
}
if last_type_ascription_set {
self.last_type_ascription = None;
}
Ok(lhs)
}
@ -615,7 +619,9 @@ impl<'a> Parser<'a> {
token::Ident(..) if this.may_recover() && this.is_mistaken_not_ident_negation() => {
make_it!(this, attrs, |this, _| this.recover_not_expr(lo))
}
_ => return this.parse_expr_dot_or_call(Some(attrs)),
_ => {
return this.parse_expr_dot_or_call(Some(attrs));
}
}
}
@ -743,7 +749,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 +844,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 +882,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);
}
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 +983,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 +997,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 +1150,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 +1181,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 +1224,7 @@ impl<'a> Parser<'a> {
return Some(self.mk_expr_err(span));
}
Ok(_) => {}
Err(mut err) => {
err.emit();
}
Err(err) => err.cancel(),
}
}
_ => {}
@ -1516,7 +1478,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 +1496,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 +2974,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 +2990,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) => {

23
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<'_>, 320);
/// 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,
@ -832,10 +828,11 @@ impl<'a> Parser<'a> {
}
fn expect_any_with_type(&mut self, kets: &[&TokenKind], expect: TokenExpectType) -> bool {
kets.iter().any(|k| match expect {
let res = kets.iter().any(|k| match expect {
TokenExpectType::Expect => self.check(k),
TokenExpectType::NoExpect => self.token == **k,
})
});
res
}
fn parse_seq_to_before_tokens<T>(
@ -941,10 +938,14 @@ 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();
break;
if self.token == token::Colon {
// we will try to recover in `maybe_recover_struct_lit_bad_delims`
return Err(expect_err);
} else {
expect_err.emit();
break;
}
}
}
}
@ -959,7 +960,6 @@ impl<'a> Parser<'a> {
let t = f(self)?;
v.push(t);
}
Ok((v, trailing, recovered))
}
@ -1045,6 +1045,7 @@ impl<'a> Parser<'a> {
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (ThinVec<T>, bool /* trailing */)> {
let (val, trailing, recovered) = self.parse_seq_to_before_end(ket, sep, f)?;
if !recovered {
self.eat(ket);
}

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

73
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::{pluralize, Applicability, IntoDiagnostic, PResult};
use rustc_span::source_map::{BytePos, Span};
use rustc_span::symbol::{kw, sym, Ident};
use std::mem;
@ -16,7 +17,7 @@ use thin_vec::ThinVec;
use tracing::debug;
/// Specifies how to parse a path.
#[derive(Copy, Clone, PartialEq)]
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum PathStyle {
/// In some contexts, notably in expressions, paths with generic arguments are ambiguous
/// with something else. For example, in expressions `segment < ....` can be interpreted
@ -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,9 @@ 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)?;
if segments.len() > 1 {
//panic!("debug now ...");
}
Ok(Path { segments, span: lo.to(self.prev_token.span), tokens: None })
}
@ -195,7 +216,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 +238,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 +314,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(_)))
@ -679,6 +740,7 @@ impl<'a> Parser<'a> {
&mut self,
ty_generics: Option<&Generics>,
) -> PResult<'a, Option<GenericArg>> {
debug!("pain");
let start = self.token.span;
let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
// Parse lifetime argument.
@ -687,6 +749,7 @@ impl<'a> Parser<'a> {
// Parse const argument.
GenericArg::Const(self.parse_const_arg()?)
} else if self.check_type() {
debug!("type");
// Parse type argument.
// Proactively create a parser snapshot enabling us to rewind and try to reparse the

129
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) {
Ok(true) => true,
Err(mut e) => {
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);
@ -606,21 +641,72 @@ impl<'a> Parser<'a> {
format!("{} {}", comment_marker, doc_comment_marker),
Applicability::MaybeIncorrect,
);
}
if let Err(mut e) =
self.check_mistyped_turbofish_with_multiple_type_params(e, expr)
{
if recover.no() {
return Err(e);
}
e.emit();
self.recover_stmt();
if self.recover_colon_as_semi() {
// recover_colon_as_semi has already emitted a nicer error.
e.cancel();
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.cancel();
self.sess.emit_err(MalformedLoopLabel {
span: label.ident.span,
correct_label: label.ident,
});
*expr = labeled_expr;
break 'break_recover false;
}
Err(err) => {
err.cancel();
self.restore_snapshot(snapshot);
}
}
}
}
_ => {}
}
if let Err(mut e) =
self.check_mistyped_turbofish_with_multiple_type_params(e, expr)
{
if recover.no() {
return Err(e);
}
e.emit();
self.recover_stmt();
}
true
}
true
Ok(false) => false
}
_ => false
};
if replace_with_err {
// We already emitted an error, so don't emit another type error
let sp = expr.span.to(self.prev_token.span);
@ -643,9 +729,10 @@ 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)

4
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -777,6 +777,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
.sess
.create_err(errs::SelfImportOnlyInImportListWithNonEmptyPrefix { span }),
ResolutionError::FailedToResolve { label, suggestion } => {
if label.len() > 0 {
//panic!("debug now");
}
let mut err =
struct_span_err!(self.tcx.sess, span, E0433, "failed to resolve: {}", &label);
err.span_label(span, label);

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;

15
compiler/rustc_resolve/src/late.rs
View File

@ -1264,14 +1264,15 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
opt_ns: Option<Namespace>, // `None` indicates a module path in import
finalize: Option<Finalize>,
) -> PathResult<'a> {
self.r.resolve_path_with_ribs(
let res = self.r.resolve_path_with_ribs(
path,
opt_ns,
&self.parent_scope,
finalize,
Some(&self.ribs),
None,
)
);
res
}
// AST resolution
@ -3488,10 +3489,6 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
//
// Similar thing, for types, happens in `report_errors` above.
let report_errors_for_call = |this: &mut Self, parent_err: Spanned<ResolutionError<'a>>| {
if !source.is_call() {
return Some(parent_err);
}
// Before we start looking for candidates, we have to get our hands
// on the type user is trying to perform invocation on; basically:
// we're transforming `HashMap::new` into just `HashMap`.
@ -3721,6 +3718,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}
/// Handles paths that may refer to associated items.
#[instrument(level = "debug", skip(self))]
fn resolve_qpath(
&mut self,
qself: &Option<P<QSelf>>,
@ -3728,11 +3726,6 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
ns: Namespace,
finalize: Finalize,
) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>> {
debug!(
"resolve_qpath(qself={:?}, path={:?}, ns={:?}, finalize={:?})",
qself, path, ns, finalize,
);
if let Some(qself) = qself {
if qself.position == 0 {
// This is a case like `<T>::B`, where there is no

12
compiler/rustc_resolve/src/late/diagnostics.rs
View File

@ -305,6 +305,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
/// Handles error reporting for `smart_resolve_path_fragment` function.
/// Creates base error and amends it with one short label and possibly some longer helps/notes.
#[instrument(level = "debug", skip(self))]
pub(crate) fn smart_resolve_report_errors(
&mut self,
path: &[Segment],
@ -350,7 +351,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
return (err, candidates);
}
if !self.type_ascription_suggestion(&mut err, base_error.span) {
if !self.suggest_missing_let(&mut err, base_error.span) {
let mut fallback =
self.suggest_trait_and_bounds(&mut err, source, res, span, &base_error);
@ -1823,7 +1824,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
start.to(sm.next_point(start))
}
fn type_ascription_suggestion(&self, err: &mut Diagnostic, base_span: Span) -> bool {
#[instrument(level = "debug", skip(self, err))]
fn suggest_missing_let(&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() {
@ -1878,12 +1880,6 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
}
}
}
if show_label {
err.span_label(
base_span,
"expecting a type here because of type ascription",
);
}
return show_label;
}
}

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

5
tests/ui/generic-associated-types/equality-bound.stderr
View File

@ -36,7 +36,10 @@ error[E0433]: failed to resolve: use of undeclared type `I`
--> $DIR/equality-bound.rs:9:41
|
LL | fn sum3<J: Iterator>(i: J) -> i32 where I::Item = i32 {
| ^ use of undeclared type `I`
| ^
| |
| use of undeclared type `I`
| help: a type parameter with a similar name exists: `J`
error: aborting due to 4 previous errors

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: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
error: aborting due to previous error

12
tests/ui/issues/issue-22644.rs
View File

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

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

15
tests/ui/macros/builtin-prelude-no-accidents.stderr
View File

@ -4,18 +4,21 @@ error[E0433]: failed to resolve: use of undeclared crate or module `env`
LL | env::current_dir;
| ^^^ use of undeclared crate or module `env`
error[E0433]: failed to resolve: use of undeclared crate or module `vec`
--> $DIR/builtin-prelude-no-accidents.rs:7:14
|
LL | type B = vec::Vec<u8>;
| ^^^
| |
| use of undeclared crate or module `vec`
| help: a struct with a similar name exists (notice the capitalization): `Vec`
error[E0433]: failed to resolve: use of undeclared crate or module `panic`
--> $DIR/builtin-prelude-no-accidents.rs:6:14
|
LL | type A = panic::PanicInfo;
| ^^^^^ use of undeclared crate or module `panic`
error[E0433]: failed to resolve: use of undeclared crate or module `vec`
--> $DIR/builtin-prelude-no-accidents.rs:7:14
|
LL | type B = vec::Vec<u8>;
| ^^^ use of undeclared crate or module `vec`
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0433`.

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

195
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:9: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,11 @@ LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
| ^ expected expression
error: an inner attribute is not permitted in this context
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:10:38
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:13:38
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
| ^^^^^^^^
@ -35,13 +48,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:13: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:16:36
|
LL | #[cfg(FALSE)] fn e() { let _ = 0 + #![attr] 0; }
| ^^^^^^^^
@ -50,7 +63,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:18:33
|
LL | #[cfg(FALSE)] fn e() { let _ = !#![attr] 0; }
| ^^^^^^^^
@ -59,7 +72,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:20:33
|
LL | #[cfg(FALSE)] fn e() { let _ = -#![attr] 0; }
| ^^^^^^^^
@ -68,13 +81,17 @@ 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:22: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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:21:35
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:24:35
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] foo; }
| ^^^^^^^^
@ -83,7 +100,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:23:40
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:26:40
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] foo; }
| ^^^^^^^^
@ -92,7 +113,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:25:35
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:28:35
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] {foo}; }
| ^^^^^^^^
@ -101,7 +126,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:27:40
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:30:40
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
| ^^^^^^^^
@ -110,19 +139,31 @@ LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
= note: outer attributes, like `#[test]`, annotate the item following them
error: expected expression, found `..`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:29:40
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:32:40
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..#[attr] 0; }
| ^^ expected expression
error: expected expression, found `..`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:31:40
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:34:40
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..; }
| ^^ expected expression
error: an inner attribute is not permitted in this context
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:33:41
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:36:41
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &#![attr] 0; }
| ^^^^^^^^
@ -131,7 +172,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:35:45
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:38:45
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &mut #![attr] 0; }
| ^^^^^^^^
@ -140,7 +185,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:37:37
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:40:37
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -149,7 +198,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:39:38
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:42:38
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {#![attr]}; }
| ^^^^^^^^
@ -158,13 +211,21 @@ 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 `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:41:40
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:44:40
>>>>>>> 30182b1d322 (Rip it out)
|
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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:43:45
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:46:45
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] {}; }
| ---- ^^^^^^^ -- the attributes are attached to this branch
@ -173,7 +234,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:45:46
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:48:46
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else {#![attr]}; }
| ^^^^^^^^
@ -182,7 +247,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:47:45
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:50:45
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] if 0 {}; }
| ---- ^^^^^^^ ------- the attributes are attached to this branch
@ -191,7 +260,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:49:50
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:52:50
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -200,7 +273,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:51:51
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:54:51
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 {#![attr]}; }
| ^^^^^^^^
@ -209,7 +286,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:53:45
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:56:45
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -218,7 +299,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:55:46
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:58:46
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {#![attr]}; }
| ^^^^^^^^
@ -227,13 +312,21 @@ 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 `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:57:48
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:60:48
>>>>>>> 30182b1d322 (Rip it out)
|
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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:59:53
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:62:53
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] {}; }
| ---- ^^^^^^^ -- the attributes are attached to this branch
@ -242,7 +335,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:61:54
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:64:54
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else {#![attr]}; }
| ^^^^^^^^
@ -251,7 +348,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:63:53
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:66:53
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] if let _ = 0 {}; }
| ---- ^^^^^^^ --------------- the attributes are attached to this branch
@ -260,7 +361,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:65:66
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:68:66
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 #[attr] {}; }
| -- ^^^^^^^ -- the attributes are attached to this branch
@ -269,7 +374,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:67:67
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:70:67
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 {#![attr]}; }
| ^^^^^^^^
@ -278,7 +387,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:70:32
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:73:32
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] let _ = 0; }
| ------- ^^^^^^^^ not permitted following an outer attribute
@ -289,7 +402,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:72:32
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:75:32
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] 0; }
| ------- ^^^^^^^^ not permitted following an outer attribute
@ -300,7 +417,11 @@ 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
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:74:32
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:77:32
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
| ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
@ -316,7 +437,11 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!(); }
|
error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:76:32
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:79:32
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
| ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
@ -332,7 +457,11 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo![]; }
|
error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:78:32
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:81:32
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
| ------- ^^^^^^^^ ------ the inner attribute doesn't annotate this item macro invocation
@ -348,7 +477,11 @@ LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!{}; }
|
error[E0586]: inclusive range with no end
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:84:35
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:87:35
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
| ^^^ help: use `..` instead
@ -356,13 +489,21 @@ 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 `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:84:38
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:87:38
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
| ^ expected one of `=>`, `if`, or `|`
error[E0586]: inclusive range with no end
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:87:35
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:90:35
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
| ^^^ help: use `..` instead
@ -370,19 +511,31 @@ 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 `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:87:38
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:90:38
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
| ^ expected one of `=>`, `if`, or `|`
error: unexpected token: `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:90:39
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:93:39
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=-#[attr] 10 => () } }
| ^
error[E0586]: inclusive range with no end
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:92:35
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:95:35
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
| ^^^ help: use `..` instead
@ -390,47 +543,79 @@ 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 `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:92:38
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:95:38
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
| ^ expected one of `=>`, `if`, or `|`
error: unexpected token: `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:96:34
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:99:34
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
| ^
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:96:34
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:99:34
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: unexpected token: `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:99:34
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:102:34
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
| ^
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:99:34
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:102:34
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: expected statement after outer attribute
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:104:37
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:107:37
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr]; } } }
| ^^^^^^^
error: expected statement after outer attribute
<<<<<<< HEAD
--> $DIR/attr-stmt-expr-attr-bad.rs:106:37
=======
--> $DIR/attr-stmt-expr-attr-bad.rs:109:37
>>>>>>> 30182b1d322 (Rip it out)
|
LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr] } } }
| ^^^^^^^
<<<<<<< HEAD
error: aborting due to 52 previous errors
=======
error: aborting due to 54 previous errors
>>>>>>> 30182b1d322 (Rip it out)
For more information about this error, try `rustc --explain E0586`.

18
tests/ui/parser/dyn-trait-compatibility.stderr
View File

@ -1,9 +1,3 @@
error[E0433]: failed to resolve: use of undeclared crate or module `dyn`
--> $DIR/dyn-trait-compatibility.rs:3:11
|
LL | type A1 = dyn::dyn;
| ^^^ use of undeclared crate or module `dyn`
error[E0412]: cannot find type `dyn` in this scope
--> $DIR/dyn-trait-compatibility.rs:1:11
|
@ -46,6 +40,18 @@ error[E0412]: cannot find type `dyn` in this scope
LL | type A3 = dyn<<dyn as dyn>::dyn>;
| ^^^ not found in this scope
error[E0433]: failed to resolve: use of undeclared crate or module `dyn`
--> $DIR/dyn-trait-compatibility.rs:3:11
|
LL | type A1 = dyn::dyn;
| ^^^ use of undeclared crate or module `dyn`
error[E0433]: failed to resolve: use of undeclared crate or module `dyn`
--> $DIR/dyn-trait-compatibility.rs:9:23
|
LL | type A3 = dyn<<dyn as dyn>::dyn>;
| ^^^ use of undeclared crate or module `dyn`
error: aborting due to 8 previous errors
Some errors have detailed explanations: E0405, E0412, E0433.

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

15
tests/ui/pattern/pattern-error-continue.stderr
View File

@ -1,9 +1,3 @@
error[E0433]: failed to resolve: use of undeclared type `E`
--> $DIR/pattern-error-continue.rs:33:9
|
LL | E::V => {}
| ^ use of undeclared type `E`
error[E0532]: expected tuple struct or tuple variant, found unit variant `A::D`
--> $DIR/pattern-error-continue.rs:18:9
|
@ -56,6 +50,15 @@ note: function defined here
LL | fn f(_c: char) {}
| ^ --------
error[E0433]: failed to resolve: use of undeclared type `E`
--> $DIR/pattern-error-continue.rs:33:9
|
LL | E::V => {}
| ^
| |
| use of undeclared type `E`
| help: an enum with a similar name exists: `A`
error: aborting due to 5 previous errors
Some errors have detailed explanations: E0023, E0308, E0433, E0532.

2
tests/ui/resolve/resolve-variant-assoc-item.rs
View File

@ -3,5 +3,5 @@ use E::V;
fn main() {
E::V::associated_item; //~ ERROR failed to resolve: `V` is a variant, not a module
V::associated_item; //~ ERROR failed to resolve: `V` is a variant, not a module
V::associated_item(); //~ ERROR failed to resolve: `V` is a variant, not a module
}

16
tests/ui/resolve/resolve-variant-assoc-item.stderr
View File

@ -3,12 +3,26 @@ error[E0433]: failed to resolve: `V` is a variant, not a module
|
LL | E::V::associated_item;
| ^ `V` is a variant, not a module
|
help: there is an enum variant `E::V`; try using the variant's enum
|
LL | E;
| ~
error[E0433]: failed to resolve: `V` is a variant, not a module
--> $DIR/resolve-variant-assoc-item.rs:6:5
|
LL | V::associated_item;
LL | V::associated_item();
| ^ `V` is a variant, not a module
|
help: there is an enum variant `E::V`; try using the variant's enum
|
LL | E();
| ~
help: an enum with a similar name exists
|
LL | E::associated_item();
| ~
error: aborting due to 2 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 colo
}

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

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: 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: 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: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
error: aborting due to previous error

6
tests/ui/traits/associated_type_bound/assoc_type_bound_with_struct.stderr
View File

@ -85,6 +85,12 @@ LL | fn issue_95327() where <u8 as Unresolved>::Assoc: String {}
|
= note: similarly named trait `ToString` defined here
error[E0433]: failed to resolve: use of undeclared type `Unresolved`
--> $DIR/assoc_type_bound_with_struct.rs:19:31
|
LL | fn issue_95327() where <u8 as Unresolved>::Assoc: String {}
| ^^^^^^^^^^ use of undeclared type `Unresolved`
error: aborting due to 6 previous errors
Some errors have detailed explanations: E0404, E0405.

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

38
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 ~ }}
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: 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: 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: 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: 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

19
tests/ui/type/type-ascription-precedence.rs
View File

@ -1,8 +1,5 @@
// Operator precedence of type ascription
// Type ascription has very high precedence, the same as operator `as`
#![feature(type_ascription)]
use std::ops::*;
struct S;
@ -26,29 +23,27 @@ impl Deref for S {
}
fn main() {
&S: &S; // OK
&S: &S; //~ ERROR expected one of
(&S): &S; // OK
&(S: &S); //~ ERROR mismatched types
&(S: &S);
*S: Z; // OK
(*S): Z; // OK
*(S: Z); //~ ERROR mismatched types
//~^ ERROR type `Z` cannot be dereferenced
*(S: Z);
-S: Z; // OK
(-S): Z; // OK
-(S: Z); //~ ERROR mismatched types
//~^ ERROR cannot apply unary operator `-` to type `Z`
-(S: Z);
S + Z: Z; // OK
S + (Z: Z); // OK
(S + Z): Z; //~ ERROR mismatched types
(S + Z): Z;
S * Z: Z; // OK
S * (Z: Z); // OK
(S * Z): Z; //~ ERROR mismatched types
(S * Z): Z;
S .. S: S; // OK
S .. (S: S); // OK
(S .. S): S; //~ ERROR mismatched types
(S .. S): S;
}

65
tests/ui/type/type-ascription-precedence.stderr
View File

@ -1,63 +1,8 @@
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:31:7
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
--> $DIR/type-ascription-precedence.rs:26: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
|
LL | *(S: Z);
| ^ expected `Z`, found `S`
error: aborting due to previous error
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
|
LL | -(S: Z);
| ^ expected `Z`, found `S`
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
|
LL | (S + Z): Z;
| ^^^^^^^ expected `Z`, found `S`
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:49:5
|
LL | (S * Z): Z;
| ^^^^^^^ expected `Z`, found `S`
error[E0308]: mismatched types
--> $DIR/type-ascription-precedence.rs:53:5
|
LL | (S .. S): S;
| ^^^^^^^^ expected `S`, found `Range<S>`
|
= note: expected struct `S`
found struct `std::ops::Range<S>`
error: aborting due to 8 previous errors
Some errors have detailed explanations: E0308, E0600, E0614.
For more information about an error, try `rustc --explain E0308`.

6
tests/ui/type/type-ascription-with-fn-call.fixed
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() {}

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

12
tests/ui/type/type-path-err-node-types.stderr
View File

@ -1,9 +1,3 @@
error[E0433]: failed to resolve: use of undeclared type `NonExistent`
--> $DIR/type-path-err-node-types.rs:15:5
|
LL | NonExistent::Assoc::<u8>;
| ^^^^^^^^^^^ use of undeclared type `NonExistent`
error[E0412]: cannot find type `Nonexistent` in this scope
--> $DIR/type-path-err-node-types.rs:7:12
|
@ -22,6 +16,12 @@ error[E0425]: cannot find value `nonexistent` in this scope
LL | nonexistent.nonexistent::<u8>();
| ^^^^^^^^^^^ not found in this scope
error[E0433]: failed to resolve: use of undeclared type `NonExistent`
--> $DIR/type-path-err-node-types.rs:15:5
|
LL | NonExistent::Assoc::<u8>;
| ^^^^^^^^^^^ use of undeclared type `NonExistent`
error[E0282]: type annotations needed
--> $DIR/type-path-err-node-types.rs:23:14
|

22
tests/ui/ufcs/ufcs-partially-resolved.stderr
View File

@ -1,3 +1,25 @@
error[E0433]: failed to resolve: `Y` is a variant, not a module
--> $DIR/ufcs-partially-resolved.rs:48:22
|
LL | let _: <u8 as E::Y>::NN;
| ^ `Y` is a variant, not a module
|
help: there is an enum variant `E::Y`; try using the variant's enum
|
LL | let _: E;
| ~
error[E0433]: failed to resolve: `Y` is a variant, not a module
--> $DIR/ufcs-partially-resolved.rs:50:15
|
LL | <u8 as E::Y>::NN;
| ^ `Y` is a variant, not a module
|
help: there is an enum variant `E::Y`; try using the variant's enum
|
LL | E;
| ~
error[E0576]: cannot find associated type `N` in trait `Tr`
--> $DIR/ufcs-partially-resolved.rs:19:24
|