diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 35dad578e0e..efe899a78fd 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -61,6 +61,13 @@ use syntax::visit; use syntax; use syntax_ext; +pub struct Resolutions { + pub def_map: RefCell, + pub freevars: FreevarMap, + pub trait_map: TraitMap, + pub maybe_unused_trait_imports: NodeSet, +} + pub fn compile_input(sess: &Session, cstore: &CStore, cfg: ast::CrateConfig, @@ -147,23 +154,25 @@ pub fn compile_input(sess: &Session, "early lint checks", || lint::check_ast_crate(sess, &expanded_crate)); - let resolve::CrateMap { - def_map, - freevars, - maybe_unused_trait_imports, - export_map, - trait_map, - glob_map, - } = time(sess.time_passes(), "name resolution", || { - resolve::resolve_crate(sess, &expanded_crate, &defs.borrow(), control.make_glob_map) - }); + let (analysis, resolutions) = { + resolve::with_resolver(sess, &defs.borrow(), control.make_glob_map, |mut resolver| { + time(sess.time_passes(), "name resolution", || { + resolve::resolve_crate(&mut resolver, &expanded_crate); + }); - let analysis = ty::CrateAnalysis { - export_map: export_map, - access_levels: AccessLevels::default(), - reachable: NodeSet(), - name: &id, - glob_map: glob_map, + (ty::CrateAnalysis { + export_map: resolver.export_map, + access_levels: AccessLevels::default(), + reachable: NodeSet(), + name: &id, + glob_map: if resolver.make_glob_map { Some(resolver.glob_map) } else { None }, + }, Resolutions { + def_map: RefCell::new(resolver.def_map), + freevars: resolver.freevars, + trait_map: resolver.trait_map, + maybe_unused_trait_imports: resolver.maybe_unused_trait_imports, + }) + }) }; // Lower ast -> hir. @@ -218,13 +227,10 @@ pub fn compile_input(sess: &Session, phase_3_run_analysis_passes(sess, hir_map, + analysis, + resolutions, &arenas, &id, - analysis, - def_map, - freevars, - trait_map, - maybe_unused_trait_imports, |tcx, mir_map, analysis, result| { { // Eventually, we will want to track plugins. @@ -785,13 +791,10 @@ pub fn assign_node_ids(sess: &Session, krate: ast::Crate) -> ast::Crate { /// structures carrying the results of the analysis. pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, hir_map: hir_map::Map<'tcx>, + mut analysis: ty::CrateAnalysis, + resolutions: Resolutions, arenas: &'tcx ty::CtxtArenas<'tcx>, name: &str, - mut analysis: ty::CrateAnalysis, - def_map: RefCell, - freevars: FreevarMap, - trait_map: TraitMap, - maybe_unused_trait_imports: NodeSet, f: F) -> Result where F: FnOnce(&TyCtxt<'tcx>, Option>, ty::CrateAnalysis, CompileResult) -> R @@ -820,7 +823,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, "lifetime resolution", || middle::resolve_lifetime::krate(sess, &hir_map, - &def_map.borrow()))?; + &resolutions.def_map.borrow()))?; time(time_passes, "looking for entry point", @@ -840,17 +843,18 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, time(time_passes, "static item recursion checking", - || static_recursion::check_crate(sess, &def_map.borrow(), &hir_map))?; + || static_recursion::check_crate(sess, &resolutions.def_map.borrow(), &hir_map))?; let index = stability::Index::new(&hir_map); + let trait_map = resolutions.trait_map; TyCtxt::create_and_enter(sess, arenas, - def_map, + resolutions.def_map, named_region_map, hir_map, - freevars, - maybe_unused_trait_imports, + resolutions.freevars, + resolutions.maybe_unused_trait_imports, region_map, lang_items, index, diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index f90f8481a25..2ed35cdd0ad 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -995,11 +995,11 @@ pub struct Resolver<'a> { // The idents for the primitive types. primitive_type_table: PrimitiveTypeTable, - def_map: DefMap, - freevars: FreevarMap, + pub def_map: DefMap, + pub freevars: FreevarMap, freevars_seen: NodeMap>, - export_map: ExportMap, - trait_map: TraitMap, + pub export_map: ExportMap, + pub trait_map: TraitMap, // A map from nodes to modules, both normal (`mod`) modules and anonymous modules. // Anonymous modules are pseudo-modules that are implicitly created around items @@ -1022,14 +1022,14 @@ pub struct Resolver<'a> { // so as to avoid printing duplicate errors emit_errors: bool, - make_glob_map: bool, + pub make_glob_map: bool, // Maps imports to the names of items actually imported (this actually maps // all imports, but only glob imports are actually interesting). - glob_map: GlobMap, + pub glob_map: GlobMap, used_imports: HashSet<(NodeId, Namespace)>, used_crates: HashSet, - maybe_unused_trait_imports: NodeSet, + pub maybe_unused_trait_imports: NodeSet, privacy_errors: Vec>, @@ -3563,15 +3563,6 @@ fn err_path_resolution() -> PathResolution { } -pub struct CrateMap { - pub def_map: RefCell, - pub freevars: FreevarMap, - pub maybe_unused_trait_imports: NodeSet, - pub export_map: ExportMap, - pub trait_map: TraitMap, - pub glob_map: Option, -} - #[derive(PartialEq,Copy, Clone)] pub enum MakeGlobMap { Yes, @@ -3579,11 +3570,7 @@ pub enum MakeGlobMap { } /// Entry point to crate resolution. -pub fn resolve_crate<'a>(session: &'a Session, - krate: &'a Crate, - definitions: &'a Definitions, - make_glob_map: MakeGlobMap) - -> CrateMap { +pub fn resolve_crate<'a, 'b>(resolver: &'b mut Resolver<'a>, krate: &'b Crate) { // Currently, we ignore the name resolution data structures for // the purposes of dependency tracking. Instead we will run name // resolution and include its output in the hash of each item, @@ -3592,42 +3579,23 @@ pub fn resolve_crate<'a>(session: &'a Session, // resolution on those contents. Hopefully we'll push this back at // some point. - let arenas = Resolver::arenas(); - let mut resolver = create_resolver(session, definitions, krate, make_glob_map, &arenas); - + resolver.build_reduced_graph(krate); + resolve_imports::resolve_imports(resolver); resolver.resolve_crate(krate); - check_unused::check_crate(&mut resolver, krate); + check_unused::check_crate(resolver, krate); resolver.report_privacy_errors(); - - CrateMap { - def_map: RefCell::new(resolver.def_map), - freevars: resolver.freevars, - maybe_unused_trait_imports: resolver.maybe_unused_trait_imports, - export_map: resolver.export_map, - trait_map: resolver.trait_map, - glob_map: if resolver.make_glob_map { - Some(resolver.glob_map) - } else { - None - }, - } } -/// Builds a name resolution walker. -fn create_resolver<'a>(session: &'a Session, - definitions: &'a Definitions, - krate: &'a Crate, - make_glob_map: MakeGlobMap, - arenas: &'a ResolverArenas<'a>) - -> Resolver<'a> { - let mut resolver = Resolver::new(session, definitions, make_glob_map, arenas); - - resolver.build_reduced_graph(krate); - - resolve_imports::resolve_imports(&mut resolver); - - resolver +pub fn with_resolver<'a, T, F>(session: &'a Session, + definitions: &'a Definitions, + make_glob_map: MakeGlobMap, + f: F) -> T + where F: for<'b> FnOnce(Resolver<'b>) -> T, +{ + let arenas = Resolver::arenas(); + let resolver = Resolver::new(session, definitions, make_glob_map, &arenas); + f(resolver) } __build_diagnostic_array! { librustc_resolve, DIAGNOSTICS }