mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Gracefully handle missing ternary operator

Browse Source
This commit is contained in:
Catherine Flores 2023-07-25 18:27:24 +00:00
parent cb6ab9516b
commit 16481807f5
7 changed files with 220 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_parse/messages.ftl
View File

@ -722,6 +722,10 @@ parse_sugg_wrap_pattern_in_parens = wrap the pattern in parentheses
parse_switch_mut_let_order =
switch the order of `mut` and `let`
parse_ternary_operator = Rust has no ternary operator
.help = use an `if-else` expression instead
parse_tilde_const_lifetime = `~const` may only modify trait bounds, not lifetime bounds
parse_tilde_is_not_unary_operator = `~` cannot be used as a unary operator

8
compiler/rustc_parse/src/errors.rs
View File

@ -365,6 +365,14 @@ pub(crate) enum IfExpressionMissingThenBlockSub {
AddThenBlock(#[primary_span] Span),
}
#[derive(Diagnostic)]
#[diag(parse_ternary_operator)]
#[help]
pub struct TernaryOperator {
#[primary_span]
pub span: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parse_extra_if_in_let_else, applicability = "maybe-incorrect", code = "")]
pub(crate) struct IfExpressionLetSomeSub {

46
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -14,7 +14,7 @@
PatternMethodParamWithoutBody, QuestionMarkInType, QuestionMarkInTypeSugg, SelfParamNotFirst,
StructLiteralBodyWithoutPath, StructLiteralBodyWithoutPathSugg, StructLiteralNeedingParens,
StructLiteralNeedingParensSugg, SuggAddMissingLetStmt, SuggEscapeIdentifier, SuggRemoveComma,
UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
TernaryOperator, UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead,
};
@ -500,6 +500,13 @@ fn is_ident_eq_keyword(found: &TokenKind, expected: &TokenType) -> bool {
// Special-case "expected `;`" errors
if expected.contains(&TokenType::Token(token::Semi)) {
if self.prev_token.kind == token::Question {
self.maybe_ternary_lo = Some(self.prev_token.span.lo());
let result = self.maybe_recover_from_ternary_operator().map(|_| true);
self.maybe_ternary_lo = None;
return result;
}
if self.token.span == DUMMY_SP || self.prev_token.span == DUMMY_SP {
// Likely inside a macro, can't provide meaningful suggestions.
} else if !sm.is_multiline(self.prev_token.span.until(self.token.span)) {
@ -1330,6 +1337,41 @@ pub(super) fn maybe_recover_from_question_mark(&mut self, ty: P<Ty>) -> P<Ty> {
}
}
/// Rust has no ternary operator (`cond ? then : else`). Parse it and try
/// to recover from it if `then` and `else` are valid expressions.
pub(super) fn maybe_recover_from_ternary_operator(&mut self) -> PResult<'a, ()> {
let snapshot = self.create_snapshot_for_diagnostic();
let lo = self.prev_token.span.lo();
if self.prev_token == token::Question
&& match self.parse_expr() {
Ok(_) => true,
Err(err) => {
err.cancel();
// The colon can sometimes be mistaken for type
// ascription. Catch when this happens and continue.
self.token == token::Colon
}
}
{
if self.eat_noexpect(&token::Colon) {
match self.parse_expr() {
Ok(_) => {
self.sess.emit_err(TernaryOperator { span: self.token.span.with_lo(lo) });
}
Err(err) => {
err.cancel();
self.restore_snapshot(snapshot);
}
};
}
} else {
self.restore_snapshot(snapshot);
};
Ok(())
}
pub(super) fn maybe_recover_from_bad_type_plus(&mut self, ty: &Ty) -> PResult<'a, ()> {
// Do not add `+` to expected tokens.
if !self.token.is_like_plus() {
@ -2111,7 +2153,7 @@ pub(super) fn expected_expression_found(&self) -> DiagnosticBuilder<'a, ErrorGua
}
_ => (
self.token.span,
format!("expected expression, found {}", super::token_descr(&self.token),),
format!("expected expression, found {}", super::token_descr(&self.token)),
),
};
let mut err = self.struct_span_err(span, msg);

9
compiler/rustc_parse/src/parser/mod.rs
View File

@ -37,6 +37,7 @@
use rustc_session::parse::ParseSess;
use rustc_span::source_map::{Span, DUMMY_SP};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::BytePos;
use std::ops::Range;
use std::{cmp, mem, slice};
use thin_vec::ThinVec;
@ -157,12 +158,17 @@ pub struct Parser<'a> {
/// Whether the parser is allowed to do recovery.
/// This is disabled when parsing macro arguments, see #103534
pub recovery: Recovery,
/// The low part of a ternary operator (`cond ? then : else`).
/// FIXME(Centri3): This is currently only used so that type ascription is
/// not mentioned in the error. Once the error in `stmt.rs` is removed, this
/// can be removed.
maybe_ternary_lo: Option<BytePos>,
}
// 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<'_>, 272);
rustc_data_structures::static_assert_size!(Parser<'_>, 280);
/// Stores span information about a closure.
#[derive(Clone)]
@ -475,6 +481,7 @@ pub fn new(
},
current_closure: None,
recovery: Recovery::Allowed,
maybe_ternary_lo: None,
};
// Make parser point to the first token.

