From 889b0e9ace0aa6c4279ab6cf4f0553dd54f54ce7 Mon Sep 17 00:00:00 2001 From: corentih Date: Mon, 26 Oct 2015 20:31:11 +0100 Subject: [PATCH] rustfmt librustc_resolve --- src/librustc_resolve/build_reduced_graph.rs | 521 +++---- src/librustc_resolve/check_unused.rs | 26 +- src/librustc_resolve/diagnostics.rs | 6 +- src/librustc_resolve/lib.rs | 1460 ++++++++++--------- src/librustc_resolve/record_exports.rs | 39 +- src/librustc_resolve/resolve_imports.rs | 350 +++-- 6 files changed, 1216 insertions(+), 1186 deletions(-) diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 0bbceafa4a8..3481f1bfd52 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -66,7 +66,7 @@ enum DuplicateCheckingMode { ForbidDuplicateTypesAndModules, ForbidDuplicateValues, ForbidDuplicateTypesAndValues, - OverwriteDuplicates + OverwriteDuplicates, } #[derive(Copy, Clone, PartialEq)] @@ -74,19 +74,19 @@ enum NamespaceError { NoError, ModuleError, TypeError, - ValueError + ValueError, } fn namespace_error_to_string(ns: NamespaceError) -> &'static str { match ns { - NoError => "", + NoError => "", ModuleError | TypeError => "type or module", - ValueError => "value", + ValueError => "value", } } -struct GraphBuilder<'a, 'b:'a, 'tcx:'b> { - resolver: &'a mut Resolver<'b, 'tcx> +struct GraphBuilder<'a, 'b: 'a, 'tcx: 'b> { + resolver: &'a mut Resolver<'b, 'tcx>, } impl<'a, 'b:'a, 'tcx:'b> Deref for GraphBuilder<'a, 'b, 'tcx> { @@ -109,7 +109,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let parent = self.graph_root.get_module(); let mut visitor = BuildReducedGraphVisitor { builder: self, - parent: parent + parent: parent, }; visit::walk_crate(&mut visitor, krate); } @@ -135,9 +135,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // child name directly. Otherwise, we create or reuse an anonymous // module and add the child to that. - self.check_for_conflicts_between_external_crates_and_items(&**parent, - name, - sp); + self.check_for_conflicts_between_external_crates_and_items(&**parent, name, sp); // Add or reuse the child. let child = parent.children.borrow().get(&name).cloned(); @@ -194,14 +192,14 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { n = Some(TypeNS); duplicate_type = TypeError; } - }; + } if child.defined_in_namespace(ValueNS) { duplicate_type = ValueError; n = Some(ValueNS); } n } - OverwriteDuplicates => None + OverwriteDuplicates => None, }; if duplicate_type != NoError { // Return an error here by looking up the namespace that @@ -218,7 +216,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let r = child.span_for_namespace(ns); if let Some(sp) = r { self.session.span_note(sp, - &format!("first definition of {} `{}` here", + &format!("first definition of {} `{}` here", namespace_error_to_string(duplicate_type), name)); } @@ -278,15 +276,20 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let module_path = match view_path.node { ViewPathSimple(_, ref full_path) => { full_path.segments - .split_last().unwrap().1 - .iter().map(|seg| seg.identifier.name) - .collect() + .split_last() + .unwrap() + .1 + .iter() + .map(|seg| seg.identifier.name) + .collect() } ViewPathGlob(ref module_ident_path) | ViewPathList(ref module_ident_path, _) => { module_ident_path.segments - .iter().map(|seg| seg.identifier.name).collect() + .iter() + .map(|seg| seg.identifier.name) + .collect() } }; @@ -302,8 +305,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { match view_path.node { ViewPathSimple(binding, ref full_path) => { - let source_name = - full_path.segments.last().unwrap().identifier.name; + let source_name = full_path.segments.last().unwrap().identifier.name; if source_name.as_str() == "mod" || source_name.as_str() == "self" { resolve_error(self, view_path.span, @@ -321,19 +323,21 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } ViewPathList(_, ref source_items) => { // Make sure there's at most one `mod` import in the list. - let mod_spans = source_items.iter().filter_map(|item| match item.node { - PathListMod { .. } => Some(item.span), - _ => None - }).collect::>(); + let mod_spans = source_items.iter() + .filter_map(|item| { + match item.node { + PathListMod { .. } => Some(item.span), + _ => None, + } + }) + .collect::>(); if mod_spans.len() > 1 { - resolve_error( - self, - mod_spans[0], - ResolutionError::SelfImportCanOnlyAppearOnceInTheList - ); + resolve_error(self, + mod_spans[0], + ResolutionError::SelfImportCanOnlyAppearOnceInTheList); for other_span in mod_spans.iter().skip(1) { - self.session.span_note(*other_span, - "another `self` import appears here"); + self.session + .span_note(*other_span, "another `self` import appears here"); } } @@ -359,14 +363,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { (module_path.to_vec(), name, rename) } }; - self.build_import_directive( - &**parent, - module_path, - SingleImport(rename, name), - source_item.span, - source_item.node.id(), - is_public, - shadowable); + self.build_import_directive(&**parent, + module_path, + SingleImport(rename, name), + source_item.span, + source_item.node.id(), + is_public, + shadowable); } } ViewPathGlob(_) => { @@ -383,9 +386,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } ItemExternCrate(_) => { - // n.b. we don't need to look at the path option here, because cstore already did + // n.b. we don't need to look at the path option here, because cstore already + // did if let Some(crate_id) = self.session.cstore.find_extern_mod_stmt_cnum(item.id) { - let def_id = DefId { krate: crate_id, index: CRATE_DEF_INDEX }; + let def_id = DefId { + krate: crate_id, + index: CRATE_DEF_INDEX, + }; self.external_exports.insert(def_id); let parent_link = ModuleParentLink(Rc::downgrade(parent), name); let external_module = Rc::new(Module::new(parent_link, @@ -394,9 +401,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { false, true)); debug!("(build reduced graph for item) found extern `{}`", - module_to_string(&*external_module)); + module_to_string(&*external_module)); self.check_for_conflicts_between_external_crates(&**parent, name, sp); - parent.external_module_children.borrow_mut() + parent.external_module_children + .borrow_mut() .insert(name, external_module.clone()); self.build_reduced_graph_for_external_crate(&external_module); } @@ -407,20 +415,19 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let child = parent.children.borrow().get(&name).cloned(); if let Some(child) = child { // check if there's struct of the same name already defined - if child.defined_in_namespace(TypeNS) - && child.get_module_if_available().is_none() { - self.session.span_warn(sp, &format!( - "duplicate definition of {} `{}`. \ - Defining a module and a struct with \ - the same name will be disallowed \ - soon.", - namespace_error_to_string(TypeError), - name)); + if child.defined_in_namespace(TypeNS) && + child.get_module_if_available().is_none() { + self.session.span_warn(sp, + &format!("duplicate definition of {} `{}`. \ + Defining a module and a struct with \ + the same name will be disallowed soon.", + namespace_error_to_string(TypeError), + name)); { let r = child.span_for_namespace(TypeNS); if let Some(sp) = r { self.session.span_note(sp, - &format!("first definition of {} `{}` here", + &format!("first definition of {} `{}` here", namespace_error_to_string(TypeError), name)); } @@ -468,10 +475,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // These items live in the type namespace. ItemTy(..) => { - let name_bindings = - self.add_child(name, parent, ForbidDuplicateTypesAndModules, sp); + let name_bindings = self.add_child(name, + parent, + ForbidDuplicateTypesAndModules, + sp); - name_bindings.define_type(DefTy(self.ast_map.local_def_id(item.id), false), sp, + name_bindings.define_type(DefTy(self.ast_map.local_def_id(item.id), false), + sp, modifiers); let parent_link = self.get_parent_link(parent, name); @@ -485,8 +495,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } ItemEnum(ref enum_definition, _) => { - let name_bindings = - self.add_child(name, parent, ForbidDuplicateTypesAndModules, sp); + let name_bindings = self.add_child(name, + parent, + ForbidDuplicateTypesAndModules, + sp); name_bindings.define_type(DefTy(self.ast_map.local_def_id(item.id), true), sp, @@ -504,10 +516,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { for variant in &(*enum_definition).variants { let item_def_id = self.ast_map.local_def_id(item.id); - self.build_reduced_graph_for_variant( - &**variant, - item_def_id, - &module); + self.build_reduced_graph_for_variant(&**variant, item_def_id, &module); } parent.clone() } @@ -522,20 +531,21 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { if let Some(child) = child { // check if theres a DefMod if let Some(DefMod(_)) = child.def_for_namespace(TypeNS) { - self.session.span_warn(sp, &format!( - "duplicate definition of {} `{}`. \ - Defining a module and a struct with \ - the same name will be disallowed \ - soon.", - namespace_error_to_string(TypeError), - name)); + self.session.span_warn(sp, + &format!("duplicate definition of {} `{}`. \ + Defining a module and a struct \ + with the same name will be \ + disallowed soon.", + namespace_error_to_string(TypeError), + name)); { let r = child.span_for_namespace(TypeNS); if let Some(sp) = r { - self.session.span_note(sp, - &format!("first definition of {} `{}` here", - namespace_error_to_string(TypeError), - name)); + self.session + .span_note(sp, + &format!("first definition of {} `{}` here", + namespace_error_to_string(TypeError), + name)); } } } @@ -559,12 +569,15 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } // Record the def ID and fields of this struct. - let named_fields = struct_def.fields().iter().filter_map(|f| { - match f.node.kind { - NamedField(name, _) => Some(name), - UnnamedField(_) => None - } - }).collect(); + let named_fields = struct_def.fields() + .iter() + .filter_map(|f| { + match f.node.kind { + NamedField(name, _) => Some(name), + UnnamedField(_) => None, + } + }) + .collect(); let item_def_id = self.ast_map.local_def_id(item.id); self.structs.insert(item_def_id, named_fields); @@ -575,8 +588,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { ItemImpl(..) => parent.clone(), ItemTrait(_, _, _, ref items) => { - let name_bindings = - self.add_child(name, parent, ForbidDuplicateTypesAndModules, sp); + let name_bindings = self.add_child(name, + parent, + ForbidDuplicateTypesAndModules, + sp); // Add all the items within to a new module. let parent_link = self.get_parent_link(parent, name); @@ -593,9 +608,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // Add the names of all the items to the trait info. for trait_item in items { let name_bindings = self.add_child(trait_item.name, - &module_parent, - ForbidDuplicateTypesAndValues, - trait_item.span); + &module_parent, + ForbidDuplicateTypesAndValues, + trait_item.span); match trait_item.node { hir::ConstTraitItem(..) => { @@ -642,19 +657,19 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { false }; - let child = self.add_child(name, parent, - ForbidDuplicateTypesAndValues, - variant.span); + let child = self.add_child(name, parent, ForbidDuplicateTypesAndValues, variant.span); // variants are always treated as importable to allow them to be glob // used child.define_value(DefVariant(item_id, self.ast_map.local_def_id(variant.node.data.id()), is_exported), - variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); + variant.span, + DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); child.define_type(DefVariant(item_id, self.ast_map.local_def_id(variant.node.data.id()), is_exported), - variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); + variant.span, + DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); } /// Constructs the reduced graph for one foreign item. @@ -668,9 +683,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } else { DefModifiers::empty() } | DefModifiers::IMPORTABLE; - let name_bindings = - self.add_child(name, parent, ForbidDuplicateValues, - foreign_item.span); + let name_bindings = self.add_child(name, parent, ForbidDuplicateValues, foreign_item.span); let def = match foreign_item.node { ForeignItemFn(..) => { @@ -687,16 +700,15 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { if self.block_needs_anonymous_module(block) { let block_id = block.id; - debug!("(building reduced graph for block) creating a new \ - anonymous module for block {}", + debug!("(building reduced graph for block) creating a new anonymous module for block \ + {}", block_id); - let new_module = Rc::new(Module::new( - BlockParentLink(Rc::downgrade(parent), block_id), - None, - AnonymousModuleKind, - false, - false)); + let new_module = Rc::new(Module::new(BlockParentLink(Rc::downgrade(parent), block_id), + None, + AnonymousModuleKind, + false, + false)); parent.anonymous_children.borrow_mut().insert(block_id, new_module.clone()); new_module } else { @@ -711,18 +723,19 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { final_ident: &str, name: Name, new_parent: &Rc) { - debug!("(building reduced graph for \ - external crate) building external def {}, priv {:?}", - final_ident, vis); + debug!("(building reduced graph for external crate) building external def {}, priv {:?}", + final_ident, + vis); let is_public = vis == hir::Public; let modifiers = if is_public { DefModifiers::PUBLIC } else { DefModifiers::empty() } | DefModifiers::IMPORTABLE; - let is_exported = is_public && match new_parent.def_id.get() { + let is_exported = is_public && + match new_parent.def_id.get() { None => true, - Some(did) => self.external_exports.contains(&did) + Some(did) => self.external_exports.contains(&did), }; if is_exported { self.external_exports.insert(def.def_id()); @@ -731,140 +744,148 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let kind = match def { DefTy(_, true) => EnumModuleKind, DefTy(_, false) | DefStruct(..) => TypeModuleKind, - _ => NormalModuleKind + _ => NormalModuleKind, }; match def { - DefMod(def_id) | DefForeignMod(def_id) | DefStruct(def_id) | - DefTy(def_id, _) => { - let type_def = child_name_bindings.type_def.borrow().clone(); - match type_def { - Some(TypeNsDef { module_def: Some(module_def), .. }) => { - debug!("(building reduced graph for external crate) \ - already created module"); - module_def.def_id.set(Some(def_id)); - } - Some(_) | None => { - debug!("(building reduced graph for \ - external crate) building module \ - {} {}", final_ident, is_public); - let parent_link = self.get_parent_link(new_parent, name); + DefMod(def_id) | + DefForeignMod(def_id) | + DefStruct(def_id) | + DefTy(def_id, _) => { + let type_def = child_name_bindings.type_def.borrow().clone(); + match type_def { + Some(TypeNsDef { module_def: Some(module_def), .. }) => { + debug!("(building reduced graph for external crate) already created \ + module"); + module_def.def_id.set(Some(def_id)); + } + Some(_) | None => { + debug!("(building reduced graph for external crate) building module {} {}", + final_ident, + is_public); + let parent_link = self.get_parent_link(new_parent, name); - child_name_bindings.define_module(parent_link, - Some(def_id), - kind, - true, - is_public, - DUMMY_SP); - } + child_name_bindings.define_module(parent_link, + Some(def_id), + kind, + true, + is_public, + DUMMY_SP); + } + } } - } - _ => {} + _ => {} } match def { - DefMod(_) | DefForeignMod(_) => {} - DefVariant(_, variant_id, is_struct) => { - debug!("(building reduced graph for external crate) building \ - variant {}", - final_ident); - // variants are always treated as importable to allow them to be - // glob used - let modifiers = DefModifiers::PUBLIC | DefModifiers::IMPORTABLE; - if is_struct { - child_name_bindings.define_type(def, DUMMY_SP, modifiers); - // Not adding fields for variants as they are not accessed with a self receiver - self.structs.insert(variant_id, Vec::new()); - } else { - child_name_bindings.define_value(def, DUMMY_SP, modifiers); - } - } - DefFn(ctor_id, true) => { - child_name_bindings.define_value( + DefMod(_) | DefForeignMod(_) => {} + DefVariant(_, variant_id, is_struct) => { + debug!("(building reduced graph for external crate) building variant {}", + final_ident); + // variants are always treated as importable to allow them to be + // glob used + let modifiers = DefModifiers::PUBLIC | DefModifiers::IMPORTABLE; + if is_struct { + child_name_bindings.define_type(def, DUMMY_SP, modifiers); + // Not adding fields for variants as they are not accessed with a self receiver + self.structs.insert(variant_id, Vec::new()); + } else { + child_name_bindings.define_value(def, DUMMY_SP, modifiers); + } + } + DefFn(ctor_id, true) => { + child_name_bindings.define_value( csearch::get_tuple_struct_definition_if_ctor(&self.session.cstore, ctor_id) .map_or(def, |_| DefStruct(ctor_id)), DUMMY_SP, modifiers); - } - DefFn(..) | DefStatic(..) | DefConst(..) | DefAssociatedConst(..) | - DefMethod(..) => { - debug!("(building reduced graph for external \ - crate) building value (fn/static) {}", final_ident); - // impl methods have already been defined with the correct importability modifier - let mut modifiers = match *child_name_bindings.value_def.borrow() { - Some(ref def) => (modifiers & !DefModifiers::IMPORTABLE) | - (def.modifiers & DefModifiers::IMPORTABLE), - None => modifiers - }; - if new_parent.kind.get() != NormalModuleKind { - modifiers = modifiers & !DefModifiers::IMPORTABLE; } - child_name_bindings.define_value(def, DUMMY_SP, modifiers); - } - DefTrait(def_id) => { - debug!("(building reduced graph for external \ - crate) building type {}", final_ident); - - // If this is a trait, add all the trait item names to the trait - // info. - - let trait_item_def_ids = - csearch::get_trait_item_def_ids(&self.session.cstore, def_id); - for trait_item_def in &trait_item_def_ids { - let trait_item_name = csearch::get_trait_name(&self.session.cstore, - trait_item_def.def_id()); - - debug!("(building reduced graph for external crate) ... \ - adding trait item '{}'", - trait_item_name); - - self.trait_item_map.insert((trait_item_name, def_id), - trait_item_def.def_id()); - - if is_exported { - self.external_exports.insert(trait_item_def.def_id()); - } - } - - child_name_bindings.define_type(def, DUMMY_SP, modifiers); - - // Define a module if necessary. - let parent_link = self.get_parent_link(new_parent, name); - child_name_bindings.set_module_kind(parent_link, - Some(def_id), - TraitModuleKind, - true, - is_public, - DUMMY_SP) - } - DefTy(..) | DefAssociatedTy(..) => { - debug!("(building reduced graph for external \ - crate) building type {}", final_ident); - - let modifiers = match new_parent.kind.get() { - NormalModuleKind => modifiers, - _ => modifiers & !DefModifiers::IMPORTABLE - }; - - child_name_bindings.define_type(def, DUMMY_SP, modifiers); - } - DefStruct(def_id) => { - debug!("(building reduced graph for external \ - crate) building type and value for {}", - final_ident); - child_name_bindings.define_type(def, DUMMY_SP, modifiers); - let fields = csearch::get_struct_field_names(&self.session.cstore, def_id); - - if fields.is_empty() { + DefFn(..) | + DefStatic(..) | + DefConst(..) | + DefAssociatedConst(..) | + DefMethod(..) => { + debug!("(building reduced graph for external crate) building value (fn/static) {}", + final_ident); + // impl methods have already been defined with the correct importability + // modifier + let mut modifiers = match *child_name_bindings.value_def.borrow() { + Some(ref def) => (modifiers & !DefModifiers::IMPORTABLE) | + (def.modifiers & DefModifiers::IMPORTABLE), + None => modifiers, + }; + if new_parent.kind.get() != NormalModuleKind { + modifiers = modifiers & !DefModifiers::IMPORTABLE; + } child_name_bindings.define_value(def, DUMMY_SP, modifiers); } + DefTrait(def_id) => { + debug!("(building reduced graph for external crate) building type {}", + final_ident); - // Record the def ID and fields of this struct. - self.structs.insert(def_id, fields); - } - DefLocal(..) | DefPrimTy(..) | DefTyParam(..) | - DefUse(..) | DefUpvar(..) | - DefLabel(..) | DefSelfTy(..) => { - panic!("didn't expect `{:?}`", def); - } + // If this is a trait, add all the trait item names to the trait + // info. + + let trait_item_def_ids = csearch::get_trait_item_def_ids(&self.session.cstore, + def_id); + for trait_item_def in &trait_item_def_ids { + let trait_item_name = csearch::get_trait_name(&self.session.cstore, + trait_item_def.def_id()); + + debug!("(building reduced graph for external crate) ... adding trait item \ + '{}'", + trait_item_name); + + self.trait_item_map.insert((trait_item_name, def_id), trait_item_def.def_id()); + + if is_exported { + self.external_exports.insert(trait_item_def.def_id()); + } + } + + child_name_bindings.define_type(def, DUMMY_SP, modifiers); + + // Define a module if necessary. + let parent_link = self.get_parent_link(new_parent, name); + child_name_bindings.set_module_kind(parent_link, + Some(def_id), + TraitModuleKind, + true, + is_public, + DUMMY_SP) + } + DefTy(..) | DefAssociatedTy(..) => { + debug!("(building reduced graph for external crate) building type {}", + final_ident); + + let modifiers = match new_parent.kind.get() { + NormalModuleKind => modifiers, + _ => modifiers & !DefModifiers::IMPORTABLE, + }; + + child_name_bindings.define_type(def, DUMMY_SP, modifiers); + } + DefStruct(def_id) => { + debug!("(building reduced graph for external crate) building type and value for \ + {}", + final_ident); + child_name_bindings.define_type(def, DUMMY_SP, modifiers); + let fields = csearch::get_struct_field_names(&self.session.cstore, def_id); + + if fields.is_empty() { + child_name_bindings.define_value(def, DUMMY_SP, modifiers); + } + + // Record the def ID and fields of this struct. + self.structs.insert(def_id, fields); + } + DefLocal(..) | + DefPrimTy(..) | + DefTyParam(..) | + DefUse(..) | + DefUpvar(..) | + DefLabel(..) | + DefSelfTy(..) => { + panic!("didn't expect `{:?}`", def); + } } } @@ -894,11 +915,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { }); } _ => { - let child_name_bindings = - self.add_child(name, - root, - OverwriteDuplicates, - DUMMY_SP); + let child_name_bindings = self.add_child(name, + root, + OverwriteDuplicates, + DUMMY_SP); self.handle_external_def(def, def_visibility, @@ -910,12 +930,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } } DlImpl(_) => { - debug!("(building reduced graph for external crate) \ - ignoring impl"); + debug!("(building reduced graph for external crate) ignoring impl"); } DlField => { - debug!("(building reduced graph for external crate) \ - ignoring field"); + debug!("(building reduced graph for external crate) ignoring field"); } } } @@ -928,7 +946,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let def_id = match module.def_id.get() { None => { debug!("(populating external module) ... no def ID!"); - return + return; } Some(def_id) => def_id, }; @@ -936,13 +954,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { csearch::each_child_of_item(&self.session.cstore, def_id, |def_like, child_name, visibility| { - debug!("(populating external module) ... found ident: {}", - child_name); - self.build_reduced_graph_for_external_crate_def(module, - def_like, - child_name, - visibility) - }); + debug!("(populating external module) ... found ident: {}", + child_name); + self.build_reduced_graph_for_external_crate_def(module, + def_like, + child_name, + visibility) + }); module.populated.set(true) } @@ -977,12 +995,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { id: NodeId, is_public: bool, shadowable: Shadowable) { - module_.imports.borrow_mut().push(ImportDirective::new(module_path, - subclass, - span, - id, - is_public, - shadowable)); + module_.imports + .borrow_mut() + .push(ImportDirective::new(module_path, subclass, span, id, is_public, shadowable)); self.unresolved_imports += 1; if is_public { @@ -1030,9 +1045,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } } -struct BuildReducedGraphVisitor<'a, 'b:'a, 'tcx:'b> { +struct BuildReducedGraphVisitor<'a, 'b: 'a, 'tcx: 'b> { builder: GraphBuilder<'a, 'b, 'tcx>, - parent: Rc + parent: Rc, } impl<'a, 'b, 'v, 'tcx> Visitor<'v> for BuildReducedGraphVisitor<'a, 'b, 'tcx> { @@ -1056,13 +1071,9 @@ impl<'a, 'b, 'v, 'tcx> Visitor<'v> for BuildReducedGraphVisitor<'a, 'b, 'tcx> { } pub fn build_reduced_graph(resolver: &mut Resolver, krate: &hir::Crate) { - GraphBuilder { - resolver: resolver - }.build_reduced_graph(krate); + GraphBuilder { resolver: resolver }.build_reduced_graph(krate); } pub fn populate_module_if_necessary(resolver: &mut Resolver, module: &Rc) { - GraphBuilder { - resolver: resolver - }.populate_module_if_necessary(module); + GraphBuilder { resolver: resolver }.populate_module_if_necessary(module); } diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 4ebc1093a0b..870990f7860 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -31,8 +31,8 @@ use rustc_front::hir; use rustc_front::hir::{ViewPathGlob, ViewPathList, ViewPathSimple}; use rustc_front::visit::{self, Visitor}; -struct UnusedImportCheckVisitor<'a, 'b:'a, 'tcx:'b> { - resolver: &'a mut Resolver<'b, 'tcx> +struct UnusedImportCheckVisitor<'a, 'b: 'a, 'tcx: 'b> { + resolver: &'a mut Resolver<'b, 'tcx>, } // Deref and DerefMut impls allow treating UnusedImportCheckVisitor as Resolver. @@ -51,16 +51,16 @@ impl<'a, 'b, 'tcx:'b> DerefMut for UnusedImportCheckVisitor<'a, 'b, 'tcx> { } impl<'a, 'b, 'tcx> UnusedImportCheckVisitor<'a, 'b, 'tcx> { - // We have information about whether `use` (import) directives are actually used now. - // If an import is not used at all, we signal a lint error. If an import is only used - // for a single namespace, we remove the other namespace from the recorded privacy - // information. That means in privacy.rs, we will only check imports and namespaces - // which are used. In particular, this means that if an import could name either a - // public or private item, we will check the correct thing, dependent on how the import - // is used. + // We have information about whether `use` (import) directives are actually + // used now. If an import is not used at all, we signal a lint error. If an + // import is only used for a single namespace, we remove the other namespace + // from the recorded privacy information. That means in privacy.rs, we will + // only check imports and namespaces which are used. In particular, this + // means that if an import could name either a public or private item, we + // will check the correct thing, dependent on how the import is used. fn finalize_import(&mut self, id: ast::NodeId, span: Span) { debug!("finalizing import uses for {:?}", - self.session.codemap().span_to_snippet(span)); + self.session.codemap().span_to_snippet(span)); if !self.used_imports.contains(&(id, TypeNS)) && !self.used_imports.contains(&(id, ValueNS)) { @@ -99,14 +99,14 @@ impl<'a, 'b, 'tcx> UnusedImportCheckVisitor<'a, 'b, 'tcx> { // we might have two LastPrivates pointing at the same thing. There is no point // checking both, so lets not check the value one. (Some(DependsOn(def_v)), Some(DependsOn(def_t))) if def_v == def_t => v_used = Unused, - _ => {}, + _ => {} } path_res.last_private = LastImport { value_priv: v_priv, value_used: v_used, type_priv: t_priv, - type_used: t_used + type_used: t_used, }; } } @@ -132,7 +132,7 @@ impl<'a, 'b, 'v, 'tcx> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b, 'tcx> { "unused extern crate".to_string()); } } - }, + } hir::ItemUse(ref p) => { match p.node { ViewPathSimple(_, _) => { diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index 4147f2bea48..a6665a13786 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -10,9 +10,9 @@ #![allow(non_snake_case)] -// Error messages for EXXXX errors. -// Each message should start and end with a new line, and be wrapped to 80 characters. -// In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable. +// Error messages for EXXXX errors. Each message should start and end with a +// new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and +// use `gq` to wrap paragraphs. Use `:set tw=0` to disable. register_long_diagnostics! { E0154: r##" diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 80062b371a3..a402d8310f9 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -25,9 +25,13 @@ #![feature(rustc_private)] #![feature(staged_api)] -#[macro_use] extern crate log; -#[macro_use] extern crate syntax; -#[macro_use] #[no_link] extern crate rustc_bitflags; +#[macro_use] +extern crate log; +#[macro_use] +extern crate syntax; +#[macro_use] +#[no_link] +extern crate rustc_bitflags; extern crate rustc_front; extern crate rustc; @@ -198,208 +202,279 @@ pub enum ResolutionError<'a> { AttemptToUseNonConstantValueInConstant, } -fn resolve_error<'b, 'a:'b, 'tcx:'a>(resolver: &'b Resolver<'a, 'tcx>, span: syntax::codemap::Span, - resolution_error: ResolutionError<'b>) { +fn resolve_error<'b, 'a: 'b, 'tcx: 'a>(resolver: &'b Resolver<'a, 'tcx>, + span: syntax::codemap::Span, + resolution_error: ResolutionError<'b>) { if !resolver.emit_errors { return; } match resolution_error { ResolutionError::TypeParametersFromOuterFunction => { - span_err!(resolver.session, span, E0401, "can't use type parameters from \ - outer function; try using a local \ - type parameter instead"); - }, + span_err!(resolver.session, + span, + E0401, + "can't use type parameters from outer function; try using a local type \ + parameter instead"); + } ResolutionError::OuterTypeParameterContext => { - span_err!(resolver.session, span, E0402, - "cannot use an outer type parameter in this context"); - }, + span_err!(resolver.session, + span, + E0402, + "cannot use an outer type parameter in this context"); + } ResolutionError::NameAlreadyUsedInTypeParameterList(name) => { - span_err!(resolver.session, span, E0403, - "the name `{}` is already used for a type \ - parameter in this type parameter list", name); - }, + span_err!(resolver.session, + span, + E0403, + "the name `{}` is already used for a type parameter in this type parameter \ + list", + name); + } ResolutionError::IsNotATrait(name) => { - span_err!(resolver.session, span, E0404, - "`{}` is not a trait", - name); - }, + span_err!(resolver.session, span, E0404, "`{}` is not a trait", name); + } ResolutionError::UndeclaredTraitName(name) => { - span_err!(resolver.session, span, E0405, - "use of undeclared trait name `{}`", - name); - }, + span_err!(resolver.session, + span, + E0405, + "use of undeclared trait name `{}`", + name); + } ResolutionError::UndeclaredAssociatedType => { span_err!(resolver.session, span, E0406, "undeclared associated type"); - }, + } ResolutionError::MethodNotMemberOfTrait(method, trait_) => { - span_err!(resolver.session, span, E0407, - "method `{}` is not a member of trait `{}`", - method, - trait_); - }, + span_err!(resolver.session, + span, + E0407, + "method `{}` is not a member of trait `{}`", + method, + trait_); + } ResolutionError::TypeNotMemberOfTrait(type_, trait_) => { - span_err!(resolver.session, span, E0437, - "type `{}` is not a member of trait `{}`", - type_, - trait_); - }, + span_err!(resolver.session, + span, + E0437, + "type `{}` is not a member of trait `{}`", + type_, + trait_); + } ResolutionError::ConstNotMemberOfTrait(const_, trait_) => { - span_err!(resolver.session, span, E0438, - "const `{}` is not a member of trait `{}`", - const_, - trait_); - }, + span_err!(resolver.session, + span, + E0438, + "const `{}` is not a member of trait `{}`", + const_, + trait_); + } ResolutionError::VariableNotBoundInPattern(variable_name, pattern_number) => { - span_err!(resolver.session, span, E0408, - "variable `{}` from pattern #1 is not bound in pattern #{}", - variable_name, - pattern_number); - }, + span_err!(resolver.session, + span, + E0408, + "variable `{}` from pattern #1 is not bound in pattern #{}", + variable_name, + pattern_number); + } ResolutionError::VariableBoundWithDifferentMode(variable_name, pattern_number) => { - span_err!(resolver.session, span, E0409, - "variable `{}` is bound with different \ - mode in pattern #{} than in pattern #1", - variable_name, - pattern_number); - }, + span_err!(resolver.session, + span, + E0409, + "variable `{}` is bound with different mode in pattern #{} than in pattern \ + #1", + variable_name, + pattern_number); + } ResolutionError::VariableNotBoundInParentPattern(variable_name, pattern_number) => { - span_err!(resolver.session, span, E0410, - "variable `{}` from pattern #{} is not bound in pattern #1", - variable_name, - pattern_number); - }, + span_err!(resolver.session, + span, + E0410, + "variable `{}` from pattern #{} is not bound in pattern #1", + variable_name, + pattern_number); + } ResolutionError::SelfUsedOutsideImplOrTrait => { - span_err!(resolver.session, span, E0411, "use of `Self` outside of an impl or trait"); - }, + span_err!(resolver.session, + span, + E0411, + "use of `Self` outside of an impl or trait"); + } ResolutionError::UseOfUndeclared(kind, name) => { - span_err!(resolver.session, span, E0412, - "use of undeclared {} `{}`", - kind, - name); - }, + span_err!(resolver.session, + span, + E0412, + "use of undeclared {} `{}`", + kind, + name); + } ResolutionError::DeclarationShadowsEnumVariantOrUnitLikeStruct(name) => { - span_err!(resolver.session, span, E0413, - "declaration of `{}` shadows an enum variant or unit-like struct in \ - scope", - name); - }, + span_err!(resolver.session, + span, + E0413, + "declaration of `{}` shadows an enum variant or unit-like struct in scope", + name); + } ResolutionError::OnlyIrrefutablePatternsAllowedHere(did, name) => { - span_err!(resolver.session, span, E0414, "only irrefutable patterns allowed here"); - resolver.session.span_note(span, "there already is a constant in scope \ - sharing the same name as this pattern"); + span_err!(resolver.session, + span, + E0414, + "only irrefutable patterns allowed here"); + resolver.session.span_note(span, + "there already is a constant in scope sharing the same \ + name as this pattern"); if let Some(sp) = resolver.ast_map.span_if_local(did) { resolver.session.span_note(sp, "constant defined here"); } if let Some(directive) = resolver.current_module .import_resolutions - .borrow().get(&name) { + .borrow() + .get(&name) { let item = resolver.ast_map.expect_item(directive.value_id); resolver.session.span_note(item.span, "constant imported here"); } - }, + } ResolutionError::IdentifierBoundMoreThanOnceInParameterList(identifier) => { - span_err!(resolver.session, span, E0415, - "identifier `{}` is bound more than once in this parameter list", - identifier); - }, + span_err!(resolver.session, + span, + E0415, + "identifier `{}` is bound more than once in this parameter list", + identifier); + } ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(identifier) => { - span_err!(resolver.session, span, E0416, - "identifier `{}` is bound more than once in the same pattern", - identifier); - }, + span_err!(resolver.session, + span, + E0416, + "identifier `{}` is bound more than once in the same pattern", + identifier); + } ResolutionError::StaticVariableReference => { - span_err!(resolver.session, span, E0417, "static variables cannot be \ - referenced in a pattern, \ - use a `const` instead"); - }, + span_err!(resolver.session, + span, + E0417, + "static variables cannot be referenced in a pattern, use a `const` instead"); + } ResolutionError::NotAnEnumVariantStructOrConst(name) => { - span_err!(resolver.session, span, E0418, - "`{}` is not an enum variant, struct or const", - name); - }, + span_err!(resolver.session, + span, + E0418, + "`{}` is not an enum variant, struct or const", + name); + } ResolutionError::UnresolvedEnumVariantStructOrConst(name) => { - span_err!(resolver.session, span, E0419, - "unresolved enum variant, struct or const `{}`", - name); - }, + span_err!(resolver.session, + span, + E0419, + "unresolved enum variant, struct or const `{}`", + name); + } ResolutionError::NotAnAssociatedConst(name) => { - span_err!(resolver.session, span, E0420, - "`{}` is not an associated const", - name); - }, + span_err!(resolver.session, + span, + E0420, + "`{}` is not an associated const", + name); + } ResolutionError::UnresolvedAssociatedConst(name) => { - span_err!(resolver.session, span, E0421, - "unresolved associated const `{}`", - name); - }, + span_err!(resolver.session, + span, + E0421, + "unresolved associated const `{}`", + name); + } ResolutionError::DoesNotNameAStruct(name) => { - span_err!(resolver.session, span, E0422, "`{}` does not name a structure", name); - }, + span_err!(resolver.session, + span, + E0422, + "`{}` does not name a structure", + name); + } ResolutionError::StructVariantUsedAsFunction(path_name) => { - span_err!(resolver.session, span, E0423, - "`{}` is the name of a struct or struct variant, \ - but this expression \ - uses it like a function name", - path_name); - }, + span_err!(resolver.session, + span, + E0423, + "`{}` is the name of a struct or struct variant, but this expression uses \ + it like a function name", + path_name); + } ResolutionError::SelfNotAvailableInStaticMethod => { - span_err!(resolver.session, span, E0424, "`self` is not available in a static method. \ - Maybe a `self` argument is missing?"); - }, + span_err!(resolver.session, + span, + E0424, + "`self` is not available in a static method. Maybe a `self` argument is \ + missing?"); + } ResolutionError::UnresolvedName(path, name) => { - span_err!(resolver.session, span, E0425, - "unresolved name `{}`{}", - path, - name); - }, + span_err!(resolver.session, + span, + E0425, + "unresolved name `{}`{}", + path, + name); + } ResolutionError::UndeclaredLabel(name) => { - span_err!(resolver.session, span, E0426, - "use of undeclared label `{}`", - name); - }, + span_err!(resolver.session, + span, + E0426, + "use of undeclared label `{}`", + name); + } ResolutionError::CannotUseRefBindingModeWith(descr) => { - span_err!(resolver.session, span, E0427, - "cannot use `ref` binding mode with {}", - descr); - }, + span_err!(resolver.session, + span, + E0427, + "cannot use `ref` binding mode with {}", + descr); + } ResolutionError::DuplicateDefinition(namespace, name) => { - span_err!(resolver.session, span, E0428, - "duplicate definition of {} `{}`", - namespace, - name); - }, + span_err!(resolver.session, + span, + E0428, + "duplicate definition of {} `{}`", + namespace, + name); + } ResolutionError::SelfImportsOnlyAllowedWithin => { - span_err!(resolver.session, span, E0429, "{}", - "`self` imports are only allowed within a { } list"); - }, + span_err!(resolver.session, + span, + E0429, + "{}", + "`self` imports are only allowed within a { } list"); + } ResolutionError::SelfImportCanOnlyAppearOnceInTheList => { - span_err!(resolver.session, span, E0430, - "`self` import can only appear once in the list"); - }, + span_err!(resolver.session, + span, + E0430, + "`self` import can only appear once in the list"); + } ResolutionError::SelfImportOnlyInImportListWithNonEmptyPrefix => { - span_err!(resolver.session, span, E0431, - "`self` import can only appear in an import list with a \ - non-empty prefix"); + span_err!(resolver.session, + span, + E0431, + "`self` import can only appear in an import list with a non-empty prefix"); } ResolutionError::UnresolvedImport(name) => { let msg = match name { Some((n, p)) => format!("unresolved import `{}`{}", n, p), - None => "unresolved import".to_owned() + None => "unresolved import".to_owned(), }; span_err!(resolver.session, span, E0432, "{}", msg); - }, + } ResolutionError::FailedToResolve(msg) => { span_err!(resolver.session, span, E0433, "failed to resolve. {}", msg); - }, + } ResolutionError::CannotCaptureDynamicEnvironmentInFnItem => { - span_err!(resolver.session, span, E0434, "{}", - "can't capture dynamic environment in a fn item; \ - use the || { ... } closure form instead"); - }, - ResolutionError::AttemptToUseNonConstantValueInConstant =>{ - span_err!(resolver.session, span, E0435, - "attempt to use a non-constant value in a constant"); - }, + span_err!(resolver.session, + span, + E0434, + "{}", + "can't capture dynamic environment in a fn item; use the || { ... } \ + closure form instead"); + } + ResolutionError::AttemptToUseNonConstantValueInConstant => { + span_err!(resolver.session, + span, + E0435, + "attempt to use a non-constant value in a constant"); + } } } @@ -422,7 +497,7 @@ enum PatternBindingMode { #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub enum Namespace { TypeNS, - ValueNS + ValueNS, } /// A NamespaceResult represents the result of resolving an import in @@ -439,20 +514,20 @@ enum NamespaceResult { UnboundResult, /// Means that resolve has determined that the name is bound in the Module /// argument, and specified by the NameBindings argument. - BoundResult(Rc, Rc) + BoundResult(Rc, Rc), } impl NamespaceResult { fn is_unknown(&self) -> bool { match *self { UnknownResult => true, - _ => false + _ => false, } } fn is_unbound(&self) -> bool { match *self { UnboundResult => true, - _ => false + _ => false, } } } @@ -492,16 +567,19 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { fn visit_generics(&mut self, generics: &Generics) { self.resolve_generics(generics); } - fn visit_poly_trait_ref(&mut self, - tref: &hir::PolyTraitRef, - m: &hir::TraitBoundModifier) { + fn visit_poly_trait_ref(&mut self, tref: &hir::PolyTraitRef, m: &hir::TraitBoundModifier) { match self.resolve_trait_reference(tref.trait_ref.ref_id, &tref.trait_ref.path, 0) { Ok(def) => self.record_def(tref.trait_ref.ref_id, def), - Err(_) => { /* error already reported */ } + Err(_) => { + // error already reported + } } visit::walk_poly_trait_ref(self, tref, m); } - fn visit_variant(&mut self, variant: &hir::Variant, generics: &Generics, item_id: ast::NodeId) { + fn visit_variant(&mut self, + variant: &hir::Variant, + generics: &Generics, + item_id: ast::NodeId) { execute_callback!(hir_map::Node::NodeVariant(variant), self); if let Some(ref dis_expr) = variant.node.disr_expr { // resolve the discriminator expr as a constant @@ -511,8 +589,11 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { } // `visit::walk_variant` without the discriminant expression. - self.visit_variant_data(&variant.node.data, variant.node.name, - generics, item_id, variant.span); + self.visit_variant_data(&variant.node.data, + variant.node.name, + generics, + item_id, + variant.span); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) { execute_callback!(hir_map::Node::NodeForeignItem(foreign_item), self); @@ -520,7 +601,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { ForeignItemFn(_, ref generics) => { HasTypeParameters(generics, FnSpace, ItemRibKind) } - ForeignItemStatic(..) => NoTypeParameters + ForeignItemStatic(..) => NoTypeParameters, }; self.with_type_parameter_rib(type_parameters, |this| { visit::walk_foreign_item(this, foreign_item); @@ -542,7 +623,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { self.visit_explicit_self(&sig.explicit_self); MethodRibKind } - FnKind::Closure(..) => ClosureRibKind(node_id) + FnKind::Closure(..) => ClosureRibKind(node_id), }; self.resolve_function(rib_kind, declaration, block); } @@ -551,14 +632,17 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { type ErrorMessage = Option<(Span, String)>; enum ResolveResult { - Failed(ErrorMessage), // Failed to resolve the name, optional helpful error message. - Indeterminate, // Couldn't determine due to unresolved globs. - Success(T) // Successfully resolved the import. + Failed(ErrorMessage), // Failed to resolve the name, optional helpful error message. + Indeterminate, // Couldn't determine due to unresolved globs. + Success(T), // Successfully resolved the import. } impl ResolveResult { fn success(&self) -> bool { - match *self { Success(_) => true, _ => false } + match *self { + Success(_) => true, + _ => false, + } } } @@ -574,16 +658,15 @@ enum FallbackSuggestion { #[derive(Copy, Clone)] enum TypeParameters<'a> { NoTypeParameters, - HasTypeParameters( - // Type parameters. - &'a Generics, + HasTypeParameters(// Type parameters. + &'a Generics, - // Identifies the things that these parameters - // were declared on (type, fn, etc) - ParamSpace, + // Identifies the things that these parameters + // were declared on (type, fn, etc) + ParamSpace, - // The kind of the rib used for type parameters. - RibKind) + // The kind of the rib used for type parameters. + RibKind), } // The rib kind controls the translation of local @@ -607,18 +690,18 @@ enum RibKind { ItemRibKind, // We're in a constant item. Can't refer to dynamic stuff. - ConstantItemRibKind + ConstantItemRibKind, } #[derive(Copy, Clone)] enum UseLexicalScopeFlag { DontUseLexicalScope, - UseLexicalScope + UseLexicalScope, } enum ModulePrefixResult { NoPrefixFound, - PrefixFound(Rc, usize) + PrefixFound(Rc, usize), } #[derive(Copy, Clone)] @@ -644,7 +727,7 @@ enum NameSearchType { enum BareIdentifierPatternResolution { FoundStructOrEnumVariant(Def, LastPrivate), FoundConst(Def, LastPrivate, Name), - BareIdentifierPatternUnresolved + BareIdentifierPatternUnresolved, } /// One local scope. @@ -658,7 +741,7 @@ impl Rib { fn new(kind: RibKind) -> Rib { Rib { bindings: HashMap::new(), - kind: kind + kind: kind, } } } @@ -666,14 +749,14 @@ impl Rib { /// A definition along with the index of the rib it was found on struct LocalDef { ribs: Option<(Namespace, usize)>, - def: Def + def: Def, } impl LocalDef { fn from_def(def: Def) -> Self { LocalDef { ribs: None, - def: def + def: def, } } } @@ -683,7 +766,7 @@ impl LocalDef { enum ParentLink { NoParentLink, ModuleParentLink(Weak, Name), - BlockParentLink(Weak, NodeId) + BlockParentLink(Weak, NodeId), } /// The type of module this is. @@ -808,10 +891,15 @@ impl Module { impl fmt::Debug for Module { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{:?}, kind: {:?}, {}", + write!(f, + "{:?}, kind: {:?}, {}", self.def_id, self.kind, - if self.is_public { "public" } else { "private" } ) + if self.is_public { + "public" + } else { + "private" + }) } } @@ -829,7 +917,7 @@ struct TypeNsDef { modifiers: DefModifiers, // see note in ImportResolution about how to use this module_def: Option>, type_def: Option, - type_span: Option + type_span: Option, } // Records a possibly-private value definition. @@ -844,8 +932,8 @@ struct ValueNsDef { // bound to. #[derive(Debug)] pub struct NameBindings { - type_def: RefCell>, //< Meaning in type namespace. - value_def: RefCell>, //< Meaning in value namespace. + type_def: RefCell>, // < Meaning in type namespace. + value_def: RefCell>, // < Meaning in value namespace. } impl NameBindings { @@ -870,11 +958,7 @@ impl NameBindings { } else { DefModifiers::empty() } | DefModifiers::IMPORTABLE; - let module_ = Rc::new(Module::new(parent_link, - def_id, - kind, - external, - is_public)); + let module_ = Rc::new(Module::new(parent_link, def_id, kind, external, is_public)); let type_def = self.type_def.borrow().clone(); match type_def { None => { @@ -882,7 +966,7 @@ impl NameBindings { modifiers: modifiers, module_def: Some(module_), type_def: None, - type_span: Some(sp) + type_span: Some(sp), }); } Some(type_def) => { @@ -890,7 +974,7 @@ impl NameBindings { modifiers: modifiers, module_def: Some(module_), type_span: Some(sp), - type_def: type_def.type_def + type_def: type_def.type_def, }); } } @@ -912,11 +996,7 @@ impl NameBindings { let type_def = self.type_def.borrow().clone(); match type_def { None => { - let module = Module::new(parent_link, - def_id, - kind, - external, - is_public); + let module = Module::new(parent_link, def_id, kind, external, is_public); *self.type_def.borrow_mut() = Some(TypeNsDef { modifiers: modifiers, module_def: Some(Rc::new(module)), @@ -927,11 +1007,7 @@ impl NameBindings { Some(type_def) => { match type_def.module_def { None => { - let module = Module::new(parent_link, - def_id, - kind, - external, - is_public); + let module = Module::new(parent_link, def_id, kind, external, is_public); *self.type_def.borrow_mut() = Some(TypeNsDef { modifiers: modifiers, module_def: Some(Rc::new(module)), @@ -947,7 +1023,9 @@ impl NameBindings { /// Records a type definition. fn define_type(&self, def: Def, sp: Span, modifiers: DefModifiers) { - debug!("defining type for def {:?} with modifiers {:?}", def, modifiers); + debug!("defining type for def {:?} with modifiers {:?}", + def, + modifiers); // Merges the type with the existing type def or creates a new one. let type_def = self.type_def.borrow().clone(); match type_def { @@ -972,7 +1050,9 @@ impl NameBindings { /// Records a value definition. fn define_value(&self, def: Def, sp: Span, modifiers: DefModifiers) { - debug!("defining value for def {:?} with modifiers {:?}", def, modifiers); + debug!("defining value for def {:?} with modifiers {:?}", + def, + modifiers); *self.value_def.borrow_mut() = Some(ValueNsDef { def: def, value_span: Some(sp), @@ -984,7 +1064,7 @@ impl NameBindings { fn get_module_if_available(&self) -> Option> { match *self.type_def.borrow() { Some(ref type_def) => type_def.module_def.clone(), - None => None + None => None, } } @@ -993,17 +1073,16 @@ impl NameBindings { fn get_module(&self) -> Rc { match self.get_module_if_available() { None => { - panic!("get_module called on a node with no module \ - definition!") + panic!("get_module called on a node with no module definition!") } - Some(module_def) => module_def + Some(module_def) => module_def, } } fn defined_in_namespace(&self, namespace: Namespace) -> bool { match namespace { - TypeNS => return self.type_def.borrow().is_some(), - ValueNS => return self.value_def.borrow().is_some() + TypeNS => return self.type_def.borrow().is_some(), + ValueNS => return self.value_def.borrow().is_some(), } } @@ -1014,11 +1093,13 @@ impl NameBindings { fn defined_in_namespace_with(&self, namespace: Namespace, modifiers: DefModifiers) -> bool { match namespace { TypeNS => match *self.type_def.borrow() { - Some(ref def) => def.modifiers.contains(modifiers), None => false + Some(ref def) => def.modifiers.contains(modifiers), + None => false, }, ValueNS => match *self.value_def.borrow() { - Some(ref def) => def.modifiers.contains(modifiers), None => false - } + Some(ref def) => def.modifiers.contains(modifiers), + None => false, + }, } } @@ -1048,7 +1129,7 @@ impl NameBindings { ValueNS => { match *self.value_def.borrow() { None => None, - Some(value_def) => Some(value_def.def) + Some(value_def) => Some(value_def.def), } } } @@ -1057,16 +1138,16 @@ impl NameBindings { fn span_for_namespace(&self, namespace: Namespace) -> Option { if self.defined_in_namespace(namespace) { match namespace { - TypeNS => { + TypeNS => { match *self.type_def.borrow() { None => None, - Some(ref type_def) => type_def.type_span + Some(ref type_def) => type_def.type_span, } } ValueNS => { match *self.value_def.borrow() { None => None, - Some(ref value_def) => value_def.value_span + Some(ref value_def) => value_def.value_span, } } } @@ -1077,7 +1158,7 @@ impl NameBindings { fn is_public(&self, namespace: Namespace) -> bool { match namespace { - TypeNS => { + TypeNS => { let type_def = self.type_def.borrow(); type_def.as_ref().unwrap().modifiers.contains(DefModifiers::PUBLIC) } @@ -1096,25 +1177,23 @@ struct PrimitiveTypeTable { impl PrimitiveTypeTable { fn new() -> PrimitiveTypeTable { - let mut table = PrimitiveTypeTable { - primitive_types: HashMap::new() - }; + let mut table = PrimitiveTypeTable { primitive_types: HashMap::new() }; - table.intern("bool", TyBool); - table.intern("char", TyChar); - table.intern("f32", TyFloat(TyF32)); - table.intern("f64", TyFloat(TyF64)); - table.intern("isize", TyInt(TyIs)); - table.intern("i8", TyInt(TyI8)); - table.intern("i16", TyInt(TyI16)); - table.intern("i32", TyInt(TyI32)); - table.intern("i64", TyInt(TyI64)); - table.intern("str", TyStr); - table.intern("usize", TyUint(TyUs)); - table.intern("u8", TyUint(TyU8)); - table.intern("u16", TyUint(TyU16)); - table.intern("u32", TyUint(TyU32)); - table.intern("u64", TyUint(TyU64)); + table.intern("bool", TyBool); + table.intern("char", TyChar); + table.intern("f32", TyFloat(TyF32)); + table.intern("f64", TyFloat(TyF64)); + table.intern("isize", TyInt(TyIs)); + table.intern("i8", TyInt(TyI8)); + table.intern("i16", TyInt(TyI16)); + table.intern("i32", TyInt(TyI32)); + table.intern("i64", TyInt(TyI64)); + table.intern("str", TyStr); + table.intern("usize", TyUint(TyUs)); + table.intern("u8", TyUint(TyU8)); + table.intern("u16", TyUint(TyU16)); + table.intern("u32", TyUint(TyU32)); + table.intern("u64", TyUint(TyU64)); table } @@ -1125,7 +1204,7 @@ impl PrimitiveTypeTable { } /// The main resolver class. -pub struct Resolver<'a, 'tcx:'a> { +pub struct Resolver<'a, 'tcx: 'a> { session: &'a Session, ast_map: &'a hir_map::Map<'tcx>, @@ -1186,20 +1265,20 @@ pub struct Resolver<'a, 'tcx:'a> { // The intention is that the callback modifies this flag. // Once set, the resolver falls out of the walk, preserving the ribs. resolved: bool, - } #[derive(PartialEq)] enum FallbackChecks { Everything, - OnlyTraitAndStatics + OnlyTraitAndStatics, } impl<'a, 'tcx> Resolver<'a, 'tcx> { fn new(session: &'a Session, ast_map: &'a hir_map::Map<'tcx>, crate_span: Span, - make_glob_map: MakeGlobMap) -> Resolver<'a, 'tcx> { + make_glob_map: MakeGlobMap) + -> Resolver<'a, 'tcx> { let graph_root = NameBindings::new(); let root_def_id = ast_map.local_def_id(CRATE_NODE_ID); @@ -1219,7 +1298,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // The outermost module has def ID 0; this is not reflected in the // AST. - graph_root: graph_root, trait_item_map: FnvHashMap(), @@ -1252,7 +1330,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { callback: None, resolved: false, - } } @@ -1285,7 +1362,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { modifiers: DefModifiers::IMPORTABLE, module_def: Some(module), type_def: None, - type_span: None + type_span: None, })), value_def: RefCell::new(None), } @@ -1298,10 +1375,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { name: Name, span: Span) { if module.external_module_children.borrow().contains_key(&name) { - span_err!(self.session, span, E0259, - "an external crate named `{}` has already \ - been imported into this module", - name); + span_err!(self.session, + span, + E0259, + "an external crate named `{}` has already been imported into this module", + name); } } @@ -1311,11 +1389,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { name: Name, span: Span) { if module.external_module_children.borrow().contains_key(&name) { - span_err!(self.session, span, E0260, - "the name `{}` conflicts with an external \ - crate that has been imported into this \ - module", - name); + span_err!(self.session, + span, + E0260, + "the name `{}` conflicts with an external crate that has been imported \ + into this module", + name); } } @@ -1327,17 +1406,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { span: Span, name_search_type: NameSearchType, lp: LastPrivate) - -> ResolveResult<(Rc, LastPrivate)> { - fn search_parent_externals(needle: Name, module: &Rc) - -> Option> { + -> ResolveResult<(Rc, LastPrivate)> { + fn search_parent_externals(needle: Name, module: &Rc) -> Option> { match module.external_module_children.borrow().get(&needle) { Some(_) => Some(module.clone()), None => match module.parent_link { ModuleParentLink(ref parent, _) => { search_parent_externals(needle, &parent.upgrade().unwrap()) } - _ => None - } + _ => None, + }, } } @@ -1363,13 +1441,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = if "???" == &module_name[..] { span.hi = span.lo + Pos::from_usize(segment_name.len()); - match search_parent_externals(name, - &self.current_module) { + match search_parent_externals(name, &self.current_module) { Some(module) => { let path_str = names_to_string(module_path); let target_mod_str = module_to_string(&*module); - let current_mod_str = - module_to_string(&*self.current_module); + let current_mod_str = module_to_string(&*self.current_module); let prefix = if target_mod_str == current_mod_str { "self::".to_string() @@ -1378,23 +1454,20 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }; format!("Did you mean `{}{}`?", prefix, path_str) - }, - None => format!("Maybe a missing `extern crate {}`?", - segment_name), + } + None => format!("Maybe a missing `extern crate {}`?", segment_name), } } else { - format!("Could not find `{}` in `{}`", - segment_name, - module_name) + format!("Could not find `{}` in `{}`", segment_name, module_name) }; return Failed(Some((span, msg))); } Failed(err) => return Failed(err), Indeterminate => { - debug!("(resolving module path for import) module \ - resolution is indeterminate: {}", - name); + debug!("(resolving module path for import) module resolution is \ + indeterminate: {}", + name); return Indeterminate; } Success((target, used_proxy)) => { @@ -1404,8 +1477,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some(ref type_def) => { match type_def.module_def { None => { - let msg = format!("Not a module `{}`", - name); + let msg = format!("Not a module `{}`", name); return Failed(Some((span, msg))); } @@ -1430,8 +1502,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } None => { // There are no type bindings at all. - let msg = format!("Not a module `{}`", - name); + let msg = format!("Not a module `{}`", name); return Failed(Some((span, msg))); } } @@ -1464,8 +1535,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { module_to_string(&*module_)); // Resolve the module prefix, if any. - let module_prefix_result = self.resolve_module_prefix(module_.clone(), - module_path); + let module_prefix_result = self.resolve_module_prefix(module_.clone(), module_path); let search_module; let start_index; @@ -1477,21 +1547,20 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match mpath.rfind(':') { Some(idx) => { let msg = format!("Could not find `{}` in `{}`", - // idx +- 1 to account for the - // colons on either side - &mpath[idx + 1..], - &mpath[..idx - 1]); + // idx +- 1 to account for the + // colons on either side + &mpath[idx + 1..], + &mpath[..idx - 1]); return Failed(Some((span, msg))); - }, + } None => { - return Failed(None) + return Failed(None); } } } Failed(err) => return Failed(err), Indeterminate => { - debug!("(resolving module path for import) indeterminate; \ - bailing"); + debug!("(resolving module path for import) indeterminate; bailing"); return Indeterminate; } Success(NoPrefixFound) => { @@ -1510,12 +1579,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // This is not a crate-relative path. We resolve the // first component of the path in the current lexical // scope and then proceed to resolve below that. - match self.resolve_module_in_lexical_scope(module_, - module_path[0]) { + match self.resolve_module_in_lexical_scope(module_, module_path[0]) { Failed(err) => return Failed(err), Indeterminate => { - debug!("(resolving module path for import) \ - indeterminate; bailing"); + debug!("(resolving module path for import) indeterminate; bailing"); return Indeterminate; } Success(containing_module) => { @@ -1550,9 +1617,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { module_: Rc, name: Name, namespace: Namespace) - -> ResolveResult<(Target, bool)> { - debug!("(resolving item in lexical scope) resolving `{}` in \ - namespace {:?} in `{}`", + -> ResolveResult<(Target, bool)> { + debug!("(resolving item in lexical scope) resolving `{}` in namespace {:?} in `{}`", name, namespace, module_to_string(&*module_)); @@ -1562,15 +1628,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { build_reduced_graph::populate_module_if_necessary(self, &module_); match module_.children.borrow().get(&name) { - Some(name_bindings) - if name_bindings.defined_in_namespace(namespace) => { + Some(name_bindings) if name_bindings.defined_in_namespace(namespace) => { debug!("top name bindings succeeded"); return Success((Target::new(module_.clone(), name_bindings.clone(), Shadowable::Never), - false)); + false)); + } + Some(_) | None => { + // Not found; continue. } - Some(_) | None => { /* Not found; continue. */ } } // Now check for its import directives. We don't have to have resolved @@ -1581,19 +1648,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match (*import_resolution).target_for_namespace(namespace) { None => { // Not found; continue. - debug!("(resolving item in lexical scope) found \ - import resolution, but not in namespace {:?}", + debug!("(resolving item in lexical scope) found import resolution, but not \ + in namespace {:?}", namespace); } Some(target) => { - debug!("(resolving item in lexical scope) using \ - import resolution"); + debug!("(resolving item in lexical scope) using import resolution"); // track used imports and extern crates as well let id = import_resolution.id(namespace); self.used_imports.insert((id, namespace)); self.record_import_use(id, name); if let Some(DefId{krate: kid, ..}) = target.target_module.def_id.get() { - self.used_crates.insert(kid); + self.used_crates.insert(kid); } return Success((target, false)); } @@ -1605,12 +1671,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // FIXME (21114): In principle unclear `child` *has* to be lifted. let child = module_.external_module_children.borrow().get(&name).cloned(); if let Some(module) = child { - let name_bindings = - Rc::new(Resolver::create_name_bindings_from_module(module)); + let name_bindings = Rc::new(Resolver::create_name_bindings_from_module(module)); debug!("lower name bindings succeeded"); - return Success((Target::new(module_, - name_bindings, - Shadowable::Never), + return Success((Target::new(module_, name_bindings, Shadowable::Never), false)); } } @@ -1622,18 +1685,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match search_module.parent_link.clone() { NoParentLink => { // No more parents. This module was unresolved. - debug!("(resolving item in lexical scope) unresolved \ - module"); + debug!("(resolving item in lexical scope) unresolved module"); return Failed(None); } ModuleParentLink(parent_module_node, _) => { match search_module.kind.get() { NormalModuleKind => { // We stop the search here. - debug!("(resolving item in lexical \ - scope) unresolved module: not \ - searching through module \ - parents"); + debug!("(resolving item in lexical scope) unresolved module: not \ + searching through module parents"); return Failed(None); } TraitModuleKind | @@ -1657,20 +1717,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { true) { Failed(Some((span, msg))) => { resolve_error(self, span, ResolutionError::FailedToResolve(&*msg)); - }, + } Failed(None) => (), // Continue up the search chain. Indeterminate => { // We couldn't see through the higher scope because of an // unresolved import higher up. Bail. - debug!("(resolving item in lexical scope) indeterminate \ - higher scope; bailing"); + debug!("(resolving item in lexical scope) indeterminate higher scope; bailing"); return Indeterminate; } Success((target, used_reexport)) => { // We found the module. - debug!("(resolving item in lexical scope) found name \ - in module, done"); + debug!("(resolving item in lexical scope) found name in module, done"); return Success((target, used_reexport)); } } @@ -1681,7 +1739,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn resolve_module_in_lexical_scope(&mut self, module_: Rc, name: Name) - -> ResolveResult> { + -> ResolveResult> { // If this module is an anonymous module, resolve the item in the // lexical scope. Otherwise, resolve the item from the crate root. let resolve_result = self.resolve_item_in_lexical_scope(module_, name, TypeNS); @@ -1692,9 +1750,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some(ref type_def) => { match type_def.module_def { None => { - debug!("!!! (resolving module in lexical \ - scope) module wasn't actually a \ - module!"); + debug!("!!! (resolving module in lexical scope) module wasn't \ + actually a module!"); return Failed(None); } Some(ref module_def) => { @@ -1704,14 +1761,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } None => { debug!("!!! (resolving module in lexical scope) module + \ wasn't actually a module!"); return Failed(None); } } } Indeterminate => { - debug!("(resolving module in lexical scope) indeterminate; \ - bailing"); + debug!("(resolving module in lexical scope) indeterminate; bailing"); return Indeterminate; } Failed(err) => { @@ -1722,8 +1779,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } /// Returns the nearest normal module parent of the given module. - fn get_nearest_normal_module_parent(&mut self, module_: Rc) - -> Option> { + fn get_nearest_normal_module_parent(&mut self, module_: Rc) -> Option> { let mut module_ = module_; loop { match module_.parent_link.clone() { @@ -1745,8 +1801,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { /// Returns the nearest normal module parent of the given module, or the /// module itself if it is a normal module. - fn get_nearest_normal_module_parent_or_self(&mut self, module_: Rc) - -> Rc { + fn get_nearest_normal_module_parent_or_self(&mut self, module_: Rc) -> Rc { match module_.kind.get() { NormalModuleKind => return module_, TraitModuleKind | @@ -1755,7 +1810,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { AnonymousModuleKind => { match self.get_nearest_normal_module_parent(module_.clone()) { None => module_, - Some(new_module) => new_module + Some(new_module) => new_module, } } } @@ -1767,7 +1822,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn resolve_module_prefix(&mut self, module_: Rc, module_path: &[Name]) - -> ResolveResult { + -> ResolveResult { // Start at the current module if we see `self` or `super`, or at the // top of the crate otherwise. let mut i = match &*module_path[0].as_str() { @@ -1817,13 +1872,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { build_reduced_graph::populate_module_if_necessary(self, &module_); match module_.children.borrow().get(&name) { - Some(name_bindings) - if name_bindings.defined_in_namespace(namespace) => { + Some(name_bindings) if name_bindings.defined_in_namespace(namespace) => { debug!("(resolving name in module) found node as child"); return Success((Target::new(module_.clone(), name_bindings.clone(), Shadowable::Never), - false)); + false)); } Some(_) | None => { // Continue. @@ -1840,24 +1894,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Check the list of resolved imports. match module_.import_resolutions.borrow().get(&name) { - Some(import_resolution) if allow_private_imports || - import_resolution.is_public => { + Some(import_resolution) if allow_private_imports || import_resolution.is_public => { - if import_resolution.is_public && - import_resolution.outstanding_references != 0 { - debug!("(resolving name in module) import \ - unresolved; bailing out"); + if import_resolution.is_public && import_resolution.outstanding_references != 0 { + debug!("(resolving name in module) import unresolved; bailing out"); return Indeterminate; } match import_resolution.target_for_namespace(namespace) { None => { - debug!("(resolving name in module) name found, \ - but not in namespace {:?}", + debug!("(resolving name in module) name found, but not in namespace {:?}", namespace); } Some(target) => { - debug!("(resolving name in module) resolved to \ - import"); + debug!("(resolving name in module) resolved to import"); // track used imports and extern crates as well let id = import_resolution.id(namespace); self.used_imports.insert((id, namespace)); @@ -1877,18 +1926,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // FIXME (21114): In principle unclear `child` *has* to be lifted. let child = module_.external_module_children.borrow().get(&name).cloned(); if let Some(module) = child { - let name_bindings = - Rc::new(Resolver::create_name_bindings_from_module(module)); - return Success((Target::new(module_, - name_bindings, - Shadowable::Never), + let name_bindings = Rc::new(Resolver::create_name_bindings_from_module(module)); + return Success((Target::new(module_, name_bindings, Shadowable::Never), false)); } } // We're out of luck. - debug!("(resolving name in module) failed to resolve `{}`", - name); + debug!("(resolving name in module) failed to resolve `{}`", name); return Failed(None); } @@ -1939,8 +1984,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // generate a fake "implementation scope" containing all the // implementations thus found, for compatibility with old resolve pass. - fn with_scope(&mut self, name: Option, f: F) where - F: FnOnce(&mut Resolver), + fn with_scope(&mut self, name: Option, f: F) + where F: FnOnce(&mut Resolver) { let orig_module = self.current_module.clone(); @@ -1961,8 +2006,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some(name_bindings) => { match (*name_bindings).get_module_if_available() { None => { - debug!("!!! (with scope) didn't find module \ - for `{}` in `{}`", + debug!("!!! (with scope) didn't find module for `{}` in `{}`", name, module_to_string(&*orig_module)); } @@ -1990,12 +2034,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } _ => { // Do not resolve labels across function boundary - return None + return None; } } let result = rib.bindings.get(&name).cloned(); if result.is_some() { - return result + return result; } } None @@ -2009,16 +2053,17 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn check_if_primitive_type_name(&self, name: Name, span: Span) { if let Some(_) = self.primitive_type_table.primitive_types.get(&name) { - span_err!(self.session, span, E0317, - "user-defined types or type parameters cannot shadow the primitive types"); + span_err!(self.session, + span, + E0317, + "user-defined types or type parameters cannot shadow the primitive types"); } } fn resolve_item(&mut self, item: &Item) { let name = item.name; - debug!("(resolving item) resolving {}", - name); + debug!("(resolving item) resolving {}", name); match item.node { ItemEnum(_, ref generics) | @@ -2026,27 +2071,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ItemStruct(_, ref generics) => { self.check_if_primitive_type_name(name, item.span); - self.with_type_parameter_rib(HasTypeParameters(generics, - TypeSpace, - ItemRibKind), + self.with_type_parameter_rib(HasTypeParameters(generics, TypeSpace, ItemRibKind), |this| visit::walk_item(this, item)); } ItemFn(_, _, _, _, ref generics, _) => { - self.with_type_parameter_rib(HasTypeParameters(generics, - FnSpace, - ItemRibKind), + self.with_type_parameter_rib(HasTypeParameters(generics, FnSpace, ItemRibKind), |this| visit::walk_item(this, item)); } ItemDefaultImpl(_, ref trait_ref) => { self.with_optional_trait_ref(Some(trait_ref), |_, _| {}); } - ItemImpl(_, - _, - ref generics, - ref opt_trait_ref, - ref self_type, - ref impl_items) => { + ItemImpl(_, _, ref generics, ref opt_trait_ref, ref self_type, ref impl_items) => { self.resolve_implementation(generics, opt_trait_ref, &**self_type, @@ -2142,8 +2178,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match self.resolve_crate_relative_path(prefix.span, &prefix.segments, TypeNS) { - Some((def, lp)) => self.record_def(item.id, - PathResolution::new(def, lp, 0)), + Some((def, lp)) => + self.record_def(item.id, PathResolution::new(def, lp, 0)), None => { resolve_error(self, prefix.span, @@ -2163,8 +2199,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - fn with_type_parameter_rib(&mut self, type_parameters: TypeParameters, f: F) where - F: FnOnce(&mut Resolver), + fn with_type_parameter_rib(&mut self, type_parameters: TypeParameters, f: F) + where F: FnOnce(&mut Resolver) { match type_parameters { HasTypeParameters(generics, space, rib_kind) => { @@ -2177,18 +2213,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if seen_bindings.contains(&name) { resolve_error(self, type_parameter.span, - ResolutionError::NameAlreadyUsedInTypeParameterList( - name) - ); + ResolutionError::NameAlreadyUsedInTypeParameterList(name)); } seen_bindings.insert(name); // plain insert (no renaming) - function_type_rib.bindings.insert(name, - DlDef(DefTyParam(space, - index as u32, - self.ast_map.local_def_id(type_parameter.id), - name))); + function_type_rib.bindings + .insert(name, + DlDef(DefTyParam(space, + index as u32, + self.ast_map + .local_def_id(type_parameter.id), + name))); } self.type_ribs.push(function_type_rib); } @@ -2201,13 +2237,17 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { f(self); match type_parameters { - HasTypeParameters(..) => { if !self.resolved { self.type_ribs.pop(); } } - NoTypeParameters => { } + HasTypeParameters(..) => { + if !self.resolved { + self.type_ribs.pop(); + } + } + NoTypeParameters => {} } } - fn with_label_rib(&mut self, f: F) where - F: FnOnce(&mut Resolver), + fn with_label_rib(&mut self, f: F) + where F: FnOnce(&mut Resolver) { self.label_ribs.push(Rib::new(NormalRibKind)); f(self); @@ -2216,8 +2256,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - fn with_constant_rib(&mut self, f: F) where - F: FnOnce(&mut Resolver), + fn with_constant_rib(&mut self, f: F) + where F: FnOnce(&mut Resolver) { self.value_ribs.push(Rib::new(ConstantItemRibKind)); self.type_ribs.push(Rib::new(ConstantItemRibKind)); @@ -2228,10 +2268,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - fn resolve_function(&mut self, - rib_kind: RibKind, - declaration: &FnDecl, - block: &Block) { + fn resolve_function(&mut self, rib_kind: RibKind, declaration: &FnDecl, block: &Block) { // Create a value rib for the function. self.value_ribs.push(Rib::new(rib_kind)); @@ -2241,9 +2278,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Add each argument to the rib. let mut bindings_list = HashMap::new(); for argument in &declaration.inputs { - self.resolve_pattern(&*argument.pat, - ArgumentIrrefutableMode, - &mut bindings_list); + self.resolve_pattern(&*argument.pat, ArgumentIrrefutableMode, &mut bindings_list); self.visit_ty(&*argument.ty); @@ -2275,22 +2310,20 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { resolve_error(self, trait_path.span, ResolutionError::IsNotATrait(&*path_names_to_string(trait_path, - path_depth)) - ); + path_depth))); // If it's a typedef, give a note if let DefTy(..) = path_res.base_def { - self.session.span_note(trait_path.span, - "`type` aliases cannot be used for traits"); + self.session + .span_note(trait_path.span, "`type` aliases cannot be used for traits"); } Err(()) } } else { resolve_error(self, trait_path.span, - ResolutionError::UndeclaredTraitName( - &*path_names_to_string(trait_path, path_depth)) - ); + ResolutionError::UndeclaredTraitName(&*path_names_to_string(trait_path, + path_depth))); Err(()) } } @@ -2328,17 +2361,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { result } - fn with_optional_trait_ref(&mut self, - opt_trait_ref: Option<&TraitRef>, - f: F) - -> T + fn with_optional_trait_ref(&mut self, opt_trait_ref: Option<&TraitRef>, f: F) -> T where F: FnOnce(&mut Resolver, Option) -> T { let mut new_val = None; let mut new_id = None; if let Some(trait_ref) = opt_trait_ref { if let Ok(path_res) = self.resolve_trait_reference(trait_ref.ref_id, - &trait_ref.path, 0) { + &trait_ref.path, + 0) { assert!(path_res.depth == 0); self.record_def(trait_ref.ref_id, path_res); new_val = Some((path_res.base_def.def_id(), trait_ref.clone())); @@ -2435,14 +2466,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn check_trait_item(&self, name: Name, span: Span, err: F) - where F: FnOnce(Name, &str) -> ResolutionError { - // If there is a TraitRef in scope for an impl, then the method must be in the trait. + where F: FnOnce(Name, &str) -> ResolutionError + { + // If there is a TraitRef in scope for an impl, then the method must be in the + // trait. if let Some((did, ref trait_ref)) = self.current_trait_ref { if !self.trait_item_map.contains_key(&(name, did)) { let path_str = path_names_to_string(&trait_ref.path, 0); - resolve_error(self, - span, - err(name, &*path_str)); + resolve_error(self, span, err(name, &*path_str)); } } } @@ -2455,9 +2486,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { walk_list!(self, visit_expr, &local.init); // Resolve the pattern. - self.resolve_pattern(&*local.pat, - LocalIrrefutableMode, - &mut HashMap::new()); + self.resolve_pattern(&*local.pat, LocalIrrefutableMode, &mut HashMap::new()); } // build a map from pattern identifiers to binding-info's. @@ -2468,10 +2497,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let mut result = HashMap::new(); pat_bindings_hygienic(&self.def_map, pat, |binding_mode, _id, sp, path1| { let name = mtwt::resolve(path1.node); - result.insert(name, BindingInfo { - span: sp, - binding_mode: binding_mode - }); + result.insert(name, + BindingInfo { + span: sp, + binding_mode: binding_mode, + }); }); return result; } @@ -2480,7 +2510,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // same set of bindings, with the same binding modes for each. fn check_consistent_bindings(&mut self, arm: &Arm) { if arm.pats.is_empty() { - return + return; } let map_0 = self.binding_mode_map(&*arm.pats[0]); for (i, p) in arm.pats.iter().enumerate() { @@ -2488,21 +2518,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (&key, &binding_0) in &map_0 { match map_i.get(&key) { - None => { - resolve_error(self, - p.span, - ResolutionError::VariableNotBoundInPattern(key, - i + 1)); - } - Some(binding_i) => { - if binding_0.binding_mode != binding_i.binding_mode { + None => { resolve_error(self, - binding_i.span, - ResolutionError::VariableBoundWithDifferentMode(key, - i + 1) - ); + p.span, + ResolutionError::VariableNotBoundInPattern(key, i + 1)); + } + Some(binding_i) => { + if binding_0.binding_mode != binding_i.binding_mode { + resolve_error(self, + binding_i.span, + ResolutionError::VariableBoundWithDifferentMode(key, + i + 1)); + } } - } } } @@ -2510,8 +2538,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if !map_0.contains_key(&key) { resolve_error(self, binding.span, - ResolutionError::VariableNotBoundInParentPattern(key, - i + 1)); + ResolutionError::VariableNotBoundInParentPattern(key, i + 1)); } } } @@ -2544,10 +2571,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Move down in the graph, if there's an anonymous module rooted here. let orig_module = self.current_module.clone(); match orig_module.anonymous_children.borrow().get(&block.id) { - None => { /* Nothing to do. */ } + None => { + // Nothing to do. + } Some(anonymous_module) => { - debug!("(resolving block) found anonymous module, moving \ - down"); + debug!("(resolving block) found anonymous module, moving down"); self.current_module = anonymous_module.clone(); } } @@ -2559,8 +2587,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if let hir::DeclItem(ref i) = declaration.node { match i.node { ItemExternCrate(_) | ItemUse(_) if found_non_item => { - span_err!(self.session, i.span, E0154, - "imports are not allowed after non-item statements"); + span_err!(self.session, + i.span, + E0154, + "imports are not allowed after non-item statements"); } _ => {} } @@ -2586,30 +2616,29 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn resolve_type(&mut self, ty: &Ty) { match ty.node { TyPath(ref maybe_qself, ref path) => { - let resolution = - match self.resolve_possibly_assoc_item(ty.id, - maybe_qself.as_ref(), - path, - TypeNS, - true) { - // `::a::b::c` is resolved by typeck alone. - TypecheckRequired => { - // Resolve embedded types. - visit::walk_ty(self, ty); - return; - } - ResolveAttempt(resolution) => resolution, - }; + let resolution = match self.resolve_possibly_assoc_item(ty.id, + maybe_qself.as_ref(), + path, + TypeNS, + true) { + // `::a::b::c` is resolved by typeck alone. + TypecheckRequired => { + // Resolve embedded types. + visit::walk_ty(self, ty); + return; + } + ResolveAttempt(resolution) => resolution, + }; // This is a path in the type namespace. Walk through scopes // looking for it. match resolution { Some(def) => { // Write the result into the def map. - debug!("(resolving type) writing resolution for `{}` \ - (id {}) = {:?}", + debug!("(resolving type) writing resolution for `{}` (id {}) = {:?}", path_names_to_string(path, 0), - ty.id, def); + ty.id, + def); self.record_def(ty.id, def); } None => { @@ -2623,10 +2652,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }; let self_type_name = special_idents::type_self.name; - let is_invalid_self_type_name = - path.segments.len() > 0 && - maybe_qself.is_none() && - path.segments[0].identifier.name == self_type_name; + let is_invalid_self_type_name = path.segments.len() > 0 && + maybe_qself.is_none() && + path.segments[0].identifier.name == + self_type_name; if is_invalid_self_type_name { resolve_error(self, ty.span, @@ -2674,19 +2703,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match self.resolve_bare_identifier_pattern(ident.name, pattern.span) { FoundStructOrEnumVariant(def, lp) if const_ok => { - debug!("(resolving pattern) resolving `{}` to \ - struct or enum variant", + debug!("(resolving pattern) resolving `{}` to struct or enum variant", renamed); - self.enforce_default_binding_mode( - pattern, - binding_mode, - "an enum variant"); - self.record_def(pattern.id, PathResolution { - base_def: def, - last_private: lp, - depth: 0 - }); + self.enforce_default_binding_mode(pattern, + binding_mode, + "an enum variant"); + self.record_def(pattern.id, + PathResolution { + base_def: def, + last_private: lp, + depth: 0, + }); } FoundStructOrEnumVariant(..) => { resolve_error( @@ -2697,19 +2725,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ); } FoundConst(def, lp, _) if const_ok => { - debug!("(resolving pattern) resolving `{}` to \ - constant", - renamed); + debug!("(resolving pattern) resolving `{}` to constant", renamed); - self.enforce_default_binding_mode( - pattern, - binding_mode, - "a constant"); - self.record_def(pattern.id, PathResolution { - base_def: def, - last_private: lp, - depth: 0 - }); + self.enforce_default_binding_mode(pattern, binding_mode, "a constant"); + self.record_def(pattern.id, + PathResolution { + base_def: def, + last_private: lp, + depth: 0, + }); } FoundConst(def, _, name) => { resolve_error( @@ -2720,8 +2744,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ); } BareIdentifierPatternUnresolved => { - debug!("(resolving pattern) binding `{}`", - renamed); + debug!("(resolving pattern) binding `{}`", renamed); let def_id = self.ast_map.local_def_id(pattern.id); let def = DefLocal(def_id, pattern.id); @@ -2730,11 +2753,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // will be able to distinguish variants from // locals in patterns. - self.record_def(pattern.id, PathResolution { - base_def: def, - last_private: LastMod(AllPublic), - depth: 0 - }); + self.record_def(pattern.id, + PathResolution { + base_def: def, + last_private: LastMod(AllPublic), + depth: 0, + }); // Add the binding to the local ribs, if it // doesn't already exist in the bindings list. (We @@ -2747,7 +2771,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { last_rib.bindings.insert(renamed, DlDef(def)); bindings_list.insert(renamed, pat_id); } else if mode == ArgumentIrrefutableMode && - bindings_list.contains_key(&renamed) { + bindings_list.contains_key(&renamed) { // Forbid duplicate bindings in the same // parameter list. resolve_error( @@ -2756,8 +2780,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ResolutionError::IdentifierBoundMoreThanOnceInParameterList( &ident.name.as_str()) ); - } else if bindings_list.get(&renamed) == - Some(&pat_id) { + } else if bindings_list.get(&renamed) == Some(&pat_id) { // Then this is a duplicate variable in the // same disjunction, which is an error. resolve_error( @@ -2775,21 +2798,24 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { PatEnum(ref path, _) => { // This must be an enum variant, struct or const. - let resolution = - match self.resolve_possibly_assoc_item(pat_id, None, - path, ValueNS, - false) { - // The below shouldn't happen because all - // qualified paths should be in PatQPath. - TypecheckRequired => - self.session.span_bug( - path.span, - "resolve_possibly_assoc_item claimed - that a path in PatEnum requires typecheck - to resolve, but qualified paths should be - PatQPath"), - ResolveAttempt(resolution) => resolution, - }; + let resolution = match self.resolve_possibly_assoc_item(pat_id, + None, + path, + ValueNS, + false) { + // The below shouldn't happen because all + // qualified paths should be in PatQPath. + TypecheckRequired => + self.session.span_bug(path.span, + "resolve_possibly_assoc_item claimed + \ + that a path in PatEnum requires typecheck + \ + to resolve, but qualified paths should be + \ + PatQPath"), + ResolveAttempt(resolution) => resolution, + }; if let Some(path_res) = resolution { match path_res.base_def { DefVariant(..) | DefStruct(..) | DefConst(..) => { @@ -2818,8 +2844,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { .as_str()) ); } else { - let const_name = path.segments.last().unwrap() - .identifier.name; + let const_name = path.segments + .last() + .unwrap() + .identifier + .name; let traits = self.get_traits_containing_item(const_name); self.trait_map.insert(pattern.id, traits); self.record_def(pattern.id, path_res); @@ -2839,23 +2868,27 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { PatQPath(ref qself, ref path) => { // Associated constants only. - let resolution = - match self.resolve_possibly_assoc_item(pat_id, Some(qself), - path, ValueNS, - false) { - TypecheckRequired => { - // All `::CONST` should end up here, and will - // require use of the trait map to resolve - // during typechecking. - let const_name = path.segments.last().unwrap() - .identifier.name; - let traits = self.get_traits_containing_item(const_name); - self.trait_map.insert(pattern.id, traits); - visit::walk_pat(self, pattern); - return true; - } - ResolveAttempt(resolution) => resolution, - }; + let resolution = match self.resolve_possibly_assoc_item(pat_id, + Some(qself), + path, + ValueNS, + false) { + TypecheckRequired => { + // All `::CONST` should end up here, and will + // require use of the trait map to resolve + // during typechecking. + let const_name = path.segments + .last() + .unwrap() + .identifier + .name; + let traits = self.get_traits_containing_item(const_name); + self.trait_map.insert(pattern.id, traits); + visit::walk_pat(self, pattern); + return true; + } + ResolveAttempt(resolution) => resolution, + }; if let Some(path_res) = resolution { match path_res.base_def { // All `::CONST` should end up here, and @@ -2874,13 +2907,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } } else { - resolve_error( - self, - path.span, - ResolutionError::UnresolvedAssociatedConst( - &path.segments.last().unwrap().identifier.name.as_str() - ) - ); + resolve_error(self, + path.span, + ResolutionError::UnresolvedAssociatedConst(&path.segments + .last() + .unwrap() + .identifier + .name + .as_str())); } visit::walk_pat(self, pattern); } @@ -2891,8 +2925,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.record_def(pattern.id, definition); } result => { - debug!("(resolving pattern) didn't find struct \ - def: {:?}", result); + debug!("(resolving pattern) didn't find struct def: {:?}", result); resolve_error( self, path.span, @@ -2916,21 +2949,20 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }); } - fn resolve_bare_identifier_pattern(&mut self, name: Name, span: Span) + fn resolve_bare_identifier_pattern(&mut self, + name: Name, + span: Span) -> BareIdentifierPatternResolution { let module = self.current_module.clone(); - match self.resolve_item_in_lexical_scope(module, - name, - ValueNS) { + match self.resolve_item_in_lexical_scope(module, name, ValueNS) { Success((target, _)) => { - debug!("(resolve bare identifier pattern) succeeded in \ - finding {} at {:?}", - name, - target.bindings.value_def.borrow()); + debug!("(resolve bare identifier pattern) succeeded in finding {} at {:?}", + name, + target.bindings.value_def.borrow()); match *target.bindings.value_def.borrow() { None => { - panic!("resolved name in the value namespace to a \ - set of name bindings with no def?!"); + panic!("resolved name in the value namespace to a set of name bindings \ + with no def?!"); } Some(def) => { // For the two success cases, this lookup can be @@ -2944,9 +2976,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { return FoundConst(def, LastMod(AllPublic), name); } DefStatic(..) => { - resolve_error(self, - span, - ResolutionError::StaticVariableReference); + resolve_error(self, span, ResolutionError::StaticVariableReference); return BareIdentifierPatternUnresolved; } _ => { @@ -2965,11 +2995,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some((span, msg)) => { resolve_error(self, span, ResolutionError::FailedToResolve(&*msg)); } - None => () + None => (), } - debug!("(resolve bare identifier pattern) failed to find {}", - name); + debug!("(resolve bare identifier pattern) failed to find {}", name); return BareIdentifierPatternUnresolved; } } @@ -2982,8 +3011,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { path: &Path, namespace: Namespace, check_ribs: bool) - -> AssocItemResolveResult - { + -> AssocItemResolveResult { let max_assoc_types; match maybe_qself { @@ -3008,8 +3036,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { break; } self.with_no_errors(|this| { - resolution = this.resolve_path(id, path, depth, - TypeNS, true); + resolution = this.resolve_path(id, path, depth, TypeNS, true); }); } if let Some(DefMod(_)) = resolution.map(|r| r.base_def) { @@ -3028,9 +3055,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { path: &Path, path_depth: usize, namespace: Namespace, - check_ribs: bool) -> Option { + check_ribs: bool) + -> Option { let span = path.span; - let segments = &path.segments[..path.segments.len()-path_depth]; + let segments = &path.segments[..path.segments.len() - path_depth]; let mk_res = |(def, lp)| PathResolution::new(def, lp, path_depth); @@ -3040,16 +3068,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } // Try to find a path to an item in a module. - let unqualified_def = self.resolve_identifier( - segments.last().unwrap().identifier, - namespace, check_ribs); + let unqualified_def = self.resolve_identifier(segments.last().unwrap().identifier, + namespace, + check_ribs); if segments.len() <= 1 { - return unqualified_def - .and_then(|def| self.adjust_local_def(def, span)) - .map(|def| { - PathResolution::new(def, LastMod(AllPublic), path_depth) - }); + return unqualified_def.and_then(|def| self.adjust_local_def(def, span)) + .map(|def| { + PathResolution::new(def, LastMod(AllPublic), path_depth) + }); } let def = self.resolve_module_relative_path(span, segments, namespace); @@ -3057,7 +3084,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { (Some((ref d, _)), Some(ref ud)) if *d == ud.def => { self.session .add_lint(lint::builtin::UNUSED_QUALIFICATIONS, - id, span, + id, + span, "unnecessary qualification".to_string()); } _ => {} @@ -3082,8 +3110,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } if check_ribs { - if let Some(def) = self.resolve_identifier_in_local_ribs(identifier, - namespace) { + if let Some(def) = self.resolve_identifier_in_local_ribs(identifier, namespace) { return Some(def); } } @@ -3095,15 +3122,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Resolve a local definition, potentially adjusting for closures. fn adjust_local_def(&mut self, local_def: LocalDef, span: Span) -> Option { let ribs = match local_def.ribs { - Some((TypeNS, i)) => &self.type_ribs[i+1..], - Some((ValueNS, i)) => &self.value_ribs[i+1..], - _ => &[] as &[_] + Some((TypeNS, i)) => &self.type_ribs[i + 1..], + Some((ValueNS, i)) => &self.value_ribs[i + 1..], + _ => &[] as &[_], }; let mut def = local_def.def; match def { DefUpvar(..) => { - self.session.span_bug(span, - &format!("unexpected {:?} in bindings", def)) + self.session.span_bug(span, &format!("unexpected {:?} in bindings", def)) } DefLocal(_, node_id) => { for rib in ribs { @@ -3115,16 +3141,21 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let prev_def = def; let node_def_id = self.ast_map.local_def_id(node_id); - let seen = self.freevars_seen.entry(function_id) - .or_insert_with(|| NodeMap()); + let seen = self.freevars_seen + .entry(function_id) + .or_insert_with(|| NodeMap()); if let Some(&index) = seen.get(&node_id) { def = DefUpvar(node_def_id, node_id, index, function_id); continue; } - let vec = self.freevars.entry(function_id) - .or_insert_with(|| vec![]); + let vec = self.freevars + .entry(function_id) + .or_insert_with(|| vec![]); let depth = vec.len(); - vec.push(Freevar { def: prev_def, span: span }); + vec.push(Freevar { + def: prev_def, + span: span, + }); def = DefUpvar(node_def_id, node_id, depth, function_id); seen.insert(node_id, depth); @@ -3133,20 +3164,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // This was an attempt to access an upvar inside a // named function item. This is not allowed, so we // report an error. - resolve_error( - self, - span, - ResolutionError::CannotCaptureDynamicEnvironmentInFnItem - ); + resolve_error(self, + span, + ResolutionError::CannotCaptureDynamicEnvironmentInFnItem); return None; } ConstantItemRibKind => { // Still doesn't deal with upvars - resolve_error( - self, - span, - ResolutionError::AttemptToUseNonConstantValueInConstant - ); + resolve_error(self, + span, + ResolutionError::AttemptToUseNonConstantValueInConstant); return None; } } @@ -3195,7 +3222,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some(def) => { // Found it. Stop the search here. let p = child_name_bindings.defined_in_public_namespace(namespace); - let lp = if p {LastMod(AllPublic)} else { + let lp = if p { + LastMod(AllPublic) + } else { LastMod(DependsOn(def.def_id())) }; return ChildNameDefinition(def, lp); @@ -3220,7 +3249,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match target.target_module.def_id.get() { Some(DefId{krate: kid, ..}) => { self.used_crates.insert(kid); - }, + } _ => {} } return ImportNameDefinition(def, LastMod(AllPublic)); @@ -3237,12 +3266,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Finally, search through external children. if namespace == TypeNS { - if let Some(module) = containing_module.external_module_children.borrow() - .get(&name).cloned() { + if let Some(module) = containing_module.external_module_children + .borrow() + .get(&name) + .cloned() { if let Some(def_id) = module.def_id.get() { // track used crates self.used_crates.insert(def_id.krate); - let lp = if module.is_public {LastMod(AllPublic)} else { + let lp = if module.is_public { + LastMod(AllPublic) + } else { LastMod(DependsOn(def_id)) }; return ChildNameDefinition(DefMod(def_id), lp); @@ -3259,9 +3292,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { segments: &[hir::PathSegment], namespace: Namespace) -> Option<(Def, LastPrivate)> { - let module_path = segments.split_last().unwrap().1.iter() - .map(|ps| ps.identifier.name) - .collect::>(); + let module_path = segments.split_last() + .unwrap() + .1 + .iter() + .map(|ps| ps.identifier.name) + .collect::>(); let containing_module; let last_private; @@ -3315,10 +3351,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { span: Span, segments: &[hir::PathSegment], namespace: Namespace) - -> Option<(Def, LastPrivate)> { - let module_path = segments.split_last().unwrap().1.iter() - .map(|ps| ps.identifier.name) - .collect::>(); + -> Option<(Def, LastPrivate)> { + let module_path = segments.split_last() + .unwrap() + .1 + .iter() + .map(|ps| ps.identifier.name) + .collect::>(); let root_module = self.graph_root.get_module(); @@ -3355,9 +3394,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } let name = segments.last().unwrap().identifier.name; - match self.resolve_definition_of_name_in_module(containing_module, - name, - namespace) { + match self.resolve_definition_of_name_in_module(containing_module, name, namespace) { NoNameDefinition => { // We failed to resolve the name. Report an error. return None; @@ -3375,7 +3412,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Check the local set of ribs. let (name, ribs) = match namespace { ValueNS => (mtwt::resolve(ident), &self.value_ribs), - TypeNS => (ident.name, &self.type_ribs) + TypeNS => (ident.name, &self.type_ribs), }; for (i, rib) in ribs.iter().enumerate().rev() { @@ -3383,15 +3420,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match def_like { DlDef(def) => { debug!("(resolving path in local ribs) resolved `{}` to {:?} at {}", - name, def, i); + name, + def, + i); return Some(LocalDef { ribs: Some((namespace, i)), - def: def + def: def, }); } def_like => { debug!("(resolving path in local ribs) resolved `{}` to pseudo-def {:?}", - name, def_like); + name, + def_like); return None; } } @@ -3404,25 +3444,22 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn resolve_item_by_name_in_lexical_scope(&mut self, name: Name, namespace: Namespace) - -> Option { + -> Option { // Check the items. let module = self.current_module.clone(); - match self.resolve_item_in_lexical_scope(module, - name, - namespace) { + match self.resolve_item_in_lexical_scope(module, name, namespace) { Success((target, _)) => { match (*target.bindings).def_for_namespace(namespace) { None => { // This can happen if we were looking for a type and // found a module instead. Modules don't have defs. - debug!("(resolving item path by identifier in lexical \ - scope) failed to resolve {} after success...", - name); + debug!("(resolving item path by identifier in lexical scope) failed to \ + resolve {} after success...", + name); None } Some(def) => { - debug!("(resolving item path in lexical scope) \ - resolved `{}` to item", + debug!("(resolving item path in lexical scope) resolved `{}` to item", name); // This lookup is "all public" because it only searched // for one identifier in the current module (couldn't @@ -3435,8 +3472,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { panic!("unexpected indeterminate result"); } Failed(err) => { - debug!("(resolving item path by identifier in lexical scope) \ - failed to resolve {}", name); + debug!("(resolving item path by identifier in lexical scope) failed to resolve {}", + name); if let Some((span, msg)) = err { resolve_error(self, span, ResolutionError::FailedToResolve(&*msg)) @@ -3447,8 +3484,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - fn with_no_errors(&mut self, f: F) -> T where - F: FnOnce(&mut Resolver) -> T, + fn with_no_errors(&mut self, f: F) -> T + where F: FnOnce(&mut Resolver) -> T { self.emit_errors = false; let rs = f(self); @@ -3457,8 +3494,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn find_fallback_in_self_type(&mut self, name: Name) -> FallbackSuggestion { - fn extract_path_and_node_id(t: &Ty, allow: FallbackChecks) - -> Option<(Path, NodeId, FallbackChecks)> { + fn extract_path_and_node_id(t: &Ty, + allow: FallbackChecks) + -> Option<(Path, NodeId, FallbackChecks)> { match t.node { TyPath(None, ref path) => Some((path.clone(), t.id, allow)), TyPtr(ref mut_ty) => extract_path_and_node_id(&*mut_ty.ty, OnlyTraitAndStatics), @@ -3470,8 +3508,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - fn get_module(this: &mut Resolver, span: Span, name_path: &[ast::Name]) - -> Option> { + fn get_module(this: &mut Resolver, + span: Span, + name_path: &[ast::Name]) + -> Option> { let root = this.current_module.clone(); let last_name = name_path.last().unwrap(); @@ -3481,7 +3521,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { match this.current_module.children.borrow().get(last_name) { Some(child) => child.get_module_if_available(), - None => None + None => None, } } } @@ -3492,7 +3532,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { span, PathSearch) { Success((module, _)) => Some(module), - _ => None + _ => None, } } } @@ -3502,13 +3542,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let sig = match this.ast_map.get(node_id) { hir_map::NodeTraitItem(trait_item) => match trait_item.node { hir::MethodTraitItem(ref sig, _) => sig, - _ => return false + _ => return false, }, hir_map::NodeImplItem(impl_item) => match impl_item.node { hir::MethodImplItem(ref sig, _) => sig, - _ => return false + _ => return false, }, - _ => return false + _ => return false, }; sig.explicit_self.node == hir::SelfStatic } else { @@ -3548,7 +3588,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if let Some(binding) = module.children.borrow().get(&name) { if let Some(DefMethod(did)) = binding.def_for_namespace(ValueNS) { if is_static_method(self, did) { - return StaticMethod(path_names_to_string(&path, 0)) + return StaticMethod(path_names_to_string(&path, 0)); } if self.current_trait_ref.is_some() { return TraitItem; @@ -3598,9 +3638,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // the typo'd name's length. let max_distance = std::cmp::max(name.len(), 3) / 3; - if !values.is_empty() && - values[smallest] <= max_distance && - name != &maybes[smallest][..] { + if !values.is_empty() && values[smallest] <= max_distance && name != &maybes[smallest][..] { Some(maybes[smallest].to_string()) @@ -3618,22 +3656,21 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Next, resolve the node. match expr.node { ExprPath(ref maybe_qself, ref path) => { - let resolution = - match self.resolve_possibly_assoc_item(expr.id, - maybe_qself.as_ref(), - path, - ValueNS, - true) { - // `::a::b::c` is resolved by typeck alone. - TypecheckRequired => { - let method_name = path.segments.last().unwrap().identifier.name; - let traits = self.get_traits_containing_item(method_name); - self.trait_map.insert(expr.id, traits); - visit::walk_expr(self, expr); - return; - } - ResolveAttempt(resolution) => resolution, - }; + let resolution = match self.resolve_possibly_assoc_item(expr.id, + maybe_qself.as_ref(), + path, + ValueNS, + true) { + // `::a::b::c` is resolved by typeck alone. + TypecheckRequired => { + let method_name = path.segments.last().unwrap().identifier.name; + let traits = self.get_traits_containing_item(method_name); + self.trait_map.insert(expr.id, traits); + visit::walk_expr(self, expr); + return; + } + ResolveAttempt(resolution) => resolution, + }; // This is a local path in the value namespace. Walk through // scopes looking for it. @@ -3646,8 +3683,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { expr.span, ResolutionError::StructVariantUsedAsFunction(&*path_name)); - let msg = format!("did you mean to write: \ - `{} {{ /* fields */ }}`?", + let msg = format!("did you mean to write: `{} {{ /* fields */ }}`?", path_name); if self.emit_errors { self.session.fileline_help(expr.span, &msg); @@ -3679,24 +3715,22 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_path(expr.id, path, 0, TypeNS, false) }); match type_res.map(|r| r.base_def) { - Some(DefTy(struct_id, _)) - if self.structs.contains_key(&struct_id) => { - resolve_error( + Some(DefTy(struct_id, _)) if self.structs.contains_key(&struct_id) => { + resolve_error( self, expr.span, ResolutionError::StructVariantUsedAsFunction( &*path_name) ); - let msg = format!("did you mean to write: \ - `{} {{ /* fields */ }}`?", - path_name); - if self.emit_errors { - self.session.fileline_help(expr.span, &msg); - } else { - self.session.span_help(expr.span, &msg); - } + let msg = format!("did you mean to write: `{} {{ /* fields */ }}`?", + path_name); + if self.emit_errors { + self.session.fileline_help(expr.span, &msg); + } else { + self.session.span_help(expr.span, &msg); } + } _ => { // Keep reporting some errors even if they're ignored above. self.resolve_path(expr.id, path, 0, ValueNS, true); @@ -3712,11 +3746,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }); if method_scope && special_names::self_.as_str() == &path_name[..] { - resolve_error( - self, - expr.span, - ResolutionError::SelfNotAvailableInStaticMethod - ); + resolve_error(self, + expr.span, + ResolutionError::SelfNotAvailableInStaticMethod); } else { let last_name = path.segments.last().unwrap().identifier.name; let mut msg = match self.find_fallback_in_self_type(last_name) { @@ -3724,16 +3756,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // limit search to 5 to reduce the number // of stupid suggestions self.find_best_match_for_name(&path_name) - .map_or("".to_string(), - |x| format!("`{}`", x)) + .map_or("".to_string(), |x| format!("`{}`", x)) } Field => format!("`self.{}`", path_name), Method | - TraitItem => - format!("to call `self.{}`", path_name), + TraitItem => format!("to call `self.{}`", path_name), TraitMethod(path_str) | StaticMethod(path_str) => - format!("to call `{}::{}`", path_str, path_name) + format!("to call `{}::{}`", path_str, path_name), }; if !msg.is_empty() { @@ -3742,8 +3772,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { resolve_error(self, expr.span, - ResolutionError::UnresolvedName(&*path_name, - &*msg)); + ResolutionError::UnresolvedName(&*path_name, &*msg)); } } } @@ -3796,16 +3825,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } Some(DlDef(def @ DefLabel(_))) => { // Since this def is a label, it is never read. - self.record_def(expr.id, PathResolution { - base_def: def, - last_private: LastMod(AllPublic), - depth: 0 - }) + self.record_def(expr.id, + PathResolution { + base_def: def, + last_private: LastMod(AllPublic), + depth: 0, + }) } Some(_) => { - self.session.span_bug(expr.span, - "label wasn't mapped to a \ - label def!") + self.session.span_bug(expr.span, "label wasn't mapped to a label def!") } } } @@ -3827,8 +3855,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.trait_map.insert(expr.id, traits); } ExprMethodCall(name, _, _) => { - debug!("(recording candidate traits for expr) recording \ - traits for {}", + debug!("(recording candidate traits for expr) recording traits for {}", expr.id); let traits = self.get_traits_containing_item(name.node); self.trait_map.insert(expr.id, traits); @@ -3840,15 +3867,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn get_traits_containing_item(&mut self, name: Name) -> Vec { - debug!("(getting traits containing item) looking for '{}'", - name); + debug!("(getting traits containing item) looking for '{}'", name); - fn add_trait_info(found_traits: &mut Vec, - trait_def_id: DefId, - name: Name) { + fn add_trait_info(found_traits: &mut Vec, trait_def_id: DefId, name: Name) { debug!("(adding trait info) found trait {:?} for method '{}'", - trait_def_id, - name); + trait_def_id, + name); found_traits.push(trait_def_id); } @@ -3872,7 +3896,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (_, child_names) in search_module.children.borrow().iter() { let def = match child_names.def_for_namespace(TypeNS) { Some(def) => def, - None => continue + None => continue, }; let trait_def_id = match def { DefTrait(trait_def_id) => trait_def_id, @@ -3919,21 +3943,25 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn record_def(&mut self, node_id: NodeId, resolution: PathResolution) { debug!("(recording def) recording {:?} for {}", resolution, node_id); - assert!(match resolution.last_private {LastImport{..} => false, _ => true}, + assert!(match resolution.last_private { + LastImport{..} => false, + _ => true, + }, "Import should only be used for `use` directives"); if let Some(prev_res) = self.def_map.borrow_mut().insert(node_id, resolution) { let span = self.ast_map.opt_span(node_id).unwrap_or(codemap::DUMMY_SP); - self.session.span_bug(span, &format!("path resolved multiple times \ - ({:?} before, {:?} now)", - prev_res, resolution)); + self.session.span_bug(span, + &format!("path resolved multiple times ({:?} before, {:?} now)", + prev_res, + resolution)); } } fn enforce_default_binding_mode(&mut self, - pat: &Pat, - pat_binding_mode: BindingMode, - descr: &str) { + pat: &Pat, + pat_binding_mode: BindingMode, + descr: &str) { match pat_binding_mode { BindByValue(_) => {} BindByRef(..) => { @@ -3966,7 +3994,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (&name, import_resolution) in import_resolutions.iter() { let value_repr; match import_resolution.target_for_namespace(ValueNS) { - None => { value_repr = "".to_string(); } + None => { + value_repr = "".to_string(); + } Some(_) => { value_repr = " value:?".to_string(); // FIXME #4954 @@ -3975,7 +4005,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let type_repr; match import_resolution.target_for_namespace(TypeNS) { - None => { type_repr = "".to_string(); } + None => { + type_repr = "".to_string(); + } Some(_) => { type_repr = " type:?".to_string(); // FIXME #4954 @@ -3998,12 +4030,12 @@ fn names_to_string(names: &[Name]) -> String { result.push_str("::") } result.push_str(&name.as_str()); - }; + } result } fn path_names_to_string(path: &Path, depth: usize) -> String { - let names: Vec = path.segments[..path.segments.len()-depth] + let names: Vec = path.segments[..path.segments.len() - depth] .iter() .map(|seg| seg.identifier.name) .collect(); @@ -4043,13 +4075,13 @@ pub struct CrateMap { pub export_map: ExportMap, pub trait_map: TraitMap, pub external_exports: ExternalExports, - pub glob_map: Option + pub glob_map: Option, } #[derive(PartialEq,Copy, Clone)] pub enum MakeGlobMap { Yes, - No + No, } /// Entry point to crate resolution. @@ -4072,10 +4104,10 @@ pub fn resolve_crate<'a, 'tcx>(session: &'a Session, trait_map: resolver.trait_map, external_exports: resolver.external_exports, glob_map: if resolver.make_glob_map { - Some(resolver.glob_map) - } else { - None - }, + Some(resolver.glob_map) + } else { + None + }, } } diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 0eb1e2cc06f..96fad16536c 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -30,8 +30,8 @@ use syntax::ast; use std::ops::{Deref, DerefMut}; use std::rc::Rc; -struct ExportRecorder<'a, 'b:'a, 'tcx:'b> { - resolver: &'a mut Resolver<'b, 'tcx> +struct ExportRecorder<'a, 'b: 'a, 'tcx: 'b> { + resolver: &'a mut Resolver<'b, 'tcx>, } // Deref and DerefMut impls allow treating ExportRecorder as Resolver. @@ -50,28 +50,26 @@ impl<'a, 'b, 'tcx:'b> DerefMut for ExportRecorder<'a, 'b, 'tcx> { } impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { - fn record_exports_for_module_subtree(&mut self, - module_: Rc) { + fn record_exports_for_module_subtree(&mut self, module_: Rc) { // If this isn't a local krate, then bail out. We don't need to record // exports for nonlocal crates. match module_.def_id.get() { Some(def_id) if def_id.is_local() => { // OK. Continue. - debug!("(recording exports for module subtree) recording \ - exports for local module `{}`", + 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 `{}`", + 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 `{}`", + debug!("(recording exports for module subtree) not recording exports for `{}`", module_to_string(&*module_)); return; } @@ -118,10 +116,11 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { match namebindings.def_for_namespace(ns) { Some(d) => { debug!("(computing exports) YES: export '{}' => {:?}", - name, d.def_id()); + name, + d.def_id()); exports.push(Export { name: name, - def_id: d.def_id() + def_id: d.def_id(), }); } d_opt => { @@ -130,25 +129,19 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { } } - fn add_exports_for_module(&mut self, - exports: &mut Vec, - module_: &Module) { + fn add_exports_for_module(&mut self, exports: &mut Vec, module_: &Module) { for (name, import_resolution) in module_.import_resolutions.borrow().iter() { if !import_resolution.is_public { - continue + continue; } let xs = [TypeNS, ValueNS]; for &ns in &xs { match import_resolution.target_for_namespace(ns) { Some(target) => { - debug!("(computing exports) maybe export '{}'", - name); - self.add_exports_of_namebindings(exports, - *name, - &*target.bindings, - ns) + debug!("(computing exports) maybe export '{}'", name); + self.add_exports_of_namebindings(exports, *name, &*target.bindings, ns) } - _ => () + _ => (), } } } diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 99d7685f7c8..9a21ec86685 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -42,14 +42,14 @@ use std::rc::Rc; #[derive(Copy, Clone,Debug)] pub enum ImportDirectiveSubclass { SingleImport(Name /* target */, Name /* source */), - GlobImport + GlobImport, } /// Whether an import can be shadowed by another import. #[derive(Debug,PartialEq,Clone,Copy)] pub enum Shadowable { Always, - Never + Never, } /// One import directive. @@ -64,13 +64,13 @@ pub struct ImportDirective { } impl ImportDirective { - pub fn new(module_path: Vec , - subclass: ImportDirectiveSubclass, - span: Span, - id: NodeId, - is_public: bool, - shadowable: Shadowable) - -> ImportDirective { + pub fn new(module_path: Vec, + subclass: ImportDirectiveSubclass, + span: Span, + id: NodeId, + is_public: bool, + shadowable: Shadowable) + -> ImportDirective { ImportDirective { module_path: module_path, subclass: subclass, @@ -92,9 +92,9 @@ pub struct Target { impl Target { pub fn new(target_module: Rc, - bindings: Rc, - shadowable: Shadowable) - -> Target { + bindings: Rc, + shadowable: Shadowable) + -> Target { Target { target_module: target_module, bindings: bindings, @@ -144,17 +144,16 @@ impl ImportResolution { } } - pub fn target_for_namespace(&self, namespace: Namespace) - -> Option { + pub fn target_for_namespace(&self, namespace: Namespace) -> Option { match namespace { - TypeNS => self.type_target.clone(), + TypeNS => self.type_target.clone(), ValueNS => self.value_target.clone(), } } pub fn id(&self, namespace: Namespace) -> NodeId { match namespace { - TypeNS => self.type_id, + TypeNS => self.type_id, ValueNS => self.value_id, } } @@ -168,12 +167,9 @@ impl ImportResolution { target.unwrap().shadowable } - pub fn set_target_and_id(&mut self, - namespace: Namespace, - target: Option, - id: NodeId) { + pub fn set_target_and_id(&mut self, namespace: Namespace, target: Option, id: NodeId) { match namespace { - TypeNS => { + TypeNS => { self.type_target = target; self.type_id = id; } @@ -191,8 +187,8 @@ struct ImportResolvingError { help: String, } -struct ImportResolver<'a, 'b:'a, 'tcx:'b> { - resolver: &'a mut Resolver<'b, 'tcx> +struct ImportResolver<'a, 'b: 'a, 'tcx: 'b> { + resolver: &'a mut Resolver<'b, 'tcx>, } impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { @@ -211,7 +207,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { let mut prev_unresolved_imports = 0; loop { debug!("(resolving imports) iteration {}, {} imports left", - i, self.resolver.unresolved_imports); + i, + self.resolver.unresolved_imports); let module_root = self.resolver.graph_root.get_module(); let errors = self.resolve_imports_for_module_subtree(module_root.clone()); @@ -246,7 +243,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { /// Attempts to resolve imports for the given module and all of its /// submodules. - fn resolve_imports_for_module_subtree(&mut self, module_: Rc) + fn resolve_imports_for_module_subtree(&mut self, + module_: Rc) -> Vec { let mut errors = Vec::new(); debug!("(resolving imports for module subtree) resolving {}", @@ -279,8 +277,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { let mut errors = Vec::new(); if module.all_imports_resolved() { - debug!("(resolving imports for module) all imports resolved for \ - {}", + debug!("(resolving imports for module) all imports resolved for {}", module_to_string(&*module)); return errors; } @@ -290,22 +287,19 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { let mut indeterminate_imports = Vec::new(); while module.resolved_import_count.get() + indeterminate_imports.len() < import_count { let import_index = module.resolved_import_count.get(); - match self.resolve_import_for_module(module.clone(), - &imports[import_index]) { + match self.resolve_import_for_module(module.clone(), &imports[import_index]) { ResolveResult::Failed(err) => { let import_directive = &imports[import_index]; let (span, help) = match err { Some((span, msg)) => (span, format!(". {}", msg)), - None => (import_directive.span, String::new()) + None => (import_directive.span, String::new()), }; errors.push(ImportResolvingError { - span: span, - path: import_path_to_string( - &import_directive.module_path, - import_directive.subclass - ), - help: help - }); + span: span, + path: import_path_to_string(&import_directive.module_path, + import_directive.subclass), + help: help, + }); } ResolveResult::Indeterminate => {} ResolveResult::Success(()) => { @@ -354,7 +348,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { ResolveResult::Failed(err) => { resolution_result = ResolveResult::Failed(err); None - }, + } ResolveResult::Indeterminate => { resolution_result = ResolveResult::Indeterminate; None @@ -371,20 +365,18 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { match import_directive.subclass { SingleImport(target, source) => { - resolution_result = - self.resolve_single_import(&module_, - containing_module, - target, - source, - import_directive, - lp); + resolution_result = self.resolve_single_import(&module_, + containing_module, + target, + source, + import_directive, + lp); } GlobImport => { - resolution_result = - self.resolve_glob_import(&module_, - containing_module, - import_directive, - lp); + resolution_result = self.resolve_glob_import(&module_, + containing_module, + import_directive, + lp); } } } @@ -433,8 +425,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { directive: &ImportDirective, lp: LastPrivate) -> ResolveResult<()> { - debug!("(resolving single import) resolving `{}` = `{}::{}` from \ - `{}` id {}, last private {:?}", + debug!("(resolving single import) resolving `{}` = `{}::{}` from `{}` id {}, last \ + private {:?}", target, module_to_string(&*target_module), source, @@ -445,9 +437,9 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { let lp = match lp { LastMod(lp) => lp, LastImport {..} => { - self.resolver.session - .span_bug(directive.span, - "not expecting Import here, must be LastMod") + self.resolver + .session + .span_bug(directive.span, "not expecting Import here, must be LastMod") } }; @@ -472,11 +464,10 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { value_result = BoundResult(target_module.clone(), (*child_name_bindings).clone()); if directive.is_public && !child_name_bindings.is_public(ValueNS) { - let msg = format!("`{}` is private, and cannot be reexported", - source); - let note_msg = - format!("Consider marking `{}` as `pub` in the imported module", - source); + let msg = format!("`{}` is private, and cannot be reexported", source); + let note_msg = format!("Consider marking `{}` as `pub` in the imported \ + module", + source); span_err!(self.resolver.session, directive.span, E0364, "{}", &msg); self.resolver.session.span_note(directive.span, ¬e_msg); pub_err = true; @@ -487,8 +478,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { type_result = BoundResult(target_module.clone(), (*child_name_bindings).clone()); if !pub_err && directive.is_public && !child_name_bindings.is_public(TypeNS) { - let msg = format!("`{}` is private, and cannot be reexported", - source); + let msg = format!("`{}` is private, and cannot be reexported", source); let note_msg = format!("Consider declaring module `{}` as a `pub mod`", source); span_err!(self.resolver.session, directive.span, E0365, "{}", &msg); @@ -510,8 +500,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // able to resolve this import. if target_module.pub_glob_count.get() > 0 { - debug!("(resolving single import) unresolved pub glob; \ - bailing out"); + debug!("(resolving single import) unresolved pub glob; bailing out"); return ResolveResult::Indeterminate; } @@ -531,14 +520,13 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { type_result = UnboundResult; } } - Some(import_resolution) - if import_resolution.outstanding_references == 0 => { + Some(import_resolution) if import_resolution.outstanding_references == 0 => { fn get_binding(this: &mut Resolver, import_resolution: &ImportResolution, namespace: Namespace, source: Name) - -> NamespaceResult { + -> NamespaceResult { // Import resolutions must be declared with "pub" // in order to be exported. @@ -555,8 +543,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { bindings, shadowable: _ }) => { - debug!("(resolving single import) found \ - import in ns {:?}", namespace); + debug!("(resolving single import) found import in ns {:?}", + namespace); let id = import_resolution.id(namespace); // track used imports and extern crates as well this.used_imports.insert((id, namespace)); @@ -564,7 +552,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { match target_module.def_id.get() { Some(DefId{krate: kid, ..}) => { this.used_crates.insert(kid); - }, + } _ => {} } return BoundResult(target_module, bindings); @@ -603,8 +591,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // In this case we continue as if we resolved the import and let the // check_for_conflicts_between_imports_and_items call below handle // the conflict - match (module_.def_id.get(), target_module.def_id.get()) { - (Some(id1), Some(id2)) if id1 == id2 => { + match (module_.def_id.get(), target_module.def_id.get()) { + (Some(id1), Some(id2)) if id1 == id2 => { if value_result.is_unknown() { value_result = UnboundResult; } @@ -612,10 +600,9 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { type_result = UnboundResult; } } - _ => { + _ => { // The import is unresolved. Bail out. - debug!("(resolving single import) unresolved import; \ - bailing out"); + debug!("(resolving single import) unresolved import; bailing out"); return ResolveResult::Indeterminate; } } @@ -668,17 +655,15 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { debug!("(resolving single import) found {:?} target: {:?}", namespace_name, name_bindings.def_for_namespace(namespace)); - self.check_for_conflicting_import( - &import_resolution, - directive.span, - target, - namespace); + self.check_for_conflicting_import(&import_resolution, + directive.span, + target, + namespace); - self.check_that_import_is_importable( - &**name_bindings, - directive.span, - target, - namespace); + self.check_that_import_is_importable(&**name_bindings, + directive.span, + target, + namespace); let target = Some(Target::new(target_module.clone(), name_bindings.clone(), @@ -687,7 +672,9 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { import_resolution.is_public = directive.is_public; *used_public = name_bindings.defined_in_public_namespace(namespace); } - UnboundResult => { /* Continue. */ } + UnboundResult => { + // Continue. + } UnknownResult => { panic!("{:?} result should be known at this point", namespace_name); } @@ -697,11 +684,10 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { check_and_write_import(TypeNS, &type_result, &mut type_used_public); } - self.check_for_conflicts_between_imports_and_items( - module_, - import_resolution, - directive.span, - target); + self.check_for_conflicts_between_imports_and_items(module_, + import_resolution, + directive.span, + target); if value_result.is_unbound() && type_result.is_unbound() { let msg = format!("There is no `{}` in `{}`", @@ -720,33 +706,45 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // purposes it's good enough to just favor one over the other. let value_def_and_priv = import_resolution.value_target.as_ref().map(|target| { let def = target.bindings.def_for_namespace(ValueNS).unwrap(); - (def, if value_used_public { lp } else { DependsOn(def.def_id()) }) + (def, + if value_used_public { + lp + } else { + DependsOn(def.def_id()) + }) }); let type_def_and_priv = import_resolution.type_target.as_ref().map(|target| { let def = target.bindings.def_for_namespace(TypeNS).unwrap(); - (def, if type_used_public { lp } else { DependsOn(def.def_id()) }) + (def, + if type_used_public { + lp + } else { + DependsOn(def.def_id()) + }) }); let import_lp = LastImport { value_priv: value_def_and_priv.map(|(_, p)| p), value_used: Used, type_priv: type_def_and_priv.map(|(_, p)| p), - type_used: Used + type_used: Used, }; if let Some((def, _)) = value_def_and_priv { - self.resolver.def_map.borrow_mut().insert(directive.id, PathResolution { - base_def: def, - last_private: import_lp, - depth: 0 - }); + self.resolver.def_map.borrow_mut().insert(directive.id, + PathResolution { + base_def: def, + last_private: import_lp, + depth: 0, + }); } if let Some((def, _)) = type_def_and_priv { - self.resolver.def_map.borrow_mut().insert(directive.id, PathResolution { - base_def: def, - last_private: import_lp, - depth: 0 - }); + self.resolver.def_map.borrow_mut().insert(directive.id, + PathResolution { + base_def: def, + last_private: import_lp, + depth: 0, + }); } debug!("(resolving single import) successfully resolved import"); @@ -774,8 +772,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // We must bail out if the node has unresolved imports of any kind // (including globs). if (*target_module).pub_count.get() > 0 { - debug!("(resolving glob import) target module has unresolved \ - pub imports; bailing out"); + debug!("(resolving glob import) target module has unresolved pub imports; bailing out"); return ResolveResult::Indeterminate; } @@ -787,21 +784,18 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // This means we are trying to glob import a module into itself, // and it is a no-go debug!("(resolving glob imports) target module is current module; giving up"); - return ResolveResult::Failed(Some(( - import_directive.span, - "Cannot glob-import a module into itself.".into() - ))); + return ResolveResult::Failed(Some((import_directive.span, + "Cannot glob-import a module into itself.".into()))); } for (name, target_import_resolution) in import_resolutions.iter() { - debug!("(resolving glob import) writing module resolution \ - {} into `{}`", + debug!("(resolving glob import) writing module resolution {} into `{}`", *name, module_to_string(module_)); if !target_import_resolution.is_public { debug!("(resolving glob import) nevermind, just kidding"); - continue + continue; } // Here we merge two import resolutions. @@ -843,10 +837,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // Simple: just copy the old import resolution. let mut new_import_resolution = ImportResolution::new(id, is_public); - new_import_resolution.value_target = - target_import_resolution.value_target.clone(); - new_import_resolution.type_target = - target_import_resolution.type_target.clone(); + new_import_resolution.value_target = target_import_resolution.value_target.clone(); + new_import_resolution.type_target = target_import_resolution.type_target.clone(); import_resolutions.insert(*name, new_import_resolution); } @@ -865,8 +857,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // Add external module children from the containing module. for (&name, module) in target_module.external_module_children.borrow().iter() { - let name_bindings = - Rc::new(Resolver::create_name_bindings_from_module(module.clone())); + let name_bindings = Rc::new(Resolver::create_name_bindings_from_module(module.clone())); self.merge_import_resolution(module_, target_module.clone(), import_directive, @@ -876,11 +867,12 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { // Record the destination of this import if let Some(did) = target_module.def_id.get() { - self.resolver.def_map.borrow_mut().insert(id, PathResolution { - base_def: DefMod(did), - last_private: lp, - depth: 0 - }); + self.resolver.def_map.borrow_mut().insert(id, + PathResolution { + base_def: DefMod(did), + last_private: lp, + depth: 0, + }); } debug!("(resolving glob import) successfully resolved import"); @@ -898,10 +890,11 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { let mut import_resolutions = module_.import_resolutions.borrow_mut(); let dest_import_resolution = import_resolutions.entry(name) - .or_insert_with(|| ImportResolution::new(id, is_public)); + .or_insert_with(|| { + ImportResolution::new(id, is_public) + }); - debug!("(resolving glob import) writing resolution `{}` in `{}` \ - to `{}`", + debug!("(resolving glob import) writing resolution `{}` in `{}` to `{}`", name, module_to_string(&*containing_module), module_to_string(module_)); @@ -918,18 +911,20 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { }; debug!("(resolving glob import) ... for {} target", namespace_name); if dest_import_resolution.shadowable(namespace) == Shadowable::Never { - let msg = format!("a {} named `{}` has already been imported \ - in this module", + let msg = format!("a {} named `{}` has already been imported in this \ + module", namespace_name, name); - span_err!(self.resolver.session, import_directive.span, E0251, "{}", msg); + span_err!(self.resolver.session, + import_directive.span, + E0251, + "{}", + msg); } else { let target = Target::new(containing_module.clone(), name_bindings.clone(), import_directive.shadowable); - dest_import_resolution.set_target_and_id(namespace, - Some(target), - id); + dest_import_resolution.set_target_and_id(namespace, Some(target), id); } } }; @@ -939,11 +934,10 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { dest_import_resolution.is_public = is_public; - self.check_for_conflicts_between_imports_and_items( - module_, - dest_import_resolution, - import_directive.span, - name); + self.check_for_conflicts_between_imports_and_items(module_, + dest_import_resolution, + import_directive.span, + name); } /// Checks that imported names and items don't have the same name. @@ -963,28 +957,31 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { TypeNS => { if let Some(ref ty_def) = *target.bindings.type_def.borrow() { match ty_def.module_def { - Some(ref module) - if module.kind.get() == ModuleKind::NormalModuleKind => - "module", - Some(ref module) - if module.kind.get() == ModuleKind::TraitModuleKind => - "trait", + Some(ref module) if module.kind.get() == + ModuleKind::NormalModuleKind => "module", + Some(ref module) if module.kind.get() == + ModuleKind::TraitModuleKind => "trait", _ => "type", } - } else { "type" } - }, + } else { + "type" + } + } ValueNS => "value", }; - span_err!(self.resolver.session, import_span, E0252, - "a {} named `{}` has already been imported \ - in this module", ns_word, - name); + span_err!(self.resolver.session, + import_span, + E0252, + "a {} named `{}` has already been imported in this module", + ns_word, + name); let use_id = import_resolution.id(namespace); let item = self.resolver.ast_map.expect_item(use_id); // item is syntax::ast::Item; - span_note!(self.resolver.session, item.span, - "previous import of `{}` here", - name); + span_note!(self.resolver.session, + item.span, + "previous import of `{}` here", + name); } Some(_) | None => {} } @@ -997,8 +994,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { name: Name, namespace: Namespace) { if !name_bindings.defined_in_namespace_with(namespace, DefModifiers::IMPORTABLE) { - let msg = format!("`{}` is not directly importable", - name); + let msg = format!("`{}` is not directly importable", name); span_err!(self.resolver.session, import_span, E0253, "{}", &msg[..]); } } @@ -1006,8 +1002,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { /// Checks that imported names and items don't have the same name. fn check_for_conflicts_between_imports_and_items(&mut self, module: &Module, - import_resolution: - &ImportResolution, + import_resolution: &ImportResolution, import_span: Span, name: Name) { // First, check for conflicts between imports and `extern crate`s. @@ -1016,8 +1011,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { .contains_key(&name) { match import_resolution.type_target { Some(ref target) if target.shadowable != Shadowable::Always => { - let msg = format!("import `{0}` conflicts with imported \ - crate in this module \ + let msg = format!("import `{0}` conflicts with imported crate in this module \ (maybe you meant `use {0}::*`?)", name); span_err!(self.resolver.session, import_span, E0254, "{}", &msg[..]); @@ -1031,7 +1025,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { let name_bindings = match children.get(&name) { None => { // There can't be any conflicts. - return + return; } Some(ref name_bindings) => (*name_bindings).clone(), }; @@ -1039,7 +1033,9 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { match import_resolution.value_target { Some(ref target) if target.shadowable != Shadowable::Always => { if let Some(ref value) = *name_bindings.value_def.borrow() { - span_err!(self.resolver.session, import_span, E0255, + span_err!(self.resolver.session, + import_span, + E0255, "import `{}` conflicts with value in this module", name); if let Some(span) = value.value_span { @@ -1054,17 +1050,18 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { Some(ref target) if target.shadowable != Shadowable::Always => { if let Some(ref ty) = *name_bindings.type_def.borrow() { let (what, note) = match ty.module_def { - Some(ref module) - if module.kind.get() == ModuleKind::NormalModuleKind => - ("existing submodule", "note conflicting module here"), - Some(ref module) - if module.kind.get() == ModuleKind::TraitModuleKind => - ("trait in this module", "note conflicting trait here"), - _ => ("type in this module", "note conflicting type here"), + Some(ref module) if module.kind.get() == ModuleKind::NormalModuleKind => + ("existing submodule", "note conflicting module here"), + Some(ref module) if module.kind.get() == ModuleKind::TraitModuleKind => + ("trait in this module", "note conflicting trait here"), + _ => ("type in this module", "note conflicting type here"), }; - span_err!(self.resolver.session, import_span, E0256, + span_err!(self.resolver.session, + import_span, + E0256, "import `{}` conflicts with {}", - name, what); + name, + what); if let Some(span) = ty.type_span { self.resolver.session.span_note(span, note); } @@ -1075,28 +1072,25 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { } } -fn import_path_to_string(names: &[Name], - subclass: ImportDirectiveSubclass) - -> String { +fn import_path_to_string(names: &[Name], subclass: ImportDirectiveSubclass) -> String { if names.is_empty() { import_directive_subclass_to_string(subclass) } else { (format!("{}::{}", names_to_string(names), - import_directive_subclass_to_string(subclass))).to_string() + import_directive_subclass_to_string(subclass))) + .to_string() } } fn import_directive_subclass_to_string(subclass: ImportDirectiveSubclass) -> String { match subclass { SingleImport(_, source) => source.to_string(), - GlobImport => "*".to_string() + GlobImport => "*".to_string(), } } pub fn resolve_imports(resolver: &mut Resolver) { - let mut import_resolver = ImportResolver { - resolver: resolver, - }; + let mut import_resolver = ImportResolver { resolver: resolver }; import_resolver.resolve_imports(); }