Remove all non-AST uses of @T in librustc.

src/librustc/driver/driver.rs

@@ -299,7 +299,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         last_private_map: last_private_map
     } =
         time(time_passes, "resolution", (), |_|
-             middle::resolve::resolve_crate(&sess, lang_items, krate));
+             middle::resolve::resolve_crate(&sess, &lang_items, krate));
 
     // Discard MTWT tables that aren't required past resolution.
     syntax::ext::mtwt::clear_tables();
@@ -316,7 +316,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                 sess.diagnostic(), krate)));
 
     let freevars = time(time_passes, "freevar finding", (), |_|
-                        freevars::annotate_freevars(def_map, krate));
+                        freevars::annotate_freevars(&def_map, krate));
 
     let region_map = time(time_passes, "region resolution", (), |_|
                           middle::region::resolve_crate(&sess, krate));
@@ -328,7 +328,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                             freevars, region_map, lang_items);
 
     // passes are timed inside typeck
-    let (method_map, vtable_map) = typeck::check_crate(&ty_cx, trait_map, krate);
+    typeck::check_crate(&ty_cx, trait_map, krate);
 
     time(time_passes, "check static items", (), |_|
          middle::check_static::check_crate(&ty_cx, krate));
@@ -338,56 +338,52 @@ pub fn phase_3_run_analysis_passes(sess: Session,
          middle::const_eval::process_crate(krate, &ty_cx));
 
     time(time_passes, "const checking", (), |_|
-         middle::check_const::check_crate(krate, def_map, method_map, &ty_cx));
+         middle::check_const::check_crate(krate, &ty_cx));
 
     let maps = (external_exports, last_private_map);
     let (exported_items, public_items) =
             time(time_passes, "privacy checking", maps, |(a, b)|
-                 middle::privacy::check_crate(&ty_cx, &method_map, &exp_map2,
-                                              a, b, krate));
+                 middle::privacy::check_crate(&ty_cx, &exp_map2, a, b, krate));
 
     time(time_passes, "effect checking", (), |_|
-         middle::effect::check_crate(&ty_cx, method_map, krate));
+         middle::effect::check_crate(&ty_cx, krate));
 
     let middle::moves::MoveMaps {moves_map, moved_variables_set,
                                  capture_map} =
         time(time_passes, "compute moves", (), |_|
-             middle::moves::compute_moves(&ty_cx, method_map, krate));
+             middle::moves::compute_moves(&ty_cx, krate));
 
     time(time_passes, "match checking", (), |_|
-         middle::check_match::check_crate(&ty_cx, method_map,
-                                          &moves_map, krate));
+         middle::check_match::check_crate(&ty_cx, &moves_map, krate));
 
     time(time_passes, "liveness checking", (), |_|
-         middle::liveness::check_crate(&ty_cx, method_map,
-                                       &capture_map, krate));
+         middle::liveness::check_crate(&ty_cx, &capture_map, krate));
 
     let root_map =
         time(time_passes, "borrow checking", (), |_|
-             middle::borrowck::check_crate(&ty_cx, method_map,
-                                           &moves_map, &moved_variables_set,
+             middle::borrowck::check_crate(&ty_cx, &moves_map,
+                                           &moved_variables_set,
                                            &capture_map, krate));
 
     drop(moves_map);
     drop(moved_variables_set);
 
     time(time_passes, "kind checking", (), |_|
-         kind::check_crate(&ty_cx, method_map, krate));
+         kind::check_crate(&ty_cx, krate));
 
     let reachable_map =
         time(time_passes, "reachability checking", (), |_|
-             reachable::find_reachable(&ty_cx, method_map, &exported_items));
+             reachable::find_reachable(&ty_cx, &exported_items));
 
     time(time_passes, "death checking", (), |_| {
         middle::dead::check_crate(&ty_cx,
-                                  method_map,
                                   &exported_items,
                                   &reachable_map,
                                   krate)
     });
 
     time(time_passes, "lint checking", (), |_|
-         lint::check_crate(&ty_cx, method_map, &exported_items, krate));
+         lint::check_crate(&ty_cx, &exported_items, krate));
 
     CrateAnalysis {
         exp_map2: exp_map2,
@@ -396,8 +392,6 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         public_items: public_items,
         maps: astencode::Maps {
             root_map: root_map,
-            method_map: method_map,
-            vtable_map: vtable_map,
             capture_map: RefCell::new(capture_map)
         },
         reachable: reachable_map

src/librustc/lib/llvm.rs

@@ -1882,37 +1882,23 @@ impl TypeNames {
 
 /* Memory-managed interface to target data. */
 
-pub struct target_data_res {
-    pub td: TargetDataRef,
+pub struct TargetData {
+    pub lltd: TargetDataRef
 }
 
-impl Drop for target_data_res {
+impl Drop for TargetData {
     fn drop(&mut self) {
         unsafe {
-            llvm::LLVMDisposeTargetData(self.td);
+            llvm::LLVMDisposeTargetData(self.lltd);
         }
     }
 }
 
-pub fn target_data_res(td: TargetDataRef) -> target_data_res {
-    target_data_res {
-        td: td
-    }
-}
-
-pub struct TargetData {
-    pub lltd: TargetDataRef,
-    dtor: @target_data_res
-}
-
 pub fn mk_target_data(string_rep: &str) -> TargetData {
-    let lltd = string_rep.with_c_str(|buf| {
-        unsafe { llvm::LLVMCreateTargetData(buf) }
-    });
-
     TargetData {
-        lltd: lltd,
-        dtor: @target_data_res(lltd)
+        lltd: string_rep.with_c_str(|buf| {
+            unsafe { llvm::LLVMCreateTargetData(buf) }
+        })
     }
 }
 
@@ -1949,35 +1935,22 @@ impl Drop for ObjectFile {
 
 /* Memory-managed interface to section iterators. */
 
-pub struct section_iter_res {
-    pub si: SectionIteratorRef,
+pub struct SectionIter {
+    pub llsi: SectionIteratorRef
 }
 
-impl Drop for section_iter_res {
+impl Drop for SectionIter {
     fn drop(&mut self) {
         unsafe {
-            llvm::LLVMDisposeSectionIterator(self.si);
+            llvm::LLVMDisposeSectionIterator(self.llsi);
         }
     }
 }
 
-pub fn section_iter_res(si: SectionIteratorRef) -> section_iter_res {
-    section_iter_res {
-        si: si
-    }
-}
-
-pub struct SectionIter {
-    pub llsi: SectionIteratorRef,
-    dtor: @section_iter_res
-}
-
 pub fn mk_section_iter(llof: ObjectFileRef) -> SectionIter {
     unsafe {
-        let llsi = llvm::LLVMGetSections(llof);
         SectionIter {
-            llsi: llsi,
-            dtor: @section_iter_res(llsi)
+            llsi: llvm::LLVMGetSections(llof)
         }
     }
 }

src/librustc/metadata/creader.rs

@@ -23,7 +23,6 @@ use metadata::loader;
 use metadata::loader::Os;
 use metadata::loader::CratePaths;
 
-use std::cell::RefCell;
 use std::rc::Rc;
 use collections::HashMap;
 use syntax::ast;
@@ -280,7 +279,7 @@ fn resolve_crate<'a>(e: &mut Env,
                      hash: Option<&Svh>,
                      should_link: bool,
                      span: Span)
-                     -> (ast::CrateNum, @cstore::crate_metadata,
+                     -> (ast::CrateNum, Rc<cstore::crate_metadata>,
                          cstore::CrateSource) {
     match existing_match(e, crate_id, hash) {
         None => {
@@ -317,7 +316,7 @@ fn resolve_crate<'a>(e: &mut Env,
             let cnum_map = if should_link {
                 resolve_crate_deps(e, root, metadata.as_slice(), span)
             } else {
-                @RefCell::new(HashMap::new())
+                HashMap::new()
             };
 
             // Claim this crate number and cache it if we're linking to the
@@ -331,13 +330,13 @@ fn resolve_crate<'a>(e: &mut Env,
                 -1
             };
 
-            let cmeta = @cstore::crate_metadata {
+            let cmeta = Rc::new(cstore::crate_metadata {
                 name: load_ctxt.crate_id.name.to_owned(),
                 data: metadata,
                 cnum_map: cnum_map,
                 cnum: cnum,
                 span: span,
-            };
+            });
 
             let source = cstore::CrateSource {
                 dylib: dylib,
@@ -346,7 +345,7 @@ fn resolve_crate<'a>(e: &mut Env,
             };
 
             if should_link {
-                e.sess.cstore.set_crate_data(cnum, cmeta);
+                e.sess.cstore.set_crate_data(cnum, cmeta.clone());
                 e.sess.cstore.add_used_crate_source(source.clone());
             }
             (cnum, cmeta, source)
@@ -365,20 +364,16 @@ fn resolve_crate_deps(e: &mut Env,
     debug!("resolving deps of external crate");
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
-    let mut cnum_map = HashMap::new();
-    let r = decoder::get_crate_deps(cdata);
-    for dep in r.iter() {
-        let extrn_cnum = dep.cnum;
+    decoder::get_crate_deps(cdata).iter().map(|dep| {
         debug!("resolving dep crate {} hash: `{}`", dep.crate_id, dep.hash);
         let (local_cnum, _, _) = resolve_crate(e, root,
                                                dep.crate_id.name.as_slice(),
                                                &dep.crate_id,
                                                Some(&dep.hash),
                                                true,
                                                span);
-        cnum_map.insert(extrn_cnum, local_cnum);
-    }
-    return @RefCell::new(cnum_map);
+        (dep.cnum, local_cnum)
+    }).collect()
 }
 
 pub struct Loader<'a> {
@@ -407,8 +402,8 @@ impl<'a> CrateLoader for Loader<'a> {
                                                info.ident, &info.crate_id,
                                                None, info.should_link,
                                                krate.span);
-        let macros = decoder::get_exported_macros(data);
-        let registrar = decoder::get_macro_registrar_fn(data).map(|id| {
+        let macros = decoder::get_exported_macros(&*data);
+        let registrar = decoder::get_macro_registrar_fn(&*data).map(|id| {
             decoder::get_symbol(data.data.as_slice(), id)
         });
         MacroCrate {