4
compiler/rustc_parse/src/parser/stmt.rs
View File

@ -576,7 +576,9 @@ pub(crate) fn parse_block_tail(
Applicability::MaybeIncorrect,
);
}
if self.sess.unstable_features.is_nightly_build() {
if self.sess.unstable_features.is_nightly_build()
&& self.maybe_ternary_lo.is_none()
{
// 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>");
}

40
tests/ui/parser/ternary_operator.rs Normal file
View File

@ -0,0 +1,40 @@
fn a() {
let x = 5 > 2 ? true : false;
//~^ ERROR Rust has no ternary operator
//~| HELP use an `if-else` expression instead
//~| ERROR the `?` operator can only be applied to values that implement `Try` [E0277]
//~| HELP the trait `Try` is not implemented for `{integer}`
//~| ERROR the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`) [E0277]
//~| HELP the trait `FromResidual<_>` is not implemented for `()`
}
fn b() {
let x = 5 > 2 ? { true } : { false };
//~^ ERROR Rust has no ternary operator
//~| HELP use an `if-else` expression instead
//~| ERROR the `?` operator can only be applied to values that implement `Try` [E0277]
//~| HELP the trait `Try` is not implemented for `{integer}`
//~| ERROR the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`) [E0277]
//~| HELP the trait `FromResidual<_>` is not implemented for `()`
}
fn c() {
let x = 5 > 2 ? f32::MAX : f32::MIN;
//~^ ERROR Rust has no ternary operator
//~| HELP use an `if-else` expression instead
//~| ERROR the `?` operator can only be applied to values that implement `Try` [E0277]
//~| HELP the trait `Try` is not implemented for `{integer}`
//~| ERROR the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`) [E0277]
//~| HELP the trait `FromResidual<_>` is not implemented for `()`
}
fn main() {
let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
//~^ ERROR Rust has no ternary operator
//~| HELP use an `if-else` expression instead
//~| expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
//~| ERROR the `?` operator can only be applied to values that implement `Try` [E0277]
//~| HELP the trait `Try` is not implemented for `{integer}`
//~| ERROR the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`) [E0277]
//~| HELP the trait `FromResidual<_>` is not implemented for `()`
}

113
tests/ui/parser/ternary_operator.stderr Normal file
View File

@ -0,0 +1,113 @@
error: Rust has no ternary operator
--> $DIR/ternary_operator.rs:2:19
|
LL | let x = 5 > 2 ? true : false;
| ^^^^^^^^^^^^^^^
|
= help: use an `if-else` expression instead
error: Rust has no ternary operator
--> $DIR/ternary_operator.rs:12:19
|
LL | let x = 5 > 2 ? { true } : { false };
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: use an `if-else` expression instead
error: Rust has no ternary operator
--> $DIR/ternary_operator.rs:22:19
|
LL | let x = 5 > 2 ? f32::MAX : f32::MIN;
| ^^^^^^^^^^^^^^^^^^^^^^
|
= help: use an `if-else` expression instead
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
--> $DIR/ternary_operator.rs:32:37
|
LL | let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: Rust has no ternary operator
--> $DIR/ternary_operator.rs:32:19
|
LL | let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: use an `if-else` expression instead
error[E0277]: the `?` operator can only be applied to values that implement `Try`
--> $DIR/ternary_operator.rs:2:17
|
LL | let x = 5 > 2 ? true : false;
| ^^^ the `?` operator cannot be applied to type `{integer}`
|
= help: the trait `Try` is not implemented for `{integer}`
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/ternary_operator.rs:2:19
|
LL | fn a() {
| ------ this function should return `Result` or `Option` to accept `?`
LL | let x = 5 > 2 ? true : false;
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`
error[E0277]: the `?` operator can only be applied to values that implement `Try`
--> $DIR/ternary_operator.rs:12:17
|
LL | let x = 5 > 2 ? { true } : { false };
| ^^^ the `?` operator cannot be applied to type `{integer}`
|
= help: the trait `Try` is not implemented for `{integer}`
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/ternary_operator.rs:12:19
|
LL | fn b() {
| ------ this function should return `Result` or `Option` to accept `?`
LL | let x = 5 > 2 ? { true } : { false };
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`
error[E0277]: the `?` operator can only be applied to values that implement `Try`
--> $DIR/ternary_operator.rs:22:17
|
LL | let x = 5 > 2 ? f32::MAX : f32::MIN;
| ^^^ the `?` operator cannot be applied to type `{integer}`
|
= help: the trait `Try` is not implemented for `{integer}`
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/ternary_operator.rs:22:19
|
LL | fn c() {
| ------ this function should return `Result` or `Option` to accept `?`
LL | let x = 5 > 2 ? f32::MAX : f32::MIN;
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`
error[E0277]: the `?` operator can only be applied to values that implement `Try`
--> $DIR/ternary_operator.rs:32:17
|
LL | let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
| ^^^ the `?` operator cannot be applied to type `{integer}`
|
= help: the trait `Try` is not implemented for `{integer}`
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/ternary_operator.rs:32:19
|
LL | fn main() {
| --------- this function should return `Result` or `Option` to accept `?`
LL | let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`
error: aborting due to 13 previous errors
For more information about this error, try `rustc --explain E0277`.