rollup merge of #21438: taralx/kill-racycell

[rust.git] / src / librustc_resolve / lib.rs

diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 7743a437858d2e97d3b4a350b8d81dfc7a750d4a..4262b03ece29e51f01a682a620632eafd3228213 100644 (file)
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -20,9 +20,11 @@
 #![feature(slicing_syntax)]
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
+#[macro_use] #[no_link] extern crate rustc_bitflags;
 
 extern crate rustc;
 
@@ -95,6 +97,10 @@
 use std::rc::{Rc, Weak};
 use std::uint;
 
+// NB: This module needs to be declared first so diagnostics are
+// registered before they are used.
+pub mod diagnostics;
+
 mod check_unused;
 mod record_exports;
 mod build_reduced_graph;
@@ -457,6 +463,7 @@ enum ModuleKind {
     TraitModuleKind,
     ImplModuleKind,
     EnumModuleKind,
+    TypeModuleKind,
     AnonymousModuleKind,
 }
 
@@ -520,7 +527,7 @@ fn new(parent_link: ParentLink,
             children: RefCell::new(HashMap::new()),
             imports: RefCell::new(Vec::new()),
             external_module_children: RefCell::new(HashMap::new()),
-            anonymous_children: RefCell::new(NodeMap::new()),
+            anonymous_children: RefCell::new(NodeMap()),
             import_resolutions: RefCell::new(HashMap::new()),
             glob_count: Cell::new(0),
             resolved_import_count: Cell::new(0),
@@ -940,8 +947,8 @@ fn new(session: &'a Session,
 
             graph_root: graph_root,
 
-            trait_item_map: FnvHashMap::new(),
-            structs: FnvHashMap::new(),
+            trait_item_map: FnvHashMap(),
+            structs: FnvHashMap(),
 
             unresolved_imports: 0,
 
@@ -958,16 +965,16 @@ fn new(session: &'a Session,
 
             primitive_type_table: PrimitiveTypeTable::new(),
 
-            def_map: RefCell::new(NodeMap::new()),
-            freevars: RefCell::new(NodeMap::new()),
-            freevars_seen: RefCell::new(NodeMap::new()),
-            capture_mode_map: NodeMap::new(),
-            export_map: NodeMap::new(),
-            trait_map: NodeMap::new(),
+            def_map: RefCell::new(NodeMap()),
+            freevars: RefCell::new(NodeMap()),
+            freevars_seen: RefCell::new(NodeMap()),
+            capture_mode_map: NodeMap(),
+            export_map: NodeMap(),
+            trait_map: NodeMap(),
             used_imports: HashSet::new(),
             used_crates: HashSet::new(),
-            external_exports: DefIdSet::new(),
-            last_private: NodeMap::new(),
+            external_exports: DefIdSet(),
+            last_private: NodeMap(),
 
             emit_errors: true,
             make_glob_map: make_glob_map == MakeGlobMap::Yes,
@@ -1715,7 +1722,7 @@ fn merge_import_resolution(&mut self,
                                            in this module",
                                           namespace_name,
                                           token::get_name(name).get());
-                        self.session.span_err(import_directive.span, msg.as_slice());
+                        span_err!(self.session, import_directive.span, E0251, "{}", msg.as_slice());
                     } else {
                         let target = Target::new(containing_module.clone(),
                                                  name_bindings.clone(),
@@ -1762,7 +1769,7 @@ fn check_for_conflicting_import(&mut self,
                                     ValueNS => "value",
                                   },
                                   token::get_name(name).get());
-                self.session.span_err(import_span, &msg[]);
+                span_err!(self.session, import_span, E0252, "{}", &msg[]);
             }
             Some(_) | None => {}
         }
@@ -1777,7 +1784,7 @@ fn check_that_import_is_importable(&mut self,
         if !name_bindings.defined_in_namespace_with(namespace, IMPORTABLE) {
             let msg = format!("`{}` is not directly importable",
                               token::get_name(name));
-            self.session.span_err(import_span, &msg[]);
+            span_err!(self.session, import_span, E0253, "{}", &msg[]);
         }
     }
 
@@ -1802,7 +1809,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                                        crate in this module \
                                        (maybe you meant `use {0}::*`?)",
                                       token::get_name(name).get());
-                    self.session.span_err(import_span, &msg[]);
+                    span_err!(self.session, import_span, E0254, "{}", &msg[]);
                 }
                 Some(_) | None => {}
             }
@@ -1824,7 +1831,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                     let msg = format!("import `{}` conflicts with value \
                                        in this module",
                                       token::get_name(name).get());
