From 13090889f5b8cbc72b1a14c2cb038dca5727d55c Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Fri, 21 Jan 2022 09:36:24 -0800 Subject: [PATCH 1/3] Disable drop range tracking in generators Generator drop tracking caused an ICE for generators involving the Never type (Issue #93161). Since this breaks miri, we temporarily disable drop tracking so miri is unblocked while we properly fix the issue. --- compiler/rustc_typeck/src/check/generator_interior.rs | 9 ++++++++- src/test/ui/async-await/async-fn-nonsend.rs | 4 ++++ src/test/ui/async-await/unresolved_type_param.rs | 4 ++++ src/test/ui/generator/drop-control-flow.rs | 4 ++++ src/test/ui/generator/issue-57478.rs | 4 ++++ src/test/ui/generator/partial-drop.rs | 4 ++++ 6 files changed, 28 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs index 56b6dd9a28446..cb6a49bd0c045 100644 --- a/compiler/rustc_typeck/src/check/generator_interior.rs +++ b/compiler/rustc_typeck/src/check/generator_interior.rs @@ -22,6 +22,10 @@ use tracing::debug; mod drop_ranges; +// FIXME(eholk): This flag is here to give a quick way to disable drop tracking in case we find +// unexpected breakages while it's still new. It should be removed before too long. +const ENABLE_DROP_TRACKING: bool = false; + struct InteriorVisitor<'a, 'tcx> { fcx: &'a FnCtxt<'a, 'tcx>, types: FxIndexSet>, @@ -77,7 +81,10 @@ impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> { yield_data.expr_and_pat_count, self.expr_count, source_span ); - if self.drop_ranges.is_dropped_at(hir_id, yield_data.expr_and_pat_count) + if ENABLE_DROP_TRACKING + && self + .drop_ranges + .is_dropped_at(hir_id, yield_data.expr_and_pat_count) { debug!("value is dropped at yield point; not recording"); return false; diff --git a/src/test/ui/async-await/async-fn-nonsend.rs b/src/test/ui/async-await/async-fn-nonsend.rs index c5453b67ef5b6..a1a05c0acba47 100644 --- a/src/test/ui/async-await/async-fn-nonsend.rs +++ b/src/test/ui/async-await/async-fn-nonsend.rs @@ -1,6 +1,10 @@ // edition:2018 // compile-flags: --crate-type lib +// FIXME(eholk): temporarily disabled while drop range tracking is disabled +// (see generator_interior.rs:27) +// ignore-test + use std::{cell::RefCell, fmt::Debug, rc::Rc}; fn non_sync() -> impl Debug { diff --git a/src/test/ui/async-await/unresolved_type_param.rs b/src/test/ui/async-await/unresolved_type_param.rs index d313691b38857..187356ca14021 100644 --- a/src/test/ui/async-await/unresolved_type_param.rs +++ b/src/test/ui/async-await/unresolved_type_param.rs @@ -3,6 +3,10 @@ // (rather than give a general error message) // edition:2018 +// FIXME(eholk): temporarily disabled while drop range tracking is disabled +// (see generator_interior.rs:27) +// ignore-test + async fn bar() -> () {} async fn foo() { diff --git a/src/test/ui/generator/drop-control-flow.rs b/src/test/ui/generator/drop-control-flow.rs index 6319a29f5b7d0..8540f7617acde 100644 --- a/src/test/ui/generator/drop-control-flow.rs +++ b/src/test/ui/generator/drop-control-flow.rs @@ -1,5 +1,9 @@ // build-pass +// FIXME(eholk): temporarily disabled while drop range tracking is disabled +// (see generator_interior.rs:27) +// ignore-test + // A test to ensure generators capture values that were conditionally dropped, // and also that values that are dropped along all paths to a yield do not get // included in the generator type. diff --git a/src/test/ui/generator/issue-57478.rs b/src/test/ui/generator/issue-57478.rs index 39710febdb95c..5c23ecbae3273 100644 --- a/src/test/ui/generator/issue-57478.rs +++ b/src/test/ui/generator/issue-57478.rs @@ -1,5 +1,9 @@ // check-pass +// FIXME(eholk): temporarily disabled while drop range tracking is disabled +// (see generator_interior.rs:27) +// ignore-test + #![feature(negative_impls, generators)] struct Foo; diff --git a/src/test/ui/generator/partial-drop.rs b/src/test/ui/generator/partial-drop.rs index 36f6e78cb3bfe..e89e4b61bbff7 100644 --- a/src/test/ui/generator/partial-drop.rs +++ b/src/test/ui/generator/partial-drop.rs @@ -1,3 +1,7 @@ +// FIXME(eholk): temporarily disabled while drop range tracking is disabled +// (see generator_interior.rs:27) +// ignore-test + #![feature(negative_impls, generators)] struct Foo; From 2c2deff74a84b8590c7339a22d23585a2089c767 Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Fri, 21 Jan 2022 09:48:39 -0800 Subject: [PATCH 2/3] Add regression test for #93161 --- src/test/ui/generator/issue-93161.rs | 93 ++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 src/test/ui/generator/issue-93161.rs diff --git a/src/test/ui/generator/issue-93161.rs b/src/test/ui/generator/issue-93161.rs new file mode 100644 index 0000000000000..9988acbcb73e1 --- /dev/null +++ b/src/test/ui/generator/issue-93161.rs @@ -0,0 +1,93 @@ +// edition:2021 +// run-pass + +#![feature(never_type)] + +use std::future::Future; + +// See if we can run a basic `async fn` +pub async fn foo(x: &u32, y: u32) -> u32 { + let y = &y; + let z = 9; + let z = &z; + let y = async { *y + *z }.await; + let a = 10; + let a = &a; + *x + y + *a +} + +async fn add(x: u32, y: u32) -> u32 { + let a = async { x + y }; + a.await +} + +async fn build_aggregate(a: u32, b: u32, c: u32, d: u32) -> u32 { + let x = (add(a, b).await, add(c, d).await); + x.0 + x.1 +} + +enum Never {} +fn never() -> Never { + panic!() +} + +async fn includes_never(crash: bool, x: u32) -> u32 { + let mut result = async { x * x }.await; + if !crash { + return result; + } + #[allow(unused)] + let bad = never(); + result *= async { x + x }.await; + drop(bad); + result +} + +async fn partial_init(x: u32) -> u32 { + #[allow(unreachable_code)] + let _x: (String, !) = (String::new(), return async { x + x }.await); +} + +async fn read_exact(_from: &mut &[u8], _to: &mut [u8]) -> Option<()> { + Some(()) +} + +async fn hello_world() { + let data = [0u8; 1]; + let mut reader = &data[..]; + + let mut marker = [0u8; 1]; + read_exact(&mut reader, &mut marker).await.unwrap(); +} + +fn run_fut(fut: impl Future) -> T { + use std::sync::Arc; + use std::task::{Context, Poll, Wake, Waker}; + + struct MyWaker; + impl Wake for MyWaker { + fn wake(self: Arc) { + unimplemented!() + } + } + + let waker = Waker::from(Arc::new(MyWaker)); + let mut context = Context::from_waker(&waker); + + let mut pinned = Box::pin(fut); + loop { + match pinned.as_mut().poll(&mut context) { + Poll::Pending => continue, + Poll::Ready(v) => return v, + } + } +} + +fn main() { + let x = 5; + assert_eq!(run_fut(foo(&x, 7)), 31); + assert_eq!(run_fut(build_aggregate(1, 2, 3, 4)), 10); + assert_eq!(run_fut(includes_never(false, 4)), 16); + assert_eq!(run_fut(partial_init(4)), 8); + run_fut(hello_world()); +} From ead84d089567eb46eb942ed377a032db921d2e6b Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Fri, 21 Jan 2022 11:06:14 -0800 Subject: [PATCH 3/3] Add reference to breakage this works around --- compiler/rustc_typeck/src/check/generator_interior.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs index cb6a49bd0c045..c6b92db88ae8a 100644 --- a/compiler/rustc_typeck/src/check/generator_interior.rs +++ b/compiler/rustc_typeck/src/check/generator_interior.rs @@ -23,7 +23,8 @@ use tracing::debug; mod drop_ranges; // FIXME(eholk): This flag is here to give a quick way to disable drop tracking in case we find -// unexpected breakages while it's still new. It should be removed before too long. +// unexpected breakages while it's still new. It should be removed before too long. For example, +// see #93161. const ENABLE_DROP_TRACKING: bool = false; struct InteriorVisitor<'a, 'tcx> {