bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Squash

Browse source
This commit is contained in:
David Haig 2019-11-25 12:58:40 +00:00
parent 96ad8e5fbc
commit ec41fda58b
13 changed files with 192 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/librustc/mir/interpret/error.rs
View file

@ -266,6 +266,8 @@ pub enum PanicInfo<O> {
RemainderByZero,
GeneratorResumedAfterReturn,
GeneratorResumedAfterPanic,
AsyncResumedAfterReturn,
AsyncResumedAfterPanic,
}
/// Type for MIR `Assert` terminator error messages.
@ -304,6 +306,10 @@ impl<O> PanicInfo<O> {
"generator resumed after completion",
GeneratorResumedAfterPanic =>
"generator resumed after panicking",
AsyncResumedAfterReturn =>
"`async fn` resumed after completion",
AsyncResumedAfterPanic =>
"`async fn` resumed after panic",
Panic { .. } | BoundsCheck { .. } =>
bug!("Unexpected PanicInfo"),
}

14
src/librustc/mir/mod.rs
View file

@ -6,7 +6,7 @@
use crate::hir::def::{CtorKind, Namespace};
use crate::hir::def_id::DefId;
use crate::hir;
use crate::hir::GeneratorKind;
use crate::mir::interpret::{GlobalAlloc, PanicInfo, Scalar};
use crate::mir::visit::MirVisitable;
use crate::ty::adjustment::PointerCast;
@ -117,6 +117,10 @@ pub struct Body<'tcx> {
/// The layout of a generator. Produced by the state transformation.
pub generator_layout: Option<GeneratorLayout<'tcx>>,
/// If this is a generator then record the type of source expression that caused this generator
/// to be created.
pub generator_kind: Option<GeneratorKind>,
/// Declarations of locals.
///
/// The first local is the return value pointer, followed by `arg_count`
@ -170,6 +174,7 @@ impl<'tcx> Body<'tcx> {
var_debug_info: Vec<VarDebugInfo<'tcx>>,
span: Span,
control_flow_destroyed: Vec<(Span, String)>,
generator_kind : Option<GeneratorKind>,
) -> Self {
// We need `arg_count` locals, and one for the return place.
assert!(
@ -187,6 +192,7 @@ impl<'tcx> Body<'tcx> {
yield_ty: None,
generator_drop: None,
generator_layout: None,
generator_kind,
local_decls,
user_type_annotations,
arg_count,
@ -2975,7 +2981,8 @@ impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> {
index: index.fold_with(folder),
},
Panic { .. } | Overflow(_) | OverflowNeg | DivisionByZero | RemainderByZero |
GeneratorResumedAfterReturn | GeneratorResumedAfterPanic =>
GeneratorResumedAfterReturn | GeneratorResumedAfterPanic |
AsyncResumedAfterReturn | AsyncResumedAfterPanic =>
msg.clone(),
};
Assert { cond: cond.fold_with(folder), expected, msg, target, cleanup }
@ -3021,7 +3028,8 @@ impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> {
len.visit_with(visitor) || index.visit_with(visitor),
Panic { .. } | Overflow(_) | OverflowNeg |
DivisionByZero | RemainderByZero |
GeneratorResumedAfterReturn | GeneratorResumedAfterPanic =>
GeneratorResumedAfterReturn | GeneratorResumedAfterPanic |
AsyncResumedAfterReturn | AsyncResumedAfterPanic =>
false
}
} else {

3
src/librustc/mir/visit.rs
View file

@ -517,7 +517,8 @@ macro_rules! make_mir_visitor {
self.visit_operand(index, location);
}
Panic { .. } | Overflow(_) | OverflowNeg | DivisionByZero | RemainderByZero |
GeneratorResumedAfterReturn | GeneratorResumedAfterPanic => {
GeneratorResumedAfterReturn | GeneratorResumedAfterPanic |
AsyncResumedAfterReturn | AsyncResumedAfterPanic => {
// Nothing to visit
}
}

15
src/librustc_mir/build/mod.rs
View file

@ -5,7 +5,7 @@ use crate::hair::{LintLevel, BindingMode, PatKind};
use crate::transform::MirSource;
use crate::util as mir_util;
use rustc::hir;
use rustc::hir::Node;
use rustc::hir::{Node, GeneratorKind};
use rustc::hir::def_id::DefId;
use rustc::middle::lang_items;
use rustc::middle::region;
@ -279,7 +279,7 @@ struct Builder<'a, 'tcx> {
fn_span: Span,
arg_count: usize,
is_generator: bool,
generator_kind: Option<GeneratorKind>,
/// The current set of scopes, updated as we traverse;
/// see the `scope` module for more details.
@ -570,7 +570,7 @@ where
safety,
return_ty,
return_ty_span,
body.generator_kind.is_some());
body.generator_kind);
let call_site_scope = region::Scope {
id: body.value.hir_id.local_id,
@ -647,7 +647,7 @@ fn construct_const<'a, 'tcx>(
Safety::Safe,
const_ty,
const_ty_span,
false,
None,
);
let mut block = START_BLOCK;
@ -678,7 +678,7 @@ fn construct_error<'a, 'tcx>(
let owner_id = hir.tcx().hir().body_owner(body_id);
let span = hir.tcx().hir().span(owner_id);
let ty = hir.tcx().types.err;
let mut builder = Builder::new(hir, span, 0, Safety::Safe, ty, span, false);
let mut builder = Builder::new(hir, span, 0, Safety::Safe, ty, span, None);
let source_info = builder.source_info(span);
builder.cfg.terminate(START_BLOCK, source_info, TerminatorKind::Unreachable);
builder.finish()
@ -691,7 +691,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
safety: Safety,
return_ty: Ty<'tcx>,
return_span: Span,
is_generator: bool)
generator_kind: Option<GeneratorKind>)
-> Builder<'a, 'tcx> {
let lint_level = LintLevel::Explicit(hir.root_lint_level);
let mut builder = Builder {
@ -699,7 +699,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
cfg: CFG { basic_blocks: IndexVec::new() },
fn_span: span,
arg_count,
is_generator,
generator_kind,
scopes: Default::default(),
block_context: BlockContext::new(),
source_scopes: IndexVec::new(),
@ -748,6 +748,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
self.var_debug_info,
self.fn_span,
self.hir.control_flow_destroyed(),
self.generator_kind
)
}

40
src/librustc_mir/build/scope.rs
View file

@ -91,6 +91,7 @@ use syntax_pos::{DUMMY_SP, Span};
use rustc_data_structures::fx::FxHashMap;
use std::collections::hash_map::Entry;
use std::mem;
use rustc::hir::GeneratorKind;
#[derive(Debug)]
struct Scope {
@ -219,7 +220,12 @@ impl Scope {
/// `storage_only` controls whether to invalidate only drop paths that run `StorageDead`.
/// `this_scope_only` controls whether to invalidate only drop paths that refer to the current
/// top-of-scope (as opposed to dependent scopes).
fn invalidate_cache(&mut self, storage_only: bool, is_generator: bool, this_scope_only: bool) {
fn invalidate_cache(
&mut self,
storage_only: bool,
generator_kind: Option<GeneratorKind>,
this_scope_only: bool
) {
// FIXME: maybe do shared caching of `cached_exits` etc. to handle functions
// with lots of `try!`?
@ -229,7 +235,7 @@ impl Scope {
// the current generator drop and unwind refer to top-of-scope
self.cached_generator_drop = None;
let ignore_unwinds = storage_only && !is_generator;
let ignore_unwinds = storage_only && generator_kind.is_none();
if !ignore_unwinds {
self.cached_unwind.invalidate();
}
@ -481,7 +487,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
unpack!(block = build_scope_drops(
&mut self.cfg,
self.is_generator,
self.generator_kind,
&scope,
block,
unwind_to,
@ -574,7 +580,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
unpack!(block = build_scope_drops(
&mut self.cfg,
self.is_generator,
self.generator_kind,
scope,
block,
unwind_to,
@ -625,7 +631,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
unpack!(block = build_scope_drops(
&mut self.cfg,
self.is_generator,
self.generator_kind,
scope,
block,
unwind_to,
@ -809,7 +815,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
// invalidating caches of each scope visited. This way bare minimum of the
// caches gets invalidated. i.e., if a new drop is added into the middle scope, the
// cache of outer scope stays intact.
scope.invalidate_cache(!needs_drop, self.is_generator, this_scope);
scope.invalidate_cache(!needs_drop, self.generator_kind, this_scope);
if this_scope {
let region_scope_span = region_scope.span(self.hir.tcx(),
&self.hir.region_scope_tree);
@ -958,7 +964,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
}
}
top_scope.invalidate_cache(true, self.is_generator, true);
top_scope.invalidate_cache(true, self.generator_kind, true);
} else {
bug!("Expected as_local_operand to produce a temporary");
}
@ -1016,7 +1022,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
for scope in self.scopes.top_scopes(first_uncached) {
target = build_diverge_scope(&mut self.cfg, scope.region_scope_span,
scope, target, generator_drop, self.is_generator);
scope, target, generator_drop, self.generator_kind);
}
target
@ -1079,14 +1085,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
assert_eq!(top_scope.region_scope, region_scope);
top_scope.drops.clear();
top_scope.invalidate_cache(false, self.is_generator, true);
top_scope.invalidate_cache(false, self.generator_kind, true);
}
}
/// Builds drops for pop_scope and exit_scope.
fn build_scope_drops<'tcx>(
cfg: &mut CFG<'tcx>,
is_generator: bool,
generator_kind: Option<GeneratorKind>,
scope: &Scope,
mut block: BasicBlock,
last_unwind_to: BasicBlock,
@ -1130,7 +1136,7 @@ fn build_scope_drops<'tcx>(
continue;
}
let unwind_to = get_unwind_to(scope, is_generator, drop_idx, generator_drop)
let unwind_to = get_unwind_to(scope, generator_kind, drop_idx, generator_drop)
.unwrap_or(last_unwind_to);
let next = cfg.start_new_block();
@ -1156,19 +1162,19 @@ fn build_scope_drops<'tcx>(
fn get_unwind_to(
scope: &Scope,
is_generator: bool,
generator_kind: Option<GeneratorKind>,
unwind_from: usize,
generator_drop: bool,
) -> Option<BasicBlock> {
for drop_idx in (0..unwind_from).rev() {
let drop_data = &scope.drops[drop_idx];
match (is_generator, &drop_data.kind) {
(true, DropKind::Storage) => {
match (generator_kind, &drop_data.kind) {
(Some(_), DropKind::Storage) => {
return Some(drop_data.cached_block.get(generator_drop).unwrap_or_else(|| {
span_bug!(drop_data.span, "cached block not present for {:?}", drop_data)
}));
}
(false, DropKind::Value) => {
(None, DropKind::Value) => {
return Some(drop_data.cached_block.get(generator_drop).unwrap_or_else(|| {
span_bug!(drop_data.span, "cached block not present for {:?}", drop_data)
}));
@ -1184,7 +1190,7 @@ fn build_diverge_scope<'tcx>(cfg: &mut CFG<'tcx>,
scope: &mut Scope,
mut target: BasicBlock,
generator_drop: bool,
is_generator: bool)
generator_kind: Option<GeneratorKind>)
-> BasicBlock
{
// Build up the drops in **reverse** order. The end result will
@ -1224,7 +1230,7 @@ fn build_diverge_scope<'tcx>(cfg: &mut CFG<'tcx>,
// match the behavior of clang, but on inspection eddyb says
// this is not what clang does.
match drop_data.kind {
DropKind::Storage if is_generator => {
DropKind::Storage if generator_kind.is_some() => {
storage_deads.push(Statement {
source_info: source_info(drop_data.span),
kind: StatementKind::StorageDead(drop_data.local)

2
src/librustc_mir/interpret/terminator.rs
View file

@ -144,6 +144,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
RemainderByZero => err_panic!(RemainderByZero),
GeneratorResumedAfterReturn => err_panic!(GeneratorResumedAfterReturn),
GeneratorResumedAfterPanic => err_panic!(GeneratorResumedAfterPanic),
AsyncResumedAfterReturn => err_panic!(AsyncResumedAfterReturn),
AsyncResumedAfterPanic => err_panic!(AsyncResumedAfterPanic),
Panic { .. } => bug!("`Panic` variant cannot occur in MIR"),
}
.into());

4
src/librustc_mir/shim.rs
View file

@ -208,6 +208,7 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
vec![],
span,
vec![],
None,
);
if let Some(..) = ty {
@ -374,6 +375,7 @@ impl CloneShimBuilder<'tcx> {
vec![],
self.span,
vec![],
None,
)
}
@ -834,6 +836,7 @@ fn build_call_shim<'tcx>(
vec![],
span,
vec![],
None,
);
if let Abi::RustCall = sig.abi {
body.spread_arg = Some(Local::new(sig.inputs().len()));
@ -920,6 +923,7 @@ pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> &Body<'_> {
vec![],
span,
vec![],
None,
);
crate::util::dump_mir(

1
src/librustc_mir/transform/const_prop.rs
View file

@ -91,6 +91,7 @@ impl<'tcx> MirPass<'tcx> for ConstProp {
Default::default(),
tcx.def_span(source.def_id()),
Default::default(),
body.generator_kind,
);
// FIXME(oli-obk, eddyb) Optimize locals (or even local paths) to hold

23
src/librustc_mir/transform/generator.rs
View file

@ -50,7 +50,7 @@
//! Otherwise it drops all the values in scope at the last suspension point.
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::hir::{def_id::DefId, GeneratorKind};
use rustc::mir::*;
use rustc::mir::visit::{PlaceContext, Visitor, MutVisitor};
use rustc::ty::{self, TyCtxt, AdtDef, Ty};
@ -1058,14 +1058,27 @@ fn create_generator_resume_function<'tcx>(
use rustc::mir::interpret::PanicInfo::{
GeneratorResumedAfterPanic,
GeneratorResumedAfterReturn,
AsyncResumedAfterReturn,
AsyncResumedAfterPanic,
};
// Jump to the entry point on the unresumed
cases.insert(0, (UNRESUMED, BasicBlock::new(0)));
// Panic when resumed on the returned state
cases.insert(1, (RETURNED, insert_panic_block(tcx, body, GeneratorResumedAfterReturn)));
// Panic when resumed on the poisoned state
cases.insert(2, (POISONED, insert_panic_block(tcx, body, GeneratorResumedAfterPanic)));
// Panic when resumed on the returned or poisoned state
match body.generator_kind {
Some(GeneratorKind::Async(_)) => {
cases.insert(1, (RETURNED, insert_panic_block(tcx, body, AsyncResumedAfterReturn)));
cases.insert(2, (POISONED, insert_panic_block(tcx, body, AsyncResumedAfterPanic)));
},
Some(GeneratorKind::Gen) => {
cases.insert(1, (RETURNED, insert_panic_block(tcx, body, GeneratorResumedAfterReturn)));
cases.insert(2, (POISONED, insert_panic_block(tcx, body, GeneratorResumedAfterPanic)));
},
None => {
// N/A because we would never create a resume function if there was no generator_kind
}
};
insert_switch(body, cases, &transform, TerminatorKind::Unreachable);

1
src/librustc_mir/transform/promote_consts.rs
View file

@ -1104,6 +1104,7 @@ pub fn promote_candidates<'tcx>(
vec![],
body.span,
vec![],
body.generator_kind,
),
tcx,
source: body,

44
src/test/ui/issues/issue-65419/issue-65419-async-fn-resume-after-completion.rs Normal file
View file

@ -0,0 +1,44 @@
// issue 65419 - Attempting to run an async fn after completion mentions generators when it should
// be talking about `async fn`s instead.
// run-fail
// error-pattern: thread 'main' panicked at '`async fn` resumed after completion'
// compile-flags: --edition 2018
#![feature(generators, generator_trait)]
async fn foo() {
}
fn main() {
let mut future = Box::pin(foo());
executor::block_on(future.as_mut());
executor::block_on(future.as_mut());
}
mod executor {
use core::{
future::Future,
pin::Pin,
task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
};
pub fn block_on<F: Future>(mut future: F) -> F::Output {
let mut future = unsafe { Pin::new_unchecked(&mut future) };
static VTABLE: RawWakerVTable = RawWakerVTable::new(
|_| unimplemented!("clone"),
|_| unimplemented!("wake"),
|_| unimplemented!("wake_by_ref"),
|_| (),
);
let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
let mut context = Context::from_waker(&waker);
loop {
if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
break val;
}
}
}
}

50
src/test/ui/issues/issue-65419/issue-65419-async-fn-resume-after-panic.rs Normal file
View file

@ -0,0 +1,50 @@
// issue 65419 - Attempting to run an async fn after completion mentions generators when it should
// be talking about `async fn`s instead. Should also test what happens when it panics.
// run-fail
// error-pattern: thread 'main' panicked at '`async fn` resumed after panic'
// compile-flags: --edition 2018
#![feature(generators, generator_trait)]
use std::panic;
async fn foo() {
panic!();
}
fn main() {
let mut future = Box::pin(foo());
panic::catch_unwind(panic::AssertUnwindSafe(|| {
executor::block_on(future.as_mut());
}));
executor::block_on(future.as_mut());
}
mod executor {
use core::{
future::Future,
pin::Pin,
task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
};
pub fn block_on<F: Future>(mut future: F) -> F::Output {
let mut future = unsafe { Pin::new_unchecked(&mut future) };
static VTABLE: RawWakerVTable = RawWakerVTable::new(
|_| unimplemented!("clone"),
|_| unimplemented!("wake"),
|_| unimplemented!("wake_by_ref"),
|_| (),
);
let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
let mut context = Context::from_waker(&waker);
loop {
if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
break val;
}
}
}
}

22
src/test/ui/issues/issue-65419/issue-65419-generator-resume-after-completion.rs Normal file
View file

@ -0,0 +1,22 @@
// issue 65419 - Attempting to run an `async fn` after completion mentions generators when it should
// be talking about `async fn`s instead. Regression test added to make sure generators still
// panic when resumed after completion.
// run-fail
// error-pattern:generator resumed after completion
#![feature(generators, generator_trait)]
use std::{
ops::Generator,
pin::Pin,
};
fn main() {
let mut g = || {
yield;
};
Pin::new(&mut g).resume(); // Yields once.
Pin::new(&mut g).resume(); // Completes here.
Pin::new(&mut g).resume(); // Panics here.
}