use hir;
+pub struct AllArenas<'tcx> {
+ pub global: GlobalArenas<'tcx>,
+ pub interner: DroplessArena,
+}
+
+impl<'tcx> AllArenas<'tcx> {
+ pub fn new() -> Self {
+ AllArenas {
+ global: GlobalArenas::new(),
+ interner: DroplessArena::new(),
+ }
+ }
+}
+
/// Internal storage
pub struct GlobalArenas<'tcx> {
// internings
cstore: &'tcx CrateStore,
local_providers: ty::maps::Providers<'tcx>,
extern_providers: ty::maps::Providers<'tcx>,
- arenas: &'tcx GlobalArenas<'tcx>,
- arena: &'tcx DroplessArena,
+ arenas: &'tcx AllArenas<'tcx>,
resolutions: ty::Resolutions,
hir: hir_map::Map<'tcx>,
on_disk_query_result_cache: maps::OnDiskCache<'tcx>,
where F: for<'b> FnOnce(TyCtxt<'b, 'tcx, 'tcx>) -> R
{
let data_layout = TargetDataLayout::parse(s);
- let interners = CtxtInterners::new(arena);
+ let interners = CtxtInterners::new(&arenas.interner);
let common_types = CommonTypes::new(&interners);
let dep_graph = hir.dep_graph.clone();
let max_cnum = cstore.crates_untracked().iter().map(|c| c.as_usize()).max().unwrap_or(0);
tls::enter_global(GlobalCtxt {
sess: s,
cstore,
- global_arenas: arenas,
+ global_arenas: &arenas.global,
global_interners: interners,
dep_graph: dep_graph.clone(),
on_disk_query_result_cache,
pub use self::binding::BindingMode;
pub use self::binding::BindingMode::*;
-pub use self::context::{TyCtxt, GlobalArenas, tls, keep_local};
+pub use self::context::{TyCtxt, GlobalArenas, AllArenas, tls, keep_local};
pub use self::context::{Lift, TypeckTables};
pub use self::instance::{Instance, InstanceDef};
use rustc::middle::{self, stability, reachable, resolve_lifetime};
use rustc::middle::cstore::CrateStore;
use rustc::middle::privacy::AccessLevels;
-use rustc::ty::{self, TyCtxt, Resolutions, GlobalArenas};
+use rustc::ty::{self, TyCtxt, Resolutions, AllArenas};
use rustc::traits;
use rustc::util::common::{ErrorReported, time};
use rustc_allocator as allocator;
use syntax_pos::FileName;
use syntax;
use syntax_ext;
-use arena::DroplessArena;
use derive_registrar;
use pretty::ReplaceBodyWithLoop;
return Ok(())
}
- let arena = DroplessArena::new();
- let arenas = GlobalArenas::new();
+ let arenas = AllArenas::new();
// Construct the HIR map
let hir_map = time(sess.time_passes(),
sess,
outdir,
output,
- &arena,
&arenas,
&cstore,
&hir_map,
hir_map,
analysis,
resolutions,
- &arena,
&arenas,
&crate_name,
&outputs,
pub output_filenames: Option<&'a OutputFilenames>,
pub out_dir: Option<&'a Path>,
pub out_file: Option<&'a Path>,
- pub arena: Option<&'tcx DroplessArena>,
- pub arenas: Option<&'tcx GlobalArenas<'tcx>>,
+ pub arenas: Option<&'tcx AllArenas<'tcx>>,
pub expanded_crate: Option<&'a ast::Crate>,
pub hir_crate: Option<&'a hir::Crate>,
pub hir_map: Option<&'a hir_map::Map<'tcx>>,
session,
out_dir: out_dir.as_ref().map(|s| &**s),
out_file: None,
- arena: None,
arenas: None,
krate: None,
registry: None,
session: &'tcx Session,
out_dir: &'a Option<PathBuf>,
out_file: &'a Option<PathBuf>,
- arena: &'tcx DroplessArena,
- arenas: &'tcx GlobalArenas<'tcx>,
+ arenas: &'tcx AllArenas<'tcx>,
cstore: &'tcx CStore,
hir_map: &'a hir_map::Map<'tcx>,
analysis: &'a ty::CrateAnalysis,
-> Self {
CompileState {
crate_name: Some(crate_name),
- arena: Some(arena),
arenas: Some(arenas),
cstore: Some(cstore),
hir_map: Some(hir_map),
hir_map: hir_map::Map<'tcx>,
mut analysis: ty::CrateAnalysis,
resolutions: Resolutions,
- arena: &'tcx DroplessArena,
- arenas: &'tcx GlobalArenas<'tcx>,
+ arenas: &'tcx AllArenas<'tcx>,
name: &str,
output_filenames: &OutputFilenames,
f: F)
local_providers,
extern_providers,
arenas,
- arena,
resolutions,
hir_map,
query_result_on_disk_cache,
&state.expanded_crate.take().unwrap(),
state.crate_name.unwrap(),
ppm,
- state.arena.unwrap(),
state.arenas.unwrap(),
state.output_filenames.unwrap(),
opt_uii.clone(),
use {abort_on_err, driver};
-use rustc::ty::{self, TyCtxt, GlobalArenas, Resolutions};
+use rustc::ty::{self, TyCtxt, Resolutions, AllArenas};
use rustc::cfg;
use rustc::cfg::graphviz::LabelledCFG;
use rustc::middle::cstore::CrateStore;
use rustc::hir;
use rustc::hir::print as pprust_hir;
-use arena::DroplessArena;
-
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum PpSourceMode {
PpmNormal,
hir_map: &hir_map::Map<'tcx>,
analysis: &ty::CrateAnalysis,
resolutions: &Resolutions,
- arena: &'tcx DroplessArena,
- arenas: &'tcx GlobalArenas<'tcx>,
+ arenas: &'tcx AllArenas<'tcx>,
output_filenames: &OutputFilenames,
id: &str,
f: F)
hir_map.clone(),
analysis.clone(),
resolutions.clone(),
- arena,
arenas,
id,
output_filenames,
krate: &ast::Crate,
crate_name: &str,
ppm: PpMode,
- arena: &'tcx DroplessArena,
- arenas: &'tcx GlobalArenas<'tcx>,
+ arenas: &'tcx AllArenas<'tcx>,
output_filenames: &OutputFilenames,
opt_uii: Option<UserIdentifiedItem>,
ofile: Option<&Path>) {
analysis,
resolutions,
crate_name,
- arena,
arenas,
output_filenames,
ppm,
hir_map,
analysis,
resolutions,
- arena,
arenas,
output_filenames,
crate_name,
hir_map,
analysis,
resolutions,
- arena,
arenas,
output_filenames,
crate_name,
hir_map,
analysis,
resolutions,
- arena,
arenas,
output_filenames,
crate_name,
hir_map,
analysis,
resolutions,
- arena,
arenas,
output_filenames,
crate_name,
analysis: &ty::CrateAnalysis,
resolutions: &Resolutions,
crate_name: &str,
- arena: &'tcx DroplessArena,
- arenas: &'tcx GlobalArenas<'tcx>,
+ arenas: &'tcx AllArenas<'tcx>,
output_filenames: &OutputFilenames,
ppm: PpMode,
uii: Option<UserIdentifiedItem>,
hir_map.clone(),
analysis.clone(),
resolutions.clone(),
- arena,
arenas,
crate_name,
output_filenames,
use syntax::feature_gate::UnstableFeatures;
use syntax::symbol::Symbol;
use syntax_pos::DUMMY_SP;
-use arena::DroplessArena;
use rustc::hir;
.expect("phase 2 aborted")
};
- let arena = DroplessArena::new();
- let arenas = ty::GlobalArenas::new();
+ let arenas = ty::AllArenas::new();
let hir_map = hir_map::map_crate(&sess, &*cstore, &mut hir_forest, &defs);
// run just enough stuff to build a tcx:
ty::maps::Providers::default(),
ty::maps::Providers::default(),
&arenas,
- &arena,
resolutions,
hir_map,
OnDiskCache::new_empty(sess.codemap()),
use rustc::hir::def_id::DefId;
use rustc::hir::def::Def;
use rustc::middle::privacy::AccessLevels;
-use rustc::ty::{self, TyCtxt, GlobalArenas};
+use rustc::ty::{self, TyCtxt, AllArenas};
use rustc::hir::map as hir_map;
use rustc::lint;
use rustc::util::nodemap::FxHashMap;
use clean;
use clean::Clean;
use html::render::RenderInfo;
-use arena::DroplessArena;
pub use rustc::session::config::Input;
pub use rustc::session::search_paths::SearchPaths;
abort_on_err(result, &sess)
};
- let arena = DroplessArena::new();
- let arenas = GlobalArenas::new();
+ let arenas = AllArenas::new();
let hir_map = hir_map::map_crate(&sess, &*cstore, &mut hir_forest, &defs);
let output_filenames = driver::build_output_filenames(&input,
&None,
hir_map,
analysis,
resolutions,
- &arena,
&arenas,
&name,
&output_filenames,