Remove unnecessary maybe_ternary_lo field

Centri3 · Centri3 · commit faa73953c075 · 2023-07-25T18:37:56.000Z
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -501,10 +501,8 @@ impl<'a> Parser<'a> {
         // 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;
+                self.maybe_recover_from_ternary_operator();
+                return Ok(true);
             }
 
             if self.token.span == DUMMY_SP || self.prev_token.span == DUMMY_SP {
@@ -1339,7 +1337,7 @@ impl<'a> Parser<'a> {
 
     /// 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, ()> {
+    pub(super) fn maybe_recover_from_ternary_operator(&mut self) {
         let snapshot = self.create_snapshot_for_diagnostic();
         let lo = self.prev_token.span.lo();
 
@@ -1368,8 +1366,6 @@ impl<'a> Parser<'a> {
         } else {
             self.restore_snapshot(snapshot);
         };
-
-        Ok(())
     }
 
     pub(super) fn maybe_recover_from_bad_type_plus(&mut self, ty: &Ty) -> PResult<'a, ()> {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
@@ -37,7 +37,6 @@ use rustc_errors::{
 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;
@@ -158,17 +157,12 @@ 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<'_>, 280);
+rustc_data_structures::static_assert_size!(Parser<'_>, 272);
 
 /// Stores span information about a closure.
 #[derive(Clone)]
@@ -481,7 +475,6 @@ impl<'a> Parser<'a> {
             },
             current_closure: None,
             recovery: Recovery::Allowed,
-            maybe_ternary_lo: None,
         };
 
         // Make parser point to the first token.
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
@@ -576,9 +576,7 @@ impl<'a> Parser<'a> {
                                 Applicability::MaybeIncorrect,
                             );
                         }
-                        if self.sess.unstable_features.is_nightly_build()
-                            && self.maybe_ternary_lo.is_none()
-                        {
+                        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>");
                         }
diff --git a/tests/ui/parser/ternary_operator.rs b/tests/ui/parser/ternary_operator.rs
@@ -1,40 +1,69 @@
-fn a() {
+// A good chunk of these errors aren't shown to the user, but are still
+// required in the test for it to pass.
+
+fn a() { //~ NOTE this function should return `Result` or `Option` to accept `?`
     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 `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE the `?` operator cannot be applied to type `{integer}`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE cannot use the `?` operator in a function that returns `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
 }
 
-fn b() {
+fn b() { //~ NOTE this function should return `Result` or `Option` to accept `?`
     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 `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE the `?` operator cannot be applied to type `{integer}`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE cannot use the `?` operator in a function that returns `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
 }
 
-fn c() {
+fn c() { //~ NOTE this function should return `Result` or `Option` to accept `?`
     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 `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE the `?` operator cannot be applied to type `{integer}`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE cannot use the `?` operator in a function that returns `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
 }
 
-fn main() {
+fn main() { //~ NOTE this function should return `Result` or `Option` to accept `?`
     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]
+    //~| ERROR expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
+    //~| NOTE expected one of `.`, `;`, `?`, `else`, or an operator
+    //~| 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 `()`
+    //~| NOTE type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE the `?` operator cannot be applied to type `{integer}`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE in this expansion of desugaring of operator `?`
+    //~| NOTE cannot use the `?` operator in a function that returns `()`
+    //~| NOTE in this expansion of desugaring of operator `?`
 }
diff --git a/tests/ui/parser/ternary_operator.stderr b/tests/ui/parser/ternary_operator.stderr
@@ -1,51 +1,53 @@
 error: Rust has no ternary operator
-  --> $DIR/ternary_operator.rs:2:19
+  --> $DIR/ternary_operator.rs:5: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
+  --> $DIR/ternary_operator.rs:21: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
+  --> $DIR/ternary_operator.rs:37: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
+  --> $DIR/ternary_operator.rs:53:37
    |
 LL |     let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
    |                                     ^ 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: Rust has no ternary operator
-  --> $DIR/ternary_operator.rs:32:19
+  --> $DIR/ternary_operator.rs:53: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
+  --> $DIR/ternary_operator.rs:5: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
+  --> $DIR/ternary_operator.rs:5:19
    |
 LL | fn a() {
    | ------ this function should return `Result` or `Option` to accept `?`
@@ -55,15 +57,15 @@ LL |     let x = 5 > 2 ? true : false;
    = 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
+  --> $DIR/ternary_operator.rs:21: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
+  --> $DIR/ternary_operator.rs:21:19
    |
 LL | fn b() {
    | ------ this function should return `Result` or `Option` to accept `?`
@@ -73,15 +75,15 @@ LL |     let x = 5 > 2 ? { true } : { false };
    = 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
+  --> $DIR/ternary_operator.rs:37: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
+  --> $DIR/ternary_operator.rs:37:19
    |
 LL | fn c() {
    | ------ this function should return `Result` or `Option` to accept `?`
@@ -91,15 +93,15 @@ LL |     let x = 5 > 2 ? f32::MAX : f32::MIN;
    = 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
+  --> $DIR/ternary_operator.rs:53: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
+  --> $DIR/ternary_operator.rs:53:19
    |
 LL | fn main() {
    | --------- this function should return `Result` or `Option` to accept `?`

Original file line number	Diff line number	Diff line change
`@@ -576,9 +576,7 @@ impl<'a> Parser<'a> {`
`576`	`576`	`Applicability::MaybeIncorrect,`
`577`	`577`	`);`
`578`	`578`	`}`
`579`		`- if self.sess.unstable_features.is_nightly_build()`
`580`		`- && self.maybe_ternary_lo.is_none()`
`581`		`- {`
	`579`	`+ if self.sess.unstable_features.is_nightly_build() {`
`582`	`580`	`// FIXME(Nilstrieb): Remove this again after a few months.`
`583`	`581`	`err.note("type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>");`
`584`	`582`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,51 +1,53 @@`
`1`	`1`	`error: Rust has no ternary operator`
`2`		`- --> $DIR/ternary_operator.rs:2:19`
	`2`	`+ --> $DIR/ternary_operator.rs:5:19`
`3`	`3`	`\|`
`4`	`4`	`LL \| let x = 5 > 2 ? true : false;`
`5`	`5`	`\| ^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= help: use an `if-else` expression instead
`8`	`8`
`9`	`9`	`error: Rust has no ternary operator`
`10`		`- --> $DIR/ternary_operator.rs:12:19`
	`10`	`+ --> $DIR/ternary_operator.rs:21:19`
`11`	`11`	`\|`
`12`	`12`	`LL \| let x = 5 > 2 ? { true } : { false };`
`13`	`13`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`14`	`14`	`\|`
`15`	`15`	= help: use an `if-else` expression instead
`16`	`16`
`17`	`17`	`error: Rust has no ternary operator`
`18`		`- --> $DIR/ternary_operator.rs:22:19`
	`18`	`+ --> $DIR/ternary_operator.rs:37:19`
`19`	`19`	`\|`
`20`	`20`	`LL \| let x = 5 > 2 ? f32::MAX : f32::MIN;`
`21`	`21`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`22`	`22`	`\|`
`23`	`23`	= help: use an `if-else` expression instead
`24`	`24`
`25`	`25`	error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
`26`		`- --> $DIR/ternary_operator.rs:32:37`
	`26`	`+ --> $DIR/ternary_operator.rs:53:37`
`27`	`27`	`\|`
`28`	`28`	`LL \| let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };`
`29`	`29`	\| ^ expected one of `.`, `;`, `?`, `else`, or an operator
	`30`	`+ \|`
	`31`	`+ = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>`
`30`	`32`
`31`	`33`	`error: Rust has no ternary operator`
`32`		`- --> $DIR/ternary_operator.rs:32:19`
	`34`	`+ --> $DIR/ternary_operator.rs:53:19`
`33`	`35`	`\|`
`34`	`36`	`LL \| let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };`
`35`	`37`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`36`	`38`	`\|`
`37`	`39`	= help: use an `if-else` expression instead
`38`	`40`
`39`	`41`	error[E0277]: the `?` operator can only be applied to values that implement `Try`
`40`		`- --> $DIR/ternary_operator.rs:2:17`
	`42`	`+ --> $DIR/ternary_operator.rs:5:17`
`41`	`43`	`\|`
`42`	`44`	`LL \| let x = 5 > 2 ? true : false;`
`43`	`45`	\| ^^^ the `?` operator cannot be applied to type `{integer}`
`44`	`46`	`\|`
`45`	`47`	= help: the trait `Try` is not implemented for `{integer}`
`46`	`48`
`47`	`49`	error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
`48`		`- --> $DIR/ternary_operator.rs:2:19`
	`50`	`+ --> $DIR/ternary_operator.rs:5:19`
`49`	`51`	`\|`
`50`	`52`	`LL \| fn a() {`
`51`	`53`	\| ------ this function should return `Result` or `Option` to accept `?`
`@@ -55,15 +57,15 @@ LL \| let x = 5 > 2 ? true : false;`
`55`	`57`	= help: the trait `FromResidual<_>` is not implemented for `()`
`56`	`58`
`57`	`59`	error[E0277]: the `?` operator can only be applied to values that implement `Try`
`58`		`- --> $DIR/ternary_operator.rs:12:17`
	`60`	`+ --> $DIR/ternary_operator.rs:21:17`
`59`	`61`	`\|`
`60`	`62`	`LL \| let x = 5 > 2 ? { true } : { false };`
`61`	`63`	\| ^^^ the `?` operator cannot be applied to type `{integer}`
`62`	`64`	`\|`
`63`	`65`	= help: the trait `Try` is not implemented for `{integer}`
`64`	`66`
`65`	`67`	error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
`66`		`- --> $DIR/ternary_operator.rs:12:19`
	`68`	`+ --> $DIR/ternary_operator.rs:21:19`
`67`	`69`	`\|`
`68`	`70`	`LL \| fn b() {`
`69`	`71`	\| ------ this function should return `Result` or `Option` to accept `?`
`@@ -73,15 +75,15 @@ LL \| let x = 5 > 2 ? { true } : { false };`
`73`	`75`	= help: the trait `FromResidual<_>` is not implemented for `()`
`74`	`76`
`75`	`77`	error[E0277]: the `?` operator can only be applied to values that implement `Try`
`76`		`- --> $DIR/ternary_operator.rs:22:17`
	`78`	`+ --> $DIR/ternary_operator.rs:37:17`
`77`	`79`	`\|`
`78`	`80`	`LL \| let x = 5 > 2 ? f32::MAX : f32::MIN;`
`79`	`81`	\| ^^^ the `?` operator cannot be applied to type `{integer}`
`80`	`82`	`\|`
`81`	`83`	= help: the trait `Try` is not implemented for `{integer}`
`82`	`84`
`83`	`85`	error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
`84`		`- --> $DIR/ternary_operator.rs:22:19`
	`86`	`+ --> $DIR/ternary_operator.rs:37:19`
`85`	`87`	`\|`
`86`	`88`	`LL \| fn c() {`
`87`	`89`	\| ------ this function should return `Result` or `Option` to accept `?`
`@@ -91,15 +93,15 @@ LL \| let x = 5 > 2 ? f32::MAX : f32::MIN;`
`91`	`93`	= help: the trait `FromResidual<_>` is not implemented for `()`
`92`	`94`
`93`	`95`	error[E0277]: the `?` operator can only be applied to values that implement `Try`
`94`		`- --> $DIR/ternary_operator.rs:32:17`
	`96`	`+ --> $DIR/ternary_operator.rs:53:17`
`95`	`97`	`\|`
`96`	`98`	`LL \| let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };`
`97`	`99`	\| ^^^ the `?` operator cannot be applied to type `{integer}`
`98`	`100`	`\|`
`99`	`101`	= help: the trait `Try` is not implemented for `{integer}`
`100`	`102`
`101`	`103`	error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
`102`		`- --> $DIR/ternary_operator.rs:32:19`
	`104`	`+ --> $DIR/ternary_operator.rs:53:19`
`103`	`105`	`\|`
`104`	`106`	`LL \| fn main() {`
`105`	`107`	\| --------- this function should return `Result` or `Option` to accept `?`