rustc: Use the new for protocol

Author: alexcrichton

src/librustc/metadata/csearch.rs

@@ -44,14 +44,24 @@ pub fn get_type_param_count(cstore: @mut cstore::CStore, def: ast::def_id)
 }
 
 /// Iterates over all the language items in the given crate.
+#[cfg(stage0)]
 pub fn each_lang_item(cstore: @mut cstore::CStore,
                       cnum: ast::crate_num,
                       f: &fn(ast::node_id, uint) -> bool) {
     let crate_data = cstore::get_crate_data(cstore, cnum);
     decoder::each_lang_item(crate_data, f)
 }
+/// Iterates over all the language items in the given crate.
+#[cfg(not(stage0))]
+pub fn each_lang_item(cstore: @mut cstore::CStore,
+                      cnum: ast::crate_num,
+                      f: &fn(ast::node_id, uint) -> bool) -> bool {
+    let crate_data = cstore::get_crate_data(cstore, cnum);
+    decoder::each_lang_item(crate_data, f)
+}
 
 /// Iterates over all the paths in the given crate.
+#[cfg(stage0)]
 pub fn each_path(cstore: @mut cstore::CStore,
                  cnum: ast::crate_num,
                  f: &fn(&str, decoder::def_like) -> bool) {
@@ -61,6 +71,17 @@ pub fn each_path(cstore: @mut cstore::CStore,
     };
     decoder::each_path(cstore.intr, crate_data, get_crate_data, f);
 }
+/// Iterates over all the paths in the given crate.
+#[cfg(not(stage0))]
+pub fn each_path(cstore: @mut cstore::CStore,
+                 cnum: ast::crate_num,
+                 f: &fn(&str, decoder::def_like) -> bool) -> bool {
+    let crate_data = cstore::get_crate_data(cstore, cnum);
+    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
+        cstore::get_crate_data(cstore, cnum)
+    };
+    decoder::each_path(cstore.intr, crate_data, get_crate_data, f)
+}
 
 pub fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
     let cstore = tcx.cstore;

src/librustc/metadata/decoder.rs

@@ -196,13 +196,23 @@ fn item_def_id(d: ebml::Doc, cdata: cmd) -> ast::def_id {
                                                     |d| parse_def_id(d)));
 }
 
+#[cfg(stage0)]
 fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) {
     for reader::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| {
         if !f(reexport_doc) {
             return;
         }
     }
 }
+#[cfg(not(stage0))]
+fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) -> bool {
+    for reader::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| {
+        if !f(reexport_doc) {
+            return false;
+        }
+    }
+    return true;
+}
 
 fn variant_disr_val(d: ebml::Doc) -> Option<int> {
     do reader::maybe_get_doc(d, tag_disr_val).chain |val_doc| {
@@ -454,6 +464,7 @@ fn def_like_to_def(def_like: def_like) -> ast::def {
 }
 
 /// Iterates over the language items in the given crate.
+#[cfg(stage0)]
 pub fn each_lang_item(cdata: cmd, f: &fn(ast::node_id, uint) -> bool) {
     let root = reader::Doc(cdata.data);
     let lang_items = reader::get_doc(root, tag_lang_items);
@@ -469,11 +480,29 @@ pub fn each_lang_item(cdata: cmd, f: &fn(ast::node_id, uint) -> bool) {
         }
     }
 }
+/// Iterates over the language items in the given crate.
+#[cfg(not(stage0))]
+pub fn each_lang_item(cdata: cmd, f: &fn(ast::node_id, uint) -> bool) -> bool {
+    let root = reader::Doc(cdata.data);
+    let lang_items = reader::get_doc(root, tag_lang_items);
+    for reader::tagged_docs(lang_items, tag_lang_items_item) |item_doc| {
+        let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id);
+        let id = reader::doc_as_u32(id_doc) as uint;
+        let node_id_doc = reader::get_doc(item_doc,
+                                          tag_lang_items_item_node_id);
+        let node_id = reader::doc_as_u32(node_id_doc) as ast::node_id;
+
+        if !f(node_id, id) {
+            return false;
+        }
+    }
+    return true;
+}
 
 /// Iterates over all the paths in the given crate.
