From a353490e6f7916bf4022b79870aed5395ba9b77d Mon Sep 17 00:00:00 2001 From: Jeffrey Seyfried Date: Tue, 12 Jan 2016 04:55:21 +0000 Subject: [PATCH] resolve: Remove record_exports, fixes #4953 --- src/librustc_privacy/lib.rs | 8 +- src/librustc_resolve/lib.rs | 4 - src/librustc_resolve/record_exports.rs | 154 ------------------------ src/librustc_resolve/resolve_imports.rs | 17 +++ 4 files changed, 22 insertions(+), 161 deletions(-) delete mode 100644 src/librustc_resolve/record_exports.rs diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 955e68be0b006..eb0315acf67f5 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -329,9 +329,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // This code is here instead of in visit_item so that the // crate module gets processed as well. if self.prev_level.is_some() { - for export in self.export_map.get(&id).expect("module isn't found in export map") { - if let Some(node_id) = self.tcx.map.as_local_node_id(export.def_id) { - self.update(node_id, Some(AccessLevel::Exported)); + if let Some(exports) = self.export_map.get(&id) { + for export in exports { + if let Some(node_id) = self.tcx.map.as_local_node_id(export.def_id) { + self.update(node_id, Some(AccessLevel::Exported)); + } } } } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 9857e83bd621a..8464d3ef29870 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -101,7 +101,6 @@ use resolve_imports::Shadowable; pub mod diagnostics; mod check_unused; -mod record_exports; mod build_reduced_graph; mod resolve_imports; @@ -4014,9 +4013,6 @@ pub fn create_resolver<'a, 'tcx>(session: &'a Session, resolve_imports::resolve_imports(&mut resolver); session.abort_if_errors(); - record_exports::record(&mut resolver); - session.abort_if_errors(); - resolver } diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs deleted file mode 100644 index 13f4348f79522..0000000000000 --- a/src/librustc_resolve/record_exports.rs +++ /dev/null @@ -1,154 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - - -// Export recording -// -// This pass simply determines what all "export" keywords refer to and -// writes the results into the export map. -// -// FIXME #4953 This pass will be removed once exports change to per-item. -// Then this operation can simply be performed as part of item (or import) -// processing. - -use {Module, NameBinding, Resolver}; -use Namespace::{TypeNS, ValueNS}; - -use build_reduced_graph; -use module_to_string; - -use rustc::middle::def::Export; -use syntax::ast; - -use std::ops::{Deref, DerefMut}; - -struct ExportRecorder<'a, 'b: 'a, 'tcx: 'b> { - resolver: &'a mut Resolver<'b, 'tcx>, -} - -// Deref and DerefMut impls allow treating ExportRecorder as Resolver. -impl<'a, 'b, 'tcx:'b> Deref for ExportRecorder<'a, 'b, 'tcx> { - type Target = Resolver<'b, 'tcx>; - - fn deref<'c>(&'c self) -> &'c Resolver<'b, 'tcx> { - &*self.resolver - } -} - -impl<'a, 'b, 'tcx:'b> DerefMut for ExportRecorder<'a, 'b, 'tcx> { - fn deref_mut<'c>(&'c mut self) -> &'c mut Resolver<'b, 'tcx> { - &mut *self.resolver - } -} - -impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { - fn record_exports_for_module_subtree(&mut self, module_: Module<'b>) { - // If this isn't a local krate, then bail out. We don't need to record - // exports for nonlocal crates. - - match module_.def_id() { - Some(def_id) if def_id.is_local() => { - // OK. Continue. - debug!("(recording exports for module subtree) recording exports for local \ - module `{}`", - module_to_string(module_)); - } - None => { - // Record exports for the root module. - debug!("(recording exports for module subtree) recording exports for root module \ - `{}`", - module_to_string(module_)); - } - Some(_) => { - // Bail out. - debug!("(recording exports for module subtree) not recording exports for `{}`", - module_to_string(module_)); - return; - } - } - - self.record_exports_for_module(module_); - build_reduced_graph::populate_module_if_necessary(self.resolver, &module_); - - for (_, child_name_bindings) in module_.children.borrow().iter() { - match child_name_bindings.type_ns.module() { - None => { - // Nothing to do. - } - Some(child_module) => { - self.record_exports_for_module_subtree(child_module); - } - } - } - - for (_, child_module) in module_.anonymous_children.borrow().iter() { - self.record_exports_for_module_subtree(child_module); - } - } - - fn record_exports_for_module(&mut self, module_: Module<'b>) { - let mut exports = Vec::new(); - - self.add_exports_for_module(&mut exports, module_); - match module_.def_id() { - Some(def_id) => { - let node_id = self.ast_map.as_local_node_id(def_id).unwrap(); - self.export_map.insert(node_id, exports); - debug!("(computing exports) writing exports for {} (some)", node_id); - } - None => {} - } - } - - fn add_export_of_namebinding(&mut self, - exports: &mut Vec, - name: ast::Name, - namebinding: &NameBinding) { - match namebinding.def() { - Some(d) => { - debug!("(computing exports) YES: export '{}' => {:?}", - name, - d.def_id()); - exports.push(Export { - name: name, - def_id: d.def_id(), - }); - } - d_opt => { - debug!("(computing exports) NO: {:?}", d_opt); - } - } - } - - fn add_exports_for_module(&mut self, exports: &mut Vec, module_: Module<'b>) { - for (name, import_resolution) in module_.import_resolutions.borrow().iter() { - let xs = [TypeNS, ValueNS]; - for &ns in &xs { - if !import_resolution[ns].is_public { - continue; - } - - match import_resolution[ns].target { - Some(ref target) => { - debug!("(computing exports) maybe export '{}'", name); - self.add_export_of_namebinding(exports, *name, &target.binding) - } - _ => (), - } - } - } - } -} - -pub fn record(resolver: &mut Resolver) { - let mut recorder = ExportRecorder { resolver: resolver }; - let root_module = recorder.graph_root; - recorder.record_exports_for_module_subtree(root_module); -} diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 53d1b888d8e87..abaf45cb1704d 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -688,6 +688,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { id: directive.id, is_public: directive.is_public }; + + self.add_export(module_, target, &import_resolution[namespace]); *used_public = name_binding.is_public(); } UnboundResult => { @@ -827,6 +829,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { dest_import_resolution[ns] = ImportResolution { id: id, is_public: is_public, target: Some(target.clone()) }; + self.add_export(module_, *name, &dest_import_resolution[ns]); } _ => {} } @@ -919,6 +922,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { id: id, is_public: is_public }; + self.add_export(module_, name, &dest_import_resolution[namespace]); } } else { // FIXME #30159: This is required for backwards compatability. @@ -935,6 +939,19 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { name); } + fn add_export(&mut self, module: Module<'b>, name: Name, resolution: &ImportResolution<'b>) { + if !resolution.is_public { return } + let node_id = match module.def_id() { + Some(def_id) => self.resolver.ast_map.as_local_node_id(def_id).unwrap(), + None => return, + }; + let export = match resolution.target.as_ref().unwrap().binding.def() { + Some(def) => Export { name: name, def_id: def.def_id() }, + None => return, + }; + self.resolver.export_map.entry(node_id).or_insert(Vec::new()).push(export); + } + /// Checks that imported names and items don't have the same name. fn check_for_conflicting_import(&mut self, import_resolution: &ImportResolutionPerNamespace,