Stop skewing inference in ?'s desugaring

WaffleLapkin · WaffleLapkin · commit b478d2b05561 · 2024-04-03T16:41:13.000Z
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1758,9 +1758,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ///     ControlFlow::Break(residual) =>
     ///         #[allow(unreachable_code)]
     ///         // If there is an enclosing `try {...}`:
-    ///         break 'catch_target Try::from_residual(residual),
+    ///         absurd(break 'catch_target Try::from_residual(residual)),
     ///         // Otherwise:
-    ///         return Try::from_residual(residual),
+    ///         absurd(return Try::from_residual(residual)),
     /// }
     /// ```
     fn lower_expr_try(&mut self, span: Span, sub_expr: &Expr) -> hir::ExprKind<'hir> {
@@ -1769,6 +1769,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
             span,
             Some(self.allow_try_trait.clone()),
         );
+
+        let absurd_allowed_span = self.mark_span_with_reason(
+            DesugaringKind::QuestionMark,
+            span,
+            Some(self.allow_convert_absurd.clone()),
+        );
+
         let try_span = self.tcx.sess.source_map().end_point(span);
         let try_span = self.mark_span_with_reason(
             DesugaringKind::QuestionMark,
@@ -1810,7 +1817,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         // `ControlFlow::Break(residual) =>
         //     #[allow(unreachable_code)]
-        //     return Try::from_residual(residual),`
+        //     absurd(return Try::from_residual(residual)),`
         let break_arm = {
             let residual_ident = Ident::with_dummy_span(sym::residual);
             let (residual_local, residual_local_nid) = self.pat_ident(try_span, residual_ident);
@@ -1823,20 +1830,27 @@ impl<'hir> LoweringContext<'_, 'hir> {
             );
             let ret_expr = if let Some(catch_node) = self.catch_scope {
                 let target_id = Ok(self.lower_node_id(catch_node));
-                self.arena.alloc(self.expr(
+                self.expr(
                     try_span,
                     hir::ExprKind::Break(
                         hir::Destination { label: None, target_id },
                         Some(from_residual_expr),
                     ),
-                ))
+                )
             } else {
-                self.arena.alloc(self.expr(try_span, hir::ExprKind::Ret(Some(from_residual_expr))))
+                self.expr(try_span, hir::ExprKind::Ret(Some(from_residual_expr)))
             };
-            self.lower_attrs(ret_expr.hir_id, &attrs);
+
+            let absurd_expr = self.expr_call_lang_item_fn(
+                absurd_allowed_span,
+                hir::LangItem::Absurd,
+                arena_vec![self; ret_expr],
+            );
+
+            self.lower_attrs(absurd_expr.hir_id, &attrs);
 
             let break_pat = self.pat_cf_break(try_span, residual_local);
-            self.arm(break_pat, ret_expr)
+            self.arm(break_pat, absurd_expr)
         };
 
         hir::ExprKind::Match(
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -130,6 +130,7 @@ struct LoweringContext<'a, 'hir> {
     node_id_to_local_id: NodeMap<hir::ItemLocalId>,
 
     allow_try_trait: Lrc<[Symbol]>,
+    allow_convert_absurd: Lrc<[Symbol]>,
     allow_gen_future: Lrc<[Symbol]>,
     allow_async_iterator: Lrc<[Symbol]>,
     allow_for_await: Lrc<[Symbol]>,
@@ -173,6 +174,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             impl_trait_defs: Vec::new(),
             impl_trait_bounds: Vec::new(),
             allow_try_trait: [sym::try_trait_v2, sym::yeet_desugar_details].into(),
+            allow_convert_absurd: [sym::convert_absurd].into(),
             allow_gen_future: if tcx.features().async_fn_track_caller {
                 [sym::gen_future, sym::closure_track_caller].into()
             } else {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -602,6 +602,7 @@ symbols! {
         const_try,
         constant,
         constructor,
+        convert_absurd,
         convert_identity,
         copy,
         copy_closures,
diff --git a/tests/ui/async-await/issue-67765-async-diagnostic.rs b/tests/ui/async-await/issue-67765-async-diagnostic.rs
@@ -10,7 +10,7 @@ async fn func<'a>() -> Result<(), &'a str> {
 
     let b = &s[..];
 
-    Err(b)?; //~ ERROR cannot return value referencing local variable `s`
+    Err::<(), _>(b)?; //~ ERROR cannot return value referencing local variable `s`
 
     Ok(())
 }
diff --git a/tests/ui/async-await/issue-67765-async-diagnostic.stderr b/tests/ui/async-await/issue-67765-async-diagnostic.stderr
@@ -4,8 +4,8 @@ error[E0515]: cannot return value referencing local variable `s`
 LL |     let b = &s[..];
    |              - `s` is borrowed here
 LL |
-LL |     Err(b)?;
-   |     ^^^^^^^ returns a value referencing data owned by the current function
+LL |     Err::<(), _>(b)?;
+   |     ^^^^^^^^^^^^^^^^ returns a value referencing data owned by the current function
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/try-operator.rs b/tests/ui/consts/try-operator.rs
@@ -7,15 +7,15 @@
 
 fn main() {
     const fn result() -> Result<bool, ()> {
-        Err(())?;
+        Err::<(), _>(())?;
         Ok(true)
     }
 
     const FOO: Result<bool, ()> = result();
     assert_eq!(Err(()), FOO);
 
     const fn option() -> Option<()> {
-        None?;
+        None::<()>?;
         Some(())
     }
     const BAR: Option<()> = option();
diff --git a/tests/ui/consts/try-operator.stderr b/tests/ui/consts/try-operator.stderr
@@ -7,8 +7,8 @@ LL | #![feature(const_convert)]
 error[E0015]: `?` cannot determine the branch of `Result<(), ()>` in constant functions
   --> $DIR/try-operator.rs:10:9
    |
-LL |         Err(())?;
-   |         ^^^^^^^^
+LL |         Err::<(), _>(())?;
+   |         ^^^^^^^^^^^^^^^^^
    |
 note: impl defined here, but it is not `const`
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -21,8 +21,8 @@ LL + #![feature(effects)]
 error[E0015]: `?` cannot convert from residual of `Result<bool, ()>` in constant functions
   --> $DIR/try-operator.rs:10:9
    |
-LL |         Err(())?;
-   |         ^^^^^^^^
+LL |         Err::<(), _>(())?;
+   |         ^^^^^^^^^^^^^^^^^
    |
 note: impl defined here, but it is not `const`
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -35,8 +35,8 @@ LL + #![feature(effects)]
 error[E0015]: `?` cannot determine the branch of `Option<()>` in constant functions
   --> $DIR/try-operator.rs:18:9
    |
-LL |         None?;
-   |         ^^^^^
+LL |         None::<()>?;
+   |         ^^^^^^^^^^^
    |
 note: impl defined here, but it is not `const`
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -49,8 +49,8 @@ LL + #![feature(effects)]
 error[E0015]: `?` cannot convert from residual of `Option<()>` in constant functions
   --> $DIR/try-operator.rs:18:9
    |
-LL |         None?;
-   |         ^^^^^
+LL |         None::<()>?;
+   |         ^^^^^^^^^^^
    |
 note: impl defined here, but it is not `const`
   --> $SRC_DIR/core/src/option.rs:LL:COL
diff --git a/tests/ui/did_you_mean/compatible-variants.stderr b/tests/ui/did_you_mean/compatible-variants.stderr
@@ -61,8 +61,6 @@ LL +     Some(())
 error[E0308]: `?` operator has incompatible types
   --> $DIR/compatible-variants.rs:35:5
    |
-LL | fn d() -> Option<()> {
-   |           ---------- expected `Option<()>` because of return type
 LL |     c()?
    |     ^^^^ expected `Option<()>`, found `()`
    |
diff --git a/tests/ui/impl-trait/cross-return-site-inference.rs b/tests/ui/impl-trait/cross-return-site-inference.rs
@@ -2,34 +2,34 @@
 
 fn foo(b: bool) -> impl std::fmt::Debug {
     if b {
-        return vec![42]
+        return vec![42];
     }
     [].into_iter().collect()
 }
 
 fn bar(b: bool) -> impl std::fmt::Debug {
     if b {
-        return [].into_iter().collect()
+        return [].into_iter().collect();
     }
     vec![42]
 }
 
 fn bak(b: bool) -> impl std::fmt::Debug {
     if b {
-        return std::iter::empty().collect()
+        return std::iter::empty().collect();
     }
     vec![42]
 }
 
 fn baa(b: bool) -> impl std::fmt::Debug {
     if b {
-        return [42].into_iter().collect()
+        return [42].into_iter().collect();
     }
     vec![]
 }
 
 fn muh() -> Result<(), impl std::fmt::Debug> {
-    Err("whoops")?;
+    Err::<(), _>("whoops")?;
     Ok(())
     //~^ ERROR type annotations needed
 }
diff --git a/tests/ui/inference/cannot-infer-closure.rs b/tests/ui/inference/cannot-infer-closure.rs
@@ -1,6 +1,6 @@
 fn main() {
     let x = |a: (), b: ()| {
-        Err(a)?;
+        Err::<(), _>(a)?;
         Ok(b)
         //~^ ERROR type annotations needed
     };
diff --git a/tests/ui/issues/issue-51632-try-desugar-incompatible-types.stderr b/tests/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
@@ -1,8 +1,6 @@
 error[E0308]: `?` operator has incompatible types
   --> $DIR/issue-51632-try-desugar-incompatible-types.rs:8:5
    |
-LL | fn forbidden_narratives() -> Result<isize, ()> {
-   |                              ----------------- expected `Result<isize, ()>` because of return type
 LL |     missing_discourses()?
    |     ^^^^^^^^^^^^^^^^^^^^^ expected `Result<isize, ()>`, found `isize`
    |
diff --git a/tests/ui/label/label_break_value_desugared_break.rs b/tests/ui/label/label_break_value_desugared_break.rs
@@ -5,14 +5,14 @@
 fn main() {
     let _: Result<(), ()> = try {
         'foo: {
-            Err(())?;
+            Err::<(), _>(())?;
             break 'foo;
         }
     };
 
     'foo: {
         let _: Result<(), ()> = try {
-            Err(())?;
+            Err::<(), _>(())?;
             break 'foo;
         };
     }
diff --git a/tests/ui/parser/try-with-nonterminal-block.rs b/tests/ui/parser/try-with-nonterminal-block.rs
@@ -11,7 +11,7 @@ macro_rules! create_try {
 
 fn main() {
     let x: Option<&str> = create_try! {{
-        None?;
+        None::<()>?;
         "Hello world"
     }};
 
diff --git a/tests/ui/suggestions/remove-question-symbol-with-paren.stderr b/tests/ui/suggestions/remove-question-symbol-with-paren.stderr
@@ -1,9 +1,6 @@
 error[E0308]: `?` operator has incompatible types
   --> $DIR/remove-question-symbol-with-paren.rs:5:6
    |
-LL | fn foo() -> Option<()> {
-   |             ---------- expected `Option<()>` because of return type
-LL |     let x = Some(());
 LL |     (x?)
    |      ^^ expected `Option<()>`, found `()`
    |
diff --git a/tests/ui/suggestions/suggest-box.fixed b/tests/ui/suggestions/suggest-box.fixed
@@ -2,7 +2,7 @@
 
 fn main() {
     let _x: Box<dyn Fn() -> Result<(), ()>> = Box::new(|| { //~ ERROR mismatched types
-        Err(())?;
+        Err::<(), _>(())?;
         Ok(())
     });
 }
diff --git a/tests/ui/suggestions/suggest-box.rs b/tests/ui/suggestions/suggest-box.rs
@@ -2,7 +2,7 @@
 
 fn main() {
     let _x: Box<dyn Fn() -> Result<(), ()>> = || { //~ ERROR mismatched types
-        Err(())?;
+        Err::<(), _>(())?;
         Ok(())
     };
 }
diff --git a/tests/ui/suggestions/suggest-box.stderr b/tests/ui/suggestions/suggest-box.stderr
@@ -5,7 +5,7 @@ LL |       let _x: Box<dyn Fn() -> Result<(), ()>> = || {
    |  _____________-------------------------------___^
    | |             |
    | |             expected due to this
-LL | |         Err(())?;
+LL | |         Err::<(), _>(())?;
 LL | |         Ok(())
 LL | |     };
    | |_____^ expected `Box<dyn Fn() -> Result<(), ()>>`, found closure
@@ -16,7 +16,7 @@ LL | |     };
 help: store this in the heap by calling `Box::new`
    |
 LL ~     let _x: Box<dyn Fn() -> Result<(), ()>> = Box::new(|| {
-LL |         Err(())?;
+LL |         Err::<(), _>(())?;
 LL |         Ok(())
 LL ~     });
    |
diff --git a/tests/ui/try-block/try-block-bad-lifetime.rs b/tests/ui/try-block/try-block-bad-lifetime.rs
@@ -12,10 +12,10 @@ pub fn main() {
         // result variable
         let result: Result<(), &str> = try {
             let my_string = String::from("");
-            let my_str: & str = & my_string;
+            let my_str: &str = &my_string;
             //~^ ERROR `my_string` does not live long enough
-            Err(my_str) ?;
-            Err("") ?;
+            Err::<(), _>(my_str)?;
+            Err::<(), _>("")?;
         };
         do_something_with(result);
     }
@@ -25,13 +25,13 @@ pub fn main() {
         let mut i = 5;
         let k = &mut i;
         let mut j: Result<(), &mut i32> = try {
-            Err(k) ?;
+            Err::<(), _>(k)?;
             i = 10; //~ ERROR cannot assign to `i` because it is borrowed
         };
         ::std::mem::drop(k); //~ ERROR use of moved value: `k`
         i = 40; //~ ERROR cannot assign to `i` because it is borrowed
 
-        let i_ptr = if let Err(i_ptr) = j { i_ptr } else { panic ! ("") };
+        let i_ptr = if let Err(i_ptr) = j { i_ptr } else { panic!("") };
         *i_ptr = 50;
     }
 }
diff --git a/tests/ui/try-block/try-block-bad-lifetime.stderr b/tests/ui/try-block/try-block-bad-lifetime.stderr
@@ -1,12 +1,12 @@
 error[E0597]: `my_string` does not live long enough
-  --> $DIR/try-block-bad-lifetime.rs:15:33
+  --> $DIR/try-block-bad-lifetime.rs:15:32
    |
 LL |         let result: Result<(), &str> = try {
    |             ------ borrow later stored here
 LL |             let my_string = String::from("");
    |                 --------- binding `my_string` declared here
-LL |             let my_str: & str = & my_string;
-   |                                 ^^^^^^^^^^^ borrowed value does not live long enough
+LL |             let my_str: &str = &my_string;
+   |                                ^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         };
    |         - `my_string` dropped here while still borrowed
@@ -29,8 +29,8 @@ error[E0382]: use of moved value: `k`
 LL |         let k = &mut i;
    |             - move occurs because `k` has type `&mut i32`, which does not implement the `Copy` trait
 LL |         let mut j: Result<(), &mut i32> = try {
-LL |             Err(k) ?;
-   |                 - value moved here
+LL |             Err::<(), _>(k)?;
+   |                          - value moved here
 ...
 LL |         ::std::mem::drop(k);
    |                          ^ value used here after move
@@ -44,7 +44,7 @@ LL |         let k = &mut i;
 LL |         i = 40;
    |         ^^^^^^ `i` is assigned to here but it was already borrowed
 LL |
-LL |         let i_ptr = if let Err(i_ptr) = j { i_ptr } else { panic ! ("") };
+LL |         let i_ptr = if let Err(i_ptr) = j { i_ptr } else { panic!("") };
    |                                         - borrow later used here
 
 error: aborting due to 4 previous errors
diff --git a/tests/ui/try-block/try-block-maybe-bad-lifetime.rs b/tests/ui/try-block/try-block-maybe-bad-lifetime.rs
diff --git a/tests/ui/try-block/try-block-opt-init.rs b/tests/ui/try-block/try-block-opt-init.rs
diff --git a/tests/ui/try-block/try-block.rs b/tests/ui/try-block/try-block.rs

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ async fn func<'a>() -> Result<(), &'a str> {`
`10`	`10`
`11`	`11`	`let b = &s[..];`
`12`	`12`
`13`		- Err(b)?; //~ ERROR cannot return value referencing local variable `s`
	`13`	+ Err::<(), _>(b)?; //~ ERROR cannot return value referencing local variable `s`
`14`	`14`
`15`	`15`	`Ok(())`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,8 @@ LL \| #![feature(const_convert)]`
`7`	`7`	error[E0015]: `?` cannot determine the branch of `Result<(), ()>` in constant functions
`8`	`8`	`--> $DIR/try-operator.rs:10:9`
`9`	`9`	`\|`
`10`		`-LL \| Err(())?;`
`11`		`- \| ^^^^^^^^`
	`10`	`+LL \| Err::<(), _>(())?;`
	`11`	`+ \| ^^^^^^^^^^^^^^^^^`
`12`	`12`	`\|`
`13`	`13`	note: impl defined here, but it is not `const`
`14`	`14`	`--> $SRC_DIR/core/src/result.rs:LL:COL`
`@@ -21,8 +21,8 @@ LL + #![feature(effects)]`
`21`	`21`	error[E0015]: `?` cannot convert from residual of `Result<bool, ()>` in constant functions
`22`	`22`	`--> $DIR/try-operator.rs:10:9`
`23`	`23`	`\|`
`24`		`-LL \| Err(())?;`
`25`		`- \| ^^^^^^^^`
	`24`	`+LL \| Err::<(), _>(())?;`
	`25`	`+ \| ^^^^^^^^^^^^^^^^^`
`26`	`26`	`\|`
`27`	`27`	note: impl defined here, but it is not `const`
`28`	`28`	`--> $SRC_DIR/core/src/result.rs:LL:COL`
`@@ -35,8 +35,8 @@ LL + #![feature(effects)]`
`35`	`35`	error[E0015]: `?` cannot determine the branch of `Option<()>` in constant functions
`36`	`36`	`--> $DIR/try-operator.rs:18:9`
`37`	`37`	`\|`
`38`		`-LL \| None?;`
`39`		`- \| ^^^^^`
	`38`	`+LL \| None::<()>?;`
	`39`	`+ \| ^^^^^^^^^^^`
`40`	`40`	`\|`
`41`	`41`	note: impl defined here, but it is not `const`
`42`	`42`	`--> $SRC_DIR/core/src/option.rs:LL:COL`
`@@ -49,8 +49,8 @@ LL + #![feature(effects)]`
`49`	`49`	error[E0015]: `?` cannot convert from residual of `Option<()>` in constant functions
`50`	`50`	`--> $DIR/try-operator.rs:18:9`
`51`	`51`	`\|`
`52`		`-LL \| None?;`
`53`		`- \| ^^^^^`
	`52`	`+LL \| None::<()>?;`
	`53`	`+ \| ^^^^^^^^^^^`
`54`	`54`	`\|`
`55`	`55`	note: impl defined here, but it is not `const`
`56`	`56`	`--> $SRC_DIR/core/src/option.rs:LL:COL`
Original file line number	Diff line number	Diff line change
`@@ -61,8 +61,6 @@ LL + Some(())`
`61`	`61`	error[E0308]: `?` operator has incompatible types
`62`	`62`	`--> $DIR/compatible-variants.rs:35:5`
`63`	`63`	`\|`
`64`		`-LL \| fn d() -> Option<()> {`
`65`		- \| ---------- expected `Option<()>` because of return type
`66`	`64`	`LL \| c()?`
`67`	`65`	\| ^^^^ expected `Option<()>`, found `()`
`68`	`66`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -2,34 +2,34 @@`
`2`	`2`
`3`	`3`	`fn foo(b: bool) -> impl std::fmt::Debug {`
`4`	`4`	`if b {`
`5`		`- return vec![42]`
	`5`	`+ return vec![42];`
`6`	`6`	`}`
`7`	`7`	`[].into_iter().collect()`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`fn bar(b: bool) -> impl std::fmt::Debug {`
`11`	`11`	`if b {`
`12`		`- return [].into_iter().collect()`
	`12`	`+ return [].into_iter().collect();`
`13`	`13`	`}`
`14`	`14`	`vec![42]`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`fn bak(b: bool) -> impl std::fmt::Debug {`
`18`	`18`	`if b {`
`19`		`- return std::iter::empty().collect()`
	`19`	`+ return std::iter::empty().collect();`
`20`	`20`	`}`
`21`	`21`	`vec![42]`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`fn baa(b: bool) -> impl std::fmt::Debug {`
`25`	`25`	`if b {`
`26`		`- return [42].into_iter().collect()`
	`26`	`+ return [42].into_iter().collect();`
`27`	`27`	`}`
`28`	`28`	`vec![]`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`fn muh() -> Result<(), impl std::fmt::Debug> {`
`32`		`- Err("whoops")?;`
	`32`	`+ Err::<(), _>("whoops")?;`
`33`	`33`	`Ok(())`
`34`	`34`	`//~^ ERROR type annotations needed`
`35`	`35`	`}`