-                    self.session.span_err(import_span, &msg[]);
+                    span_err!(self.session, import_span, E0255, "{}", &msg[]);
                     if let Some(span) = value.value_span {
                         self.session.span_note(span,
                                                "conflicting value here");
@@ -1842,7 +1849,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                             let msg = format!("import `{}` conflicts with type in \
                                                this module",
                                               token::get_name(name).get());
-                            self.session.span_err(import_span, &msg[]);
+                            span_err!(self.session, import_span, E0256, "{}", &msg[]);
                             if let Some(span) = ty.type_span {
                                 self.session.span_note(span,
                                                        "note conflicting type here")
@@ -1855,7 +1862,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                                         let msg = format!("inherent implementations \
                                                            are only allowed on types \
                                                            defined in the current module");
-                                        self.session.span_err(span, &msg[]);
+                                        span_err!(self.session, span, E0257, "{}", &msg[]);
                                         self.session.span_note(import_span,
                                                                "import from other module here")
                                     }
@@ -1864,7 +1871,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                                     let msg = format!("import `{}` conflicts with existing \
                                                        submodule",
                                                       token::get_name(name).get());
-                                    self.session.span_err(import_span, &msg[]);
+                                    span_err!(self.session, import_span, E0258, "{}", &msg[]);
                                     if let Some(span) = ty.type_span {
                                         self.session.span_note(span,
                                                                "note conflicting module here")
@@ -1890,11 +1897,10 @@ fn check_for_conflicts_between_external_crates(&self,
         }
 
         if module.external_module_children.borrow().contains_key(&name) {
-            self.session
-                .span_err(span,
-                          &format!("an external crate named `{}` has already \
+                span_err!(self.session, span, E0259,
+                          "an external crate named `{}` has already \
                                    been imported into this module",
-                                  token::get_name(name).get())[]);
+                                  token::get_name(name).get());
         }
     }
 
@@ -1908,12 +1914,11 @@ fn check_for_conflicts_between_external_crates_and_items(&self,
         }
 
         if module.external_module_children.borrow().contains_key(&name) {
-            self.session
-                .span_err(span,
-                          &format!("the name `{}` conflicts with an external \
+                span_err!(self.session, span, E0260,
+                          "the name `{}` conflicts with an external \
                                    crate that has been imported into this \
                                    module",
-                                  token::get_name(name).get())[]);
+                                  token::get_name(name).get());
         }
     }
 
@@ -1962,7 +1967,7 @@ fn search_parent_externals(needle: Name, module: &Rc<Module>)
                     let module_name = self.module_to_string(&*search_module);
                     let mut span = span;
                     let msg = if "???" == &module_name[] {
-                        span.hi = span.lo + Pos::from_uint(segment_name.get().len());
+                        span.hi = span.lo + Pos::from_usize(segment_name.get().len());
 
                         match search_parent_externals(name,
                                                      &self.current_module) {
@@ -2080,8 +2085,8 @@ fn resolve_module_path(&mut self,
                         let msg = format!("Could not find `{}` in `{}`",
                                             // idx +- 1 to account for the
                                             // colons on either side
-                                            &mpath[(idx + 1)..],
-                                            &mpath[..(idx - 1)]);
+                                            &mpath[idx + 1..],
+                                            &mpath[..idx - 1]);
                         return Failed(Some((span, msg)));
                     },
                     None => {
@@ -2238,6 +2243,7 @@ fn resolve_item_in_lexical_scope(&mut self,
                         TraitModuleKind |
                         ImplModuleKind |
                         EnumModuleKind |
+                        TypeModuleKind |
                         AnonymousModuleKind => {
                             search_module = parent_module_node.upgrade().unwrap();
                         }
@@ -2335,6 +2341,7 @@ fn get_nearest_normal_module_parent(&mut self, module_: Rc<Module>)
                         TraitModuleKind |
                         ImplModuleKind |
                         EnumModuleKind |
+                        TypeModuleKind |
                         AnonymousModuleKind => module_ = new_module,
                     }
                 }
@@ -2351,6 +2358,7 @@ fn get_nearest_normal_module_parent_or_self(&mut self, module_: Rc<Module>)
             TraitModuleKind |
             ImplModuleKind |
             EnumModuleKind |
+            TypeModuleKind |
             AnonymousModuleKind => {
                 match self.get_nearest_normal_module_parent(module_.clone()) {
                     None => module_,
@@ -2629,7 +2637,7 @@ fn upvarify(&self,
                             let mut seen = self.freevars_seen.borrow_mut();
                             let seen = match seen.entry(function_id) {
                                 Occupied(v) => v.into_mut(),
-                                Vacant(v) => v.insert(NodeSet::new()),
+                                Vacant(v) => v.insert(NodeSet()),
                             };
                             if seen.contains(&node_id) {
                                 continue;
@@ -2754,7 +2762,7 @@ fn search_ribs(&self,
         for (i, rib) in ribs.iter().enumerate().rev() {
             match rib.bindings.get(&name).cloned() {
                 Some(def_like) => {
-                    return self.upvarify(&ribs[(i + 1)..], def_like, span);
+                    return self.upvarify(&ribs[i + 1..], def_like, span);
                 }
                 None => {
                     // Continue.