-pub fn each_path(intr: @ident_interner, cdata: cmd,
-                 get_crate_data: GetCrateDataCb,
-                 f: &fn(&str, def_like) -> bool) {
+pub fn _each_path(intr: @ident_interner, cdata: cmd,
+                  get_crate_data: GetCrateDataCb,
+                  f: &fn(&str, def_like) -> bool) -> bool {
     let root = reader::Doc(cdata.data);
     let items = reader::get_doc(root, tag_items);
     let items_data = reader::get_doc(items, tag_items_data);
@@ -555,10 +584,20 @@ pub fn each_path(intr: @ident_interner, cdata: cmd,
         }
     }
 
-    // If broken, stop here.
-    if broken {
-        return;
-    }
+    return broken;
+}
+
+#[cfg(stage0)]
+pub fn each_path(intr: @ident_interner, cdata: cmd,
+                 get_crate_data: GetCrateDataCb,
+                 f: &fn(&str, def_like) -> bool) {
+    _each_path(intr, cdata, get_crate_data, f);
+}
+#[cfg(not(stage0))]
+pub fn each_path(intr: @ident_interner, cdata: cmd,
+                 get_crate_data: GetCrateDataCb,
+                 f: &fn(&str, def_like) -> bool) -> bool {
+    _each_path(intr, cdata, get_crate_data, f)
 }
 
 pub fn get_item_path(intr: @ident_interner, cdata: cmd, id: ast::node_id)

src/librustc/metadata/encoder.rs

@@ -1391,11 +1391,10 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
     ecx.stats.total_bytes = *wr.pos;
 
     if (tcx.sess.meta_stats()) {
-        do wr.bytes.each |e| {
+        for wr.bytes.each |e| {
             if *e == 0 {
                 ecx.stats.zero_bytes += 1;
             }
-            true
         }
 
         io::println("metadata stats:");

src/librustc/metadata/filesearch.rs

@@ -21,7 +21,10 @@ pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
 
 pub trait FileSearch {
     fn sysroot(&self) -> @Path;
+    #[cfg(stage0)]
     fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool);
+    #[cfg(not(stage0))]
+    fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool) -> bool;
     fn get_target_lib_path(&self) -> Path;
     fn get_target_lib_file_path(&self, file: &Path) -> Path;
 }
@@ -37,6 +40,7 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
     }
     impl FileSearch for FileSearchImpl {
         fn sysroot(&self) -> @Path { self.sysroot }
+        #[cfg(stage0)]
         fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool) {
             debug!("filesearch: searching additional lib search paths");
             // a little weird
@@ -60,6 +64,30 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
               result::Err(_) => true
            };
         }
+        #[cfg(not(stage0))]
+        fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool) -> bool {
+            debug!("filesearch: searching additional lib search paths");
+            // a little weird
+            self.addl_lib_search_paths.each(f);
+
+            debug!("filesearch: searching target lib path");
+            if !f(&make_target_lib_path(self.sysroot,
+                                        self.target_triple)) {
+                return false;
+            }
+            debug!("filesearch: searching rustpkg lib path nearest");
+            if match get_rustpkg_lib_path_nearest() {
+                    result::Ok(ref p) => f(p),
+                    result::Err(_) => true
+                } {
+                    return true;
+                }
+           debug!("filesearch: searching rustpkg lib path");
+           match get_rustpkg_lib_path() {
+              result::Ok(ref p) => f(p),
+              result::Err(_) => true
+           }
+        }
         fn get_target_lib_path(&self) -> Path {
             make_target_lib_path(self.sysroot, self.target_triple)
         }

src/librustc/middle/borrowck/check_loans.rs

@@ -67,6 +67,7 @@ enum MoveError {
 pub impl<'self> CheckLoanCtxt<'self> {
     fn tcx(&self) -> ty::ctxt { self.bccx.tcx }
 
+    #[cfg(stage0)]
     fn each_issued_loan(&self,
                         scope_id: ast::node_id,
                         op: &fn(&Loan) -> bool)
@@ -84,7 +85,27 @@ pub impl<'self> CheckLoanCtxt<'self> {
             }
         }
     }
+    #[cfg(not(stage0))]
+    fn each_issued_loan(&self,
+                        scope_id: ast::node_id,
+                        op: &fn(&Loan) -> bool) -> bool
+    {
+        //! Iterates over each loan that that has been issued
+        //! on entrance to `scope_id`, regardless of whether it is
+        //! actually *in scope* at that point.  Sometimes loans
+        //! are issued for future scopes and thus they may have been
+        //! *issued* but not yet be in effect.
+
+        for self.dfcx.each_bit_on_entry(scope_id) |loan_index| {
+            let loan = &self.all_loans[loan_index];
+            if !op(loan) {
+                return false;
+            }
+        }
+        return true;
+    }
 
+    #[cfg(stage0)]
     fn each_in_scope_loan(&self,
                           scope_id: ast::node_id,
                           op: &fn(&Loan) -> bool)
@@ -101,7 +122,26 @@ pub impl<'self> CheckLoanCtxt<'self> {
             }
         }
     }
