mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor away separate tracking of used_public and used_reexport.

Browse Source 
NameBinding now encodes these directly with binding.is_public() and (binding.is_public() && binding.is_import()) (respectively)
This commit is contained in:
Jeffrey Seyfried 2016-02-07 21:48:24 +00:00
parent 2e24c7410f
commit 4428b1cfdf
2 changed files with 37 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/librustc_resolve/lib.rs
View File

@ -1311,7 +1311,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
name);
return Indeterminate;
}
Success((binding, used_proxy)) => {
Success(binding) => {
// Check to see whether there are type bindings, and, if
// so, whether there is a module within.
if let Some(module_def) = binding.module() {
@ -1319,7 +1319,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// Keep track of the closest private module used
// when resolving this import chain.
if !used_proxy && !search_module.is_public {
if !binding.is_public() {
if let Some(did) = search_module.def_id() {
closest_private = LastMod(DependsOn(did));
}
@ -1410,7 +1410,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
debug!("(resolving module path for import) indeterminate; bailing");
return Indeterminate;
}
Success((binding, _)) => match binding.module() {
Success(binding) => match binding.module() {
Some(containing_module) => {
search_module = containing_module;
start_index = 1;
@ -1444,7 +1444,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
name: Name,
namespace: Namespace,
record_used: bool)
-> ResolveResult<(&'a NameBinding<'a>, bool)> {
-> ResolveResult<&'a NameBinding<'a>> {
debug!("(resolving item in lexical scope) resolving `{}` in namespace {:?} in `{}`",
name,
namespace,
@ -1466,10 +1466,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
debug!("(resolving item in lexical scope) indeterminate higher scope; bailing");
return Indeterminate;
}
Success((binding, used_reexport)) => {
Success(binding) => {
// We found the module.
debug!("(resolving item in lexical scope) found name in module, done");
return Success((binding, used_reexport));
return Success(binding);
}
}
@ -1565,16 +1565,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
/// Attempts to resolve the supplied name in the given module for the
/// given namespace. If successful, returns the binding corresponding to
/// the name.
///
/// The boolean returned on success is an indicator of whether this lookup
/// passed through a public re-export proxy.
fn resolve_name_in_module(&mut self,
module_: Module<'a>,
name: Name,
namespace: Namespace,
allow_private_imports: bool,
record_used: bool)
-> ResolveResult<(&'a NameBinding<'a>, bool)> {
-> ResolveResult<&'a NameBinding<'a>> {
debug!("(resolving name in module) resolving `{}` in `{}`",
name,
module_to_string(&*module_));
@ -1590,7 +1587,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
self.used_crates.insert(krate);
}
}
return Success((binding, false));
return Success(binding);
}
// Check the list of resolved imports.
@ -1605,7 +1602,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if record_used {
self.record_import_use(name, namespace, &import_resolution);
}
return Success((binding, true));
return Success(binding);
}
}
Some(..) | None => {} // Continue.
@ -2636,7 +2633,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
-> BareIdentifierPatternResolution {
let module = self.current_module;
match self.resolve_item_in_lexical_scope(module, name, ValueNS, true) {
Success((binding, _)) => {
Success(binding) => {
debug!("(resolve bare identifier pattern) succeeded in finding {} at {:?}",
name,
binding);
@ -2796,7 +2793,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let module = self.current_module;
let name = identifier.unhygienic_name;
match self.resolve_item_in_lexical_scope(module, name, namespace, record_used) {
Success((binding, _)) => binding.def().map(LocalDef::from_def),
Success(binding) => binding.def().map(LocalDef::from_def),
Failed(Some((span, msg))) => {
resolve_error(self, span, ResolutionError::FailedToResolve(&*msg));
None
@ -2934,7 +2931,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let name = segments.last().unwrap().identifier.name;
let result = self.resolve_name_in_module(containing_module, name, namespace, false, true);
let def = match result {
Success((binding, _)) => {
Success(binding) => {
let (def, lp) = binding.def_and_lp();
(def, last_private.or(lp))
}
@ -2990,7 +2987,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let name = segments.last().unwrap().identifier.name;
match self.resolve_name_in_module(containing_module, name, namespace, false, true) {
Success((binding, _)) => {
Success(binding) => {
let (def, lp) = binding.def_and_lp();
Some((def, last_private.or(lp)))
}
@ -3028,11 +3025,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
if let AnonymousModuleRibKind(module) = self.get_ribs(namespace)[i].kind {
if let Success((binding, _)) = self.resolve_name_in_module(module,
ident.unhygienic_name,
namespace,
true,
true) {
if let Success(binding) = self.resolve_name_in_module(module,
ident.unhygienic_name,
namespace,
true,
true) {
if let Some(def) = binding.def() {
return Some(LocalDef::from_def(def));
}

46
src/librustc_resolve/resolve_imports.rs
View File

@ -371,14 +371,13 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
}
/// Resolves the name in the namespace of the module because it is being imported by
/// importing_module. Returns the name bindings defining the name
/// and whether or not the name was imported.
/// importing_module. Returns the name bindings defining the name.
fn resolve_name_in_module(&mut self,
module: Module<'b>, // Module containing the name
name: Name,
ns: Namespace,
importing_module: Module<'b>) // Module importing the name
-> (ResolveResult<&'b NameBinding<'b>>, bool) {
-> ResolveResult<&'b NameBinding<'b>> {
build_reduced_graph::populate_module_if_necessary(self.resolver, module);
if let Some(name_binding) = module.get_child(name, ns) {
if name_binding.is_extern_crate() {
@ -387,32 +386,32 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
self.resolver.used_crates.insert(krate);
}
}
return (Success(name_binding), false)
return Success(name_binding);
}
// If there is an unresolved glob at this point in the containing module, bail out.
// We don't know enough to be able to resolve the name.
if module.pub_glob_count.get() > 0 {
return (Indeterminate, false);
return Indeterminate;
}
match module.import_resolutions.borrow().get(&(name, ns)) {
// The containing module definitely doesn't have an exported import with the
// name in question. We can therefore accurately report that names are unbound.
None => (Failed(None), false),
None => Failed(None),
// The name is an import which has been fully resolved, so we just follow it.
Some(resolution) if resolution.outstanding_references == 0 => {
// Import resolutions must be declared with "pub" in order to be exported.
if !resolution.is_public {
return (Failed(None), false);
return Failed(None);
}
if let Some(binding) = resolution.binding {
self.resolver.record_import_use(name, ns, &resolution);
(Success(binding), true)
Success(binding)
} else {
(Failed(None), false)
Failed(None)
}
}
@ -427,8 +426,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
// In this case we continue as if we resolved the import and let
// check_for_conflicts_between_imports_and_items handle the conflict
Some(_) => match (importing_module.def_id(), module.def_id()) {
(Some(id1), Some(id2)) if id1 == id2 => (Failed(None), false),
_ => (Indeterminate, false)
(Some(id1), Some(id2)) if id1 == id2 => Failed(None),
_ => Indeterminate
},
}
}
@ -460,13 +459,13 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
};
// We need to resolve both namespaces for this to succeed.
let (value_result, value_used_reexport) =
let value_result =
self.resolve_name_in_module(target_module, source, ValueNS, module_);
let (type_result, type_used_reexport) =
let type_result =
self.resolve_name_in_module(target_module, source, TypeNS, module_);
match (&value_result, &type_result) {
(&Success(name_binding), _) if !value_used_reexport &&
(&Success(name_binding), _) if !name_binding.is_import() &&
directive.is_public &&
!name_binding.is_public() => {
let msg = format!("`{}` is private, and cannot be reexported", source);
@ -477,7 +476,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
.emit();
}
(_, &Success(name_binding)) if !type_used_reexport && directive.is_public => {
(_, &Success(name_binding)) if !name_binding.is_import() && directive.is_public => {
if !name_binding.is_public() {
let msg = format!("`{}` is private, and cannot be reexported", source);
let note_msg =
@ -521,14 +520,11 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
_ => (),
}
let mut value_used_public = false;
let mut type_used_public = false;
// We've successfully resolved the import. Write the results in.
let mut import_resolutions = module_.import_resolutions.borrow_mut();
{
let mut check_and_write_import = |namespace, result, used_public: &mut bool| {
let mut check_and_write_import = |namespace, result| {
let result: &ResolveResult<&NameBinding> = result;
let import_resolution = import_resolutions.get_mut(&(target, namespace)).unwrap();
@ -557,7 +553,6 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
import_resolution.is_public = directive.is_public;
self.add_export(module_, target, &import_resolution);
*used_public = name_binding.is_public();
}
Failed(_) => {
// Continue.
@ -572,8 +567,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
directive.span,
(target, namespace));
};
check_and_write_import(ValueNS, &value_result, &mut value_used_public);
check_and_write_import(TypeNS, &type_result, &mut type_used_public);
check_and_write_import(ValueNS, &value_result);
check_and_write_import(TypeNS, &type_result);
}
if let (&Failed(_), &Failed(_)) = (&value_result, &type_result) {
@ -583,9 +578,6 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
return Failed(Some((directive.span, msg)));
}
let value_used_public = value_used_reexport || value_used_public;
let type_used_public = type_used_reexport || type_used_public;
let value_def_and_priv = {
let import_resolution_value = import_resolutions.get_mut(&(target, ValueNS)).unwrap();
assert!(import_resolution_value.outstanding_references >= 1);
@ -596,7 +588,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
// purposes it's good enough to just favor one over the other.
import_resolution_value.binding.as_ref().map(|binding| {
let def = binding.def().unwrap();
let last_private = if value_used_public { lp } else { DependsOn(def.def_id()) };
let last_private = if binding.is_public() { lp } else { DependsOn(def.def_id()) };
(def, last_private)
})
};
@ -608,7 +600,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
import_resolution_type.binding.as_ref().map(|binding| {
let def = binding.def().unwrap();
let last_private = if type_used_public { lp } else { DependsOn(def.def_id()) };
let last_private = if binding.is_public() { lp } else { DependsOn(def.def_id()) };
(def, last_private)
})
};