rustc: Remove compiler support for __log_level()

This commit removes all internal support for the previously used __log_level()
expression. The logging subsystem was previously modified to not rely on this
magical expression. This also removes the only other function to use the
module_data map in trans, decl_gc_metadata. It appears that this is an ancient
function from a GC only used long ago.

This does not remove the crate map entirely, as libgreen still uses it to hook
in to the event loop provided by libgreen.

1 files changed, 15 insertions, 84 deletions

diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs
index ff54a80ce99..c6d5a80208b 100644
--- a/src/libstd/rt/crate_map.rs
+++ b/src/libstd/rt/crate_map.rs
@@ -9,13 +9,14 @@
 // except according to those terms.
 
 use cast;
-use cmp::TotalOrd;
-use container::MutableSet;
-use iter::Iterator;
 use option::{Some, None, Option};
 use ptr::RawPtr;
 use rt::rtio::EventLoop;
-use vec::{ImmutableVector, OwnedVector};
+
+#[cfg(stage0)] use cmp::TotalOrd;
+#[cfg(stage0)] use container::MutableSet;
+#[cfg(stage0)] use iter::Iterator;
+#[cfg(stage0)] use vec::{ImmutableVector, OwnedVector};
 
 // Need to tell the linker on OS X to not barf on undefined symbols
 // and instead look them up at runtime, which we need to resolve
@@ -24,17 +25,24 @@ use vec::{ImmutableVector, OwnedVector};
 #[link_args = "-Wl,-U,__rust_crate_map_toplevel"]
 extern {}
 
+#[cfg(stage0)]
 pub struct ModEntry<'a> {
     name: &'a str,
     log_level: *mut u32
 }
 
+#[cfg(stage0)]
 pub struct CrateMap<'a> {
     version: i32,
     entries: &'a [ModEntry<'a>],
     children: &'a [&'a CrateMap<'a>],
     event_loop_factory: Option<fn() -> ~EventLoop>,
 }
+#[cfg(not(stage0))]
+pub struct CrateMap<'a> {
+    version: i32,
+    event_loop_factory: Option<fn() -> ~EventLoop>,
+}
 
 // When working on android, apparently weak symbols don't work so well for
 // finding the crate map, and neither does dlopen + dlsym. This is mainly a
@@ -114,6 +122,7 @@ pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
     }
 }
 
+#[cfg(stage0)]
 fn version(crate_map: &CrateMap) -> i32 {
     match crate_map.version {
         2 => return 2,
@@ -121,6 +130,7 @@ fn version(crate_map: &CrateMap) -> i32 {
     }
 }
 
+#[cfg(stage0)]
 fn do_iter_crate_map<'a>(
                      crate_map: &'a CrateMap<'a>,
                      f: |&'a ModEntry<'a>|,
@@ -149,87 +159,8 @@ fn do_iter_crate_map<'a>(
 }
 
 /// Iterates recursively over `crate_map` and all child crate maps
+#[cfg(stage0)]
 pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: |&'a ModEntry<'a>|) {
     let mut v = ~[];
     do_iter_crate_map(crate_map, f, &mut v);
 }
-
-#[cfg(test)]
-mod tests {
-    use option::None;
-    use rt::crate_map::{CrateMap, ModEntry, iter_crate_map};
-
-    #[test]
-    fn iter_crate_map_duplicates() {
-        let mut level3: u32 = 3;
-
-        let entries = [
-            ModEntry { name: "c::m1", log_level: &mut level3},
-        ];
-
-        let child_crate = CrateMap {
-            version: 2,
-            entries: entries,
-            children: &[],
-            event_loop_factory: None,
-        };
-
-        let root_crate = CrateMap {
-            version: 2,
-            entries: &[],
-            children: &[&child_crate, &child_crate],
-            event_loop_factory: None,
-        };
-
-        let mut cnt = 0;
-        unsafe {
-            iter_crate_map(&root_crate, |entry| {
-                assert!(*entry.log_level == 3);
-                cnt += 1;
-            });
-            assert!(cnt == 1);
-        }
-    }
-
-    #[test]
-    fn iter_crate_map_follow_children() {
-        let mut level2: u32 = 2;
-        let mut level3: u32 = 3;
-        let child_crate2 = CrateMap {
-            version: 2,
-            entries: &[
-                ModEntry { name: "c::m1", log_level: &mut level2},
-                ModEntry { name: "c::m2", log_level: &mut level3},
-            ],
-            children: &[],
-            event_loop_factory: None,
-        };
-
-        let child_crate1 = CrateMap {
-            version: 2,
-            entries: &[
-                ModEntry { name: "t::f1", log_level: &mut 1},
-            ],
-            children: &[&child_crate2],
-            event_loop_factory: None,
-        };
-
-        let root_crate = CrateMap {
-            version: 2,
-            entries: &[
-                ModEntry { name: "t::f2", log_level: &mut 0},
-            ],
-            children: &[&child_crate1],
-            event_loop_factory: None,
-        };
-
-        let mut cnt = 0;
-        unsafe {
-            iter_crate_map(&root_crate, |entry| {
-                assert!(*entry.log_level == cnt);
-                cnt += 1;
-            });
-            assert!(cnt == 4);
-        }
-    }
-}