From e1c9efcba48f098482ee6033835a4fe321268709 Mon Sep 17 00:00:00 2001 From: Jeffrey Seyfried Date: Wed, 17 Aug 2016 20:48:53 +0000 Subject: [PATCH] Refactor `value_determined` -> `value_result`, `type_determined` -> `type_result`. --- src/librustc_resolve/resolve_imports.rs | 85 +++++++++++++------------ 1 file changed, 45 insertions(+), 40 deletions(-) diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 3c440515036..6e1128c6773 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -38,23 +38,23 @@ pub fn resolve_imports(&mut self) { /// Contains data for specific types of import directives. #[derive(Clone, Debug)] -pub enum ImportDirectiveSubclass { +pub enum ImportDirectiveSubclass<'a> { SingleImport { target: Name, source: Name, - type_determined: Cell, - value_determined: Cell, + value_result: Cell, bool /* determined? */>>, + type_result: Cell, bool /* determined? */>>, }, GlobImport { is_prelude: bool }, } -impl ImportDirectiveSubclass { +impl<'a> ImportDirectiveSubclass<'a> { pub fn single(target: Name, source: Name) -> Self { SingleImport { target: target, source: source, - type_determined: Cell::new(false), - value_determined: Cell::new(false), + type_result: Cell::new(Err(false)), + value_result: Cell::new(Err(false)), } } } @@ -66,7 +66,7 @@ pub struct ImportDirective<'a> { parent: Module<'a>, module_path: Vec, target_module: Cell>>, // the resolution of `module_path` - subclass: ImportDirectiveSubclass, + subclass: ImportDirectiveSubclass<'a>, span: Span, vis: ty::Visibility, // see note in ImportResolutionPerNamespace about how to use this } @@ -235,7 +235,7 @@ fn try_result(&mut self, // Add an import directive to the current module. pub fn add_import_directive(&mut self, module_path: Vec, - subclass: ImportDirectiveSubclass, + subclass: ImportDirectiveSubclass<'a>, span: Span, id: NodeId, vis: ty::Visibility) { @@ -488,30 +488,35 @@ fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> ResolveResul }; directive.target_module.set(Some(target_module)); - let (source, target, value_determined, type_determined) = match directive.subclass { - SingleImport { source, target, ref value_determined, ref type_determined } => - (source, target, value_determined, type_determined), + let (source, target, value_result, type_result) = match directive.subclass { + SingleImport { source, target, ref value_result, ref type_result } => + (source, target, value_result, type_result), GlobImport { .. } => return self.resolve_glob_import(target_module, directive), }; - // We need to resolve both namespaces for this to succeed. - let span = directive.span; - let value_result = - self.resolve_name_in_module(target_module, source, ValueNS, false, Some(span)); - let type_result = - self.resolve_name_in_module(target_module, source, TypeNS, false, Some(span)); - let mut privacy_error = true; - for &(ns, result, determined) in &[(ValueNS, &value_result, value_determined), - (TypeNS, &type_result, type_determined)] { - match *result { - Failed(..) if !determined.get() => { - determined.set(true); + for &(ns, result) in &[(ValueNS, value_result), (TypeNS, type_result)] { + let was_determined = if let Err(false) = result.get() { + result.set({ + let span = Some(directive.span); + match self.resolve_name_in_module(target_module, source, ns, false, span) { + Success(binding) => Ok(binding), + Indeterminate => Err(false), + Failed(_) => Err(true), + } + }); + false + } else { + true + }; + + match result.get() { + Err(true) if !was_determined => { self.update_resolution(module, target, ns, |_, resolution| { resolution.single_imports.directive_failed() }); } - Success(binding) if !binding.is_importable() => { + Ok(binding) if !binding.is_importable() => { let msg = format!("`{}` is not directly importable", target); struct_span_err!(self.session, directive.span, E0253, "{}", &msg) .span_label(directive.span, &format!("cannot be imported directly")) @@ -521,9 +526,8 @@ fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> ResolveResul self.import_dummy_binding(directive); return Success(()); } - Success(binding) if !self.is_accessible(binding.vis) => {} - Success(binding) if !determined.get() => { - determined.set(true); + Ok(binding) if !self.is_accessible(binding.vis) => {} + Ok(binding) if !was_determined => { let imported_binding = self.import(binding, directive); let conflict = self.try_define(module, target, ns, imported_binding); if let Err(old_binding) = conflict { @@ -532,14 +536,15 @@ fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> ResolveResul } privacy_error = false; } - Success(_) => privacy_error = false, + Ok(_) => privacy_error = false, _ => {} } } - match (&value_result, &type_result) { - (&Indeterminate, _) | (_, &Indeterminate) => return Indeterminate, - (&Failed(_), &Failed(_)) => { + let (value_result, type_result) = (value_result.get(), type_result.get()); + match (value_result, type_result) { + (Err(false), _) | (_, Err(false)) => return Indeterminate, + (Err(true), Err(true)) => { let resolutions = target_module.resolutions.borrow(); let names = resolutions.iter().filter_map(|(&(ref name, _), resolution)| { if *name == source { return None; } // Never suggest the same name @@ -565,17 +570,17 @@ fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> ResolveResul } if privacy_error { - for &(ns, result) in &[(ValueNS, &value_result), (TypeNS, &type_result)] { - let binding = match *result { Success(binding) => binding, _ => continue }; + for &(ns, result) in &[(ValueNS, value_result), (TypeNS, type_result)] { + let binding = match result { Ok(binding) => binding, _ => continue }; self.privacy_errors.push(PrivacyError(directive.span, source, binding)); let imported_binding = self.import(binding, directive); let _ = self.try_define(module, target, ns, imported_binding); } } - match (&value_result, &type_result) { - (&Success(binding), _) if !binding.pseudo_vis().is_at_least(directive.vis, self) && - self.is_accessible(binding.vis) => { + match (value_result, type_result) { + (Ok(binding), _) if !binding.pseudo_vis().is_at_least(directive.vis, self) && + self.is_accessible(binding.vis) => { let msg = format!("`{}` is private, and cannot be reexported", source); let note_msg = format!("consider marking `{}` as `pub` in the imported module", source); @@ -584,8 +589,8 @@ fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> ResolveResul .emit(); } - (_, &Success(binding)) if !binding.pseudo_vis().is_at_least(directive.vis, self) && - self.is_accessible(binding.vis) => { + (_, Ok(binding)) if !binding.pseudo_vis().is_at_least(directive.vis, self) && + self.is_accessible(binding.vis) => { if binding.is_extern_crate() { let msg = format!("extern crate `{}` is private, and cannot be reexported \ (error E0364), consider declaring with `pub`", @@ -607,9 +612,9 @@ fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> ResolveResul // Record what this import resolves to for later uses in documentation, // this may resolve to either a value or a type, but for documentation // purposes it's good enough to just favor one over the other. - let def = match type_result.success().and_then(NameBinding::def) { + let def = match type_result.ok().and_then(NameBinding::def) { Some(def) => def, - None => value_result.success().and_then(NameBinding::def).unwrap(), + None => value_result.ok().and_then(NameBinding::def).unwrap(), }; let path_resolution = PathResolution::new(def); self.def_map.insert(directive.id, path_resolution); -- 2.44.0