+    #[cfg(not(stage0))]
+    fn each_in_scope_loan(&self,
+                          scope_id: ast::node_id,
+                          op: &fn(&Loan) -> bool) -> bool
+    {
+        //! Like `each_issued_loan()`, but only considers loans that are
+        //! currently in scope.
 
+        let region_maps = self.tcx().region_maps;
+        for self.each_issued_loan(scope_id) |loan| {
+            if region_maps.is_subscope_of(scope_id, loan.kill_scope) {
+                if !op(loan) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    #[cfg(stage0)]
     fn each_in_scope_restriction(&self,
                                  scope_id: ast::node_id,
                                  loan_path: @LoanPath,
@@ -120,6 +160,26 @@ pub impl<'self> CheckLoanCtxt<'self> {
             }
         }
     }
+    #[cfg(not(stage0))]
+    fn each_in_scope_restriction(&self,
+                                 scope_id: ast::node_id,
+                                 loan_path: @LoanPath,
+                                 op: &fn(&Loan, &Restriction) -> bool) -> bool
+    {
+        //! Iterates through all the in-scope restrictions for the
+        //! given `loan_path`
+
+        for self.each_in_scope_loan(scope_id) |loan| {
+            for loan.restrictions.each |restr| {
+                if restr.loan_path == loan_path {
+                    if !op(loan, restr) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
 
     fn loans_generated_by(&self, scope_id: ast::node_id) -> ~[uint] {
         //! Returns a vector of the loans that are generated as

src/librustc/middle/dataflow.rs

@@ -182,6 +182,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
     }
 
 
+    #[cfg(stage0)]
     pub fn each_bit_on_entry(&self,
                              id: ast::node_id,
                              f: &fn(uint) -> bool) {
@@ -194,7 +195,21 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
                id, bits_to_str(on_entry));
         self.each_bit(on_entry, f);
     }
+    #[cfg(not(stage0))]
+    pub fn each_bit_on_entry(&self,
+                             id: ast::node_id,
+                             f: &fn(uint) -> bool) -> bool {
+        //! Iterates through each bit that is set on entry to `id`.
+        //! Only useful after `propagate()` has been called.
+
+        let (start, end) = self.compute_id_range(id);
+        let on_entry = vec::slice(self.on_entry, start, end);
+        debug!("each_bit_on_entry(id=%?, on_entry=%s)",
+               id, bits_to_str(on_entry));
+        self.each_bit(on_entry, f)
+    }
 
+    #[cfg(stage0)]
     pub fn each_gen_bit(&self,
                         id: ast::node_id,
                         f: &fn(uint) -> bool) {
@@ -206,7 +221,20 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
                id, bits_to_str(gens));
         self.each_bit(gens, f)
     }
+    #[cfg(not(stage0))]
+    pub fn each_gen_bit(&self,
+                        id: ast::node_id,
+                        f: &fn(uint) -> bool) -> bool {
+        //! Iterates through each bit in the gen set for `id`.
 
+        let (start, end) = self.compute_id_range(id);
+        let gens = vec::slice(self.gens, start, end);
+        debug!("each_gen_bit(id=%?, gens=%s)",
+               id, bits_to_str(gens));
+        self.each_bit(gens, f)
+    }
+
+    #[cfg(stage0)]
     fn each_bit(&self,
                 words: &[uint],
                 f: &fn(uint) -> bool) {
@@ -236,6 +264,39 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
             }
         }
     }
+    #[cfg(not(stage0))]
+    fn each_bit(&self,
+                words: &[uint],
+                f: &fn(uint) -> bool) -> bool {
+        //! Helper for iterating over the bits in a bit set.
+
+        for words.eachi |word_index, &word| {
+            if word != 0 {
+                let base_index = word_index * uint::bits;
+                for uint::range(0, uint::bits) |offset| {
+                    let bit = 1 << offset;
+                    if (word & bit) != 0 {
+                        // NB: we round up the total number of bits
+                        // that we store in any given bit set so that
+                        // it is an even multiple of uint::bits.  This
+                        // means that there may be some stray bits at
+                        // the end that do not correspond to any
+                        // actual value.  So before we callback, check
+                        // whether the bit_index is greater than the
+                        // actual value the user specified and stop
+                        // iterating if so.
+                        let bit_index = base_index + offset;
+                        if bit_index >= self.bits_per_id {
+                            return true;
+                        } else if !f(bit_index) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
 }
 
 impl<O:DataFlowOperator+Copy+'static> DataFlowContext<O> {

src/librustc/middle/lang_items.rs

@@ -86,13 +86,18 @@ pub impl LanguageItems {
         }
     }
 
+    #[cfg(stage0)]
     fn each_item(&self, f: &fn(def_id: def_id, i: uint) -> bool) {
         for self.items.eachi |i, &item| {
             if !f(item.get(), i) {
                 break;
             }
         }
     }
+    #[cfg(not(stage0))]
+    fn each_item(&self, f: &fn(def_id: def_id, i: uint) -> bool) -> bool {
+        self.items.eachi(|i, &item| f(item.get(), i))
+    }
 
     pub fn item_name(index: uint) -> &'static str {
         match index {