From: bjorn3 Date: Mon, 31 May 2021 13:20:50 +0000 (+0200) Subject: Inline the rest of box_region X-Git-Url: https://git.lizzy.rs/?a=commitdiff_plain;h=99e112d28288566d7b3305e78d010bffd2aec89d;p=rust.git Inline the rest of box_region --- diff --git a/compiler/rustc_data_structures/src/box_region.rs b/compiler/rustc_data_structures/src/box_region.rs deleted file mode 100644 index a1a757b7054..00000000000 --- a/compiler/rustc_data_structures/src/box_region.rs +++ /dev/null @@ -1,80 +0,0 @@ -//! This module provides a way to deal with self-referential data. -//! -//! The main idea is to allocate such data in a generator frame and then -//! give access to it by executing user-provided closures inside that generator. -//! The module provides a safe abstraction for the latter task. -//! -//! The interface consists of two exported macros meant to be used together: -//! * `declare_box_region_type` wraps a generator inside a struct with `access` -//! method which accepts closures. -//! * `box_region_allow_access` is a helper which should be called inside -//! a generator to actually execute those closures. - -use std::marker::PhantomData; -use std::ops::{Generator, GeneratorState}; -use std::pin::Pin; - -#[derive(Copy, Clone)] -pub struct AccessAction(*mut dyn FnMut()); - -impl AccessAction { - pub fn get(self) -> *mut dyn FnMut() { - self.0 - } -} - -#[derive(Copy, Clone)] -pub enum Action { - Initial, - Access(AccessAction), - Complete, -} - -pub struct PinnedGenerator { - generator: Pin, Return = R>>>, -} - -impl PinnedGenerator { - pub fn new, Return = R> + 'static>( - generator: T, - ) -> (I, Self) { - let mut result = PinnedGenerator { generator: Box::pin(generator) }; - - // Run it to the first yield to set it up - let init = match Pin::new(&mut result.generator).resume(Action::Initial) { - GeneratorState::Yielded(YieldType::Initial(y)) => y, - _ => panic!(), - }; - - (init, result) - } - - pub unsafe fn access(&mut self, closure: *mut dyn FnMut()) { - // Call the generator, which in turn will call the closure - if let GeneratorState::Complete(_) = - Pin::new(&mut self.generator).resume(Action::Access(AccessAction(closure))) - { - panic!() - } - } - - pub fn complete(&mut self) -> R { - // Tell the generator we want it to complete, consuming it and yielding a result - let result = Pin::new(&mut self.generator).resume(Action::Complete); - if let GeneratorState::Complete(r) = result { r } else { panic!() } - } -} - -#[derive(PartialEq)] -pub struct Marker(PhantomData); - -impl Marker { - pub unsafe fn new() -> Self { - Marker(PhantomData) - } -} - -pub enum YieldType { - Initial(I), - Accessor(Marker), -} diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs index a8b9f479f1e..d55e471810c 100644 --- a/compiler/rustc_data_structures/src/lib.rs +++ b/compiler/rustc_data_structures/src/lib.rs @@ -10,7 +10,6 @@ #![feature(array_windows)] #![feature(control_flow_enum)] #![feature(in_band_lifetimes)] -#![feature(generator_trait)] #![feature(min_specialization)] #![feature(auto_traits)] #![feature(nll)] @@ -63,7 +62,6 @@ macro_rules! unlikely { pub mod base_n; pub mod binary_search_util; -pub mod box_region; pub mod captures; pub mod flock; pub mod functor; diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs index 383917e41b5..a93079c85a8 100644 --- a/compiler/rustc_interface/src/passes.rs +++ b/compiler/rustc_interface/src/passes.rs @@ -47,7 +47,10 @@ use std::ffi::OsString; use std::io::{self, BufWriter, Write}; use std::lazy::SyncLazy; +use std::marker::PhantomData; +use std::ops::{Generator, GeneratorState}; use std::path::PathBuf; +use std::pin::Pin; use std::rc::Rc; use std::{env, fs, iter}; @@ -85,27 +88,85 @@ fn count_nodes(krate: &ast::Crate) -> usize { counter.count } +#[derive(Copy, Clone)] +pub struct AccessAction(*mut dyn FnMut()); + +impl AccessAction { + pub fn get(self) -> *mut dyn FnMut() { + self.0 + } +} + +#[derive(Copy, Clone)] +pub enum Action { + Initial, + Access(AccessAction), + Complete, +} + +pub struct PinnedGenerator { + generator: Pin, Return = R>>>, +} + +impl PinnedGenerator { + pub fn new, Return = R> + 'static>( + generator: T, + ) -> (I, Self) { + let mut result = PinnedGenerator { generator: Box::pin(generator) }; + + // Run it to the first yield to set it up + let init = match Pin::new(&mut result.generator).resume(Action::Initial) { + GeneratorState::Yielded(YieldType::Initial(y)) => y, + _ => panic!(), + }; + + (init, result) + } + + pub unsafe fn access(&mut self, closure: *mut dyn FnMut()) { + // Call the generator, which in turn will call the closure + if let GeneratorState::Complete(_) = + Pin::new(&mut self.generator).resume(Action::Access(AccessAction(closure))) + { + panic!() + } + } + + pub fn complete(&mut self) -> R { + // Tell the generator we want it to complete, consuming it and yielding a result + let result = Pin::new(&mut self.generator).resume(Action::Complete); + if let GeneratorState::Complete(r) = result { r } else { panic!() } + } +} + +#[derive(PartialEq)] +pub struct Marker(PhantomData); + +impl Marker { + pub unsafe fn new() -> Self { + Marker(PhantomData) + } +} + +pub enum YieldType { + Initial(I), + Accessor(Marker), +} + pub struct BoxedResolver( - rustc_data_structures::box_region::PinnedGenerator< - Result, - fn(&mut Resolver<'_>), - ResolverOutputs, - >, + PinnedGenerator, fn(&mut Resolver<'_>), ResolverOutputs>, ); impl BoxedResolver { fn new(generator: T) -> (Result, Self) where T: ::std::ops::Generator< - rustc_data_structures::box_region::Action, - Yield = rustc_data_structures::box_region::YieldType< - Result, - fn(&mut Resolver<'_>), - >, + Action, + Yield = YieldType, fn(&mut Resolver<'_>)>, Return = ResolverOutputs, > + 'static, { - let (initial, pinned) = rustc_data_structures::box_region::PinnedGenerator::new(generator); + let (initial, pinned) = PinnedGenerator::new(generator); (initial, BoxedResolver(pinned)) } @@ -135,9 +196,8 @@ pub fn complete(mut self) -> ResolverOutputs { fn initial_yield( value: Result, - ) -> rustc_data_structures::box_region::YieldType, fn(&mut Resolver<'_>)> - { - rustc_data_structures::box_region::YieldType::Initial(value) + ) -> YieldType, fn(&mut Resolver<'_>)> { + YieldType::Initial(value) } } @@ -186,20 +246,17 @@ pub fn configure_and_expand( loop { match action { - rustc_data_structures::box_region::Action::Access(accessor) => { + Action::Access(accessor) => { let accessor: &mut dyn FnMut(&mut Resolver<'_>) = unsafe { ::std::mem::transmute(accessor.get()) }; (*accessor)(&mut resolver); unsafe { - let marker = rustc_data_structures::box_region::Marker::< - fn(&mut Resolver<'_>), - >::new(); - action = - yield rustc_data_structures::box_region::YieldType::Accessor(marker); + let marker = Marker::)>::new(); + action = yield YieldType::Accessor(marker); }; } - rustc_data_structures::box_region::Action::Complete => break, - rustc_data_structures::box_region::Action::Initial => { + Action::Complete => break, + Action::Initial => { panic!("unexpected box_region action: Initial") } }