---

yaml
---
r: 168517
b: refs/heads/batch
c: c8c0391
h: refs/heads/master
i:
  168515: 74750e3
v: v3

Author: nrc

[refs]

@@ -29,5 +29,5 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/issue-18208-method-dispatch-2: 9e1eae4fb9b6527315b4441cf8a0f5ca911d1671
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
-refs/heads/batch: 47b8479e73e40395f1b1b2d0c6281f28f80301e4
+refs/heads/batch: c8c039151963e29b92978444f2dc6590dd173ece
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970

branches/batch/src/liballoc/rc.rs

@@ -719,6 +719,17 @@ impl<T> Clone for Weak<T> {
     }
 }
 
+#[experimental = "Show is experimental."]
+impl<T: fmt::Show> fmt::Show for Weak<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.strong() == 0 {
+            write!(f, "NULL")
+        } else {
+            (*self._ptr).fmt(f)
+        }
+    }
+}
+
 #[doc(hidden)]
 trait RcBoxPtr<T> {
     fn inner(&self) -> &RcBox<T>;

branches/batch/src/libcollections/str.rs

@@ -202,7 +202,7 @@ impl<'a> Iterator<char> for Decompositions<'a> {
                 let buffer = &mut self.buffer;
                 let sorted = &mut self.sorted;
                 {
-                    let callback = |&mut: d| {
+                    let callback = |d| {
                         let class =
                             unicode::char::canonical_combining_class(d);
                         if class == 0 && !*sorted {

branches/batch/src/libcore/cell.rs

@@ -158,6 +158,7 @@
 use clone::Clone;
 use cmp::PartialEq;
 use default::Default;
+use fmt;
 use kinds::{Copy, Send};
 use ops::{Deref, DerefMut, Drop};
 use option::Option;
@@ -365,6 +366,16 @@ impl<T: PartialEq> PartialEq for RefCell<T> {
     }
 }
 
+#[unstable]
+impl<T:fmt::Show> fmt::Show for RefCell<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.try_borrow() {
+            Some(val) => write!(f, "{}", val),
+            None => write!(f, "<borrowed RefCell>")
+        }
+    }
+}
+
 struct BorrowRef<'b> {
     _borrow: &'b Cell<BorrowFlag>,
 }

branches/batch/src/libcore/fmt/float.rs

@@ -225,10 +225,10 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
         // cut off the one extra digit, and depending on its value
         // round the remaining ones.
         if limit_digits && dig == digit_count {
-            let ascii2value = |&: chr: u8| {
+            let ascii2value = |chr: u8| {
                 (chr as char).to_digit(radix).unwrap()
             };
-            let value2ascii = |&: val: uint| {
+            let value2ascii = |val: uint| {
                 char::from_digit(val, radix).unwrap() as u8
             };
 

branches/batch/src/libcore/fmt/mod.rs

@@ -398,7 +398,7 @@ impl<'a> Formatter<'a> {
         }
 
         // Writes the sign if it exists, and then the prefix if it was requested
-        let write_prefix = |&: f: &mut Formatter| {
+        let write_prefix = |f: &mut Formatter| {
             for c in sign.into_iter() {
                 let mut b = [0, ..4];
                 let n = c.encode_utf8(&mut b).unwrap_or(0);

branches/batch/src/libgetopts/lib.rs

@@ -875,7 +875,7 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where
         lim = fake_i;
     }
 
-    let mut machine = |&mut: cont: &mut bool, (i, c): (uint, char)| -> bool {
+    let machine: |&mut bool, (uint, char)| -> bool = |cont, (i, c)| {
         let whitespace = if c.is_whitespace() { Ws }       else { Cr };
         let limit      = if (i - slice_start + 1) <= lim  { UnderLim } else { OverLim };
 

branches/batch/src/librustc/metadata/creader.rs

@@ -177,7 +177,7 @@ fn extract_crate_info(e: &Env, i: &ast::ViewItem) -> Option<CrateInfo> {
 }
 
 pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
-    let err = |&: s: &str| {
+    let err = |s: &str| {
         match (sp, sess) {
             (_, None) => panic!("{}", s),
             (Some(sp), Some(sess)) => sess.span_err(sp, s),

branches/batch/src/librustc/metadata/csearch.rs

@@ -62,7 +62,7 @@ pub fn each_child_of_item<F>(cstore: &cstore::CStore,
     F: FnMut(decoder::DefLike, ast::Name, ast::Visibility),
 {
     let crate_data = cstore.get_crate_data(def_id.krate);
-    let get_crate_data = |&mut: cnum| {
+    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
         cstore.get_crate_data(cnum)
     };
     decoder::each_child_of_item(cstore.intr.clone(),
@@ -79,7 +79,7 @@ pub fn each_top_level_item_of_crate<F>(cstore: &cstore::CStore,
     F: FnMut(decoder::DefLike, ast::Name, ast::Visibility),
 {
     let crate_data = cstore.get_crate_data(cnum);
-    let get_crate_data = |&mut: cnum| {
+    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
         cstore.get_crate_data(cnum)
     };
     decoder::each_top_level_item_of_crate(cstore.intr.clone(),

branches/batch/src/librustc/metadata/decoder.rs

@@ -487,13 +487,14 @@ pub fn each_lang_item<F>(cdata: Cmd, mut f: F) -> bool where
     })
 }
 
-fn each_child_of_item_or_crate<F, G>(intr: Rc<IdentInterner>,
-                                     cdata: Cmd,
-                                     item_doc: rbml::Doc,
-                                     mut get_crate_data: G,
-                                     mut callback: F) where
+pub type GetCrateDataCb<'a> = |ast::CrateNum|: 'a -> Rc<crate_metadata>;
+
+fn each_child_of_item_or_crate<F>(intr: Rc<IdentInterner>,
+                                  cdata: Cmd,
+                                  item_doc: rbml::Doc,
+                                  get_crate_data: GetCrateDataCb,
+                                  mut callback: F) where
     F: FnMut(DefLike, ast::Name, ast::Visibility),
-    G: FnMut(ast::CrateNum) -> Rc<crate_metadata>,
 {
     // Iterate over all children.
     let _ = reader::tagged_docs(item_doc, tag_mod_child, |child_info_doc| {
@@ -607,13 +608,12 @@ fn each_child_of_item_or_crate<F, G>(intr: Rc<IdentInterner>,
 }
 
 /// Iterates over each child of the given item.
-pub fn each_child_of_item<F, G>(intr: Rc<IdentInterner>,
-                               cdata: Cmd,
-                               id: ast::NodeId,
-                               get_crate_data: G,
-                               callback: F) where
+pub fn each_child_of_item<F>(intr: Rc<IdentInterner>,
+                             cdata: Cmd,
+                             id: ast::NodeId,
+                             get_crate_data: GetCrateDataCb,
+                             callback: F) where
     F: FnMut(DefLike, ast::Name, ast::Visibility),
-    G: FnMut(ast::CrateNum) -> Rc<crate_metadata>,
 {
     // Find the item.
     let root_doc = rbml::Doc::new(cdata.data());
@@ -631,12 +631,11 @@ pub fn each_child_of_item<F, G>(intr: Rc<IdentInterner>,
 }
 
 /// Iterates over all the top-level crate items.
-pub fn each_top_level_item_of_crate<F, G>(intr: Rc<IdentInterner>,
-                                          cdata: Cmd,
-                                          get_crate_data: G,
-                                          callback: F) where
+pub fn each_top_level_item_of_crate<F>(intr: Rc<IdentInterner>,
+                                       cdata: Cmd,
+                                       get_crate_data: GetCrateDataCb,
+                                       callback: F) where
     F: FnMut(DefLike, ast::Name, ast::Visibility),
-    G: FnMut(ast::CrateNum) -> Rc<crate_metadata>,
 {
     let root_doc = rbml::Doc::new(cdata.data());
     let misc_info_doc = reader::get_doc(root_doc, tag_misc_info);

branches/batch/src/librustc/metadata/encoder.rs

@@ -1402,7 +1402,6 @@ fn encode_info_for_item(ecx: &EncodeContext,
                 }
                 ty::TypeTraitItem(associated_type) => {
                     encode_name(rbml_w, associated_type.name);
-                    encode_def_id(rbml_w, associated_type.def_id);
 
                     let elem = ast_map::PathName(associated_type.name);
                     encode_path(rbml_w,
@@ -1418,7 +1417,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
             encode_parent_sort(rbml_w, 't');
 
             let trait_item = &ms[i];
-            let encode_trait_item = |&: rbml_w: &mut Encoder| {
+            let encode_trait_item = |rbml_w: &mut Encoder| {
                 // If this is a static method, we've already
                 // encoded this.
                 if is_nonstatic_method {

branches/batch/src/librustc/metadata/filesearch.rs

@@ -30,6 +30,10 @@ pub enum FileMatch {
 // FIXME (#2658): I'm not happy how this module turned out. Should
 // probably just be folded into cstore.
 
+/// Functions with type `pick` take a parent directory as well as
+/// a file found in that directory.
+pub type pick<'a> = |path: &Path|: 'a -> FileMatch;
+
 pub struct FileSearch<'a> {
     pub sysroot: &'a Path,
     pub search_paths: &'a SearchPaths,
@@ -91,7 +95,7 @@ impl<'a> FileSearch<'a> {
         make_target_lib_path(self.sysroot, self.triple)
     }
 
-    pub fn search<F>(&self, mut pick: F) where F: FnMut(&Path) -> FileMatch {
+    pub fn search(&self, pick: pick) {
         self.for_each_lib_search_path(|lib_search_path| {
             debug!("searching {}", lib_search_path.display());
             match fs::readdir(lib_search_path) {

branches/batch/src/librustc/middle/check_const.rs

@@ -185,7 +185,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
         ast::ExprBlock(ref block) => {
             // Check all statements in the block
             for stmt in block.stmts.iter() {
-                let block_span_err = |&: span|
+                let block_span_err = |span|
                     span_err!(v.tcx.sess, span, E0016,
                               "blocks in constants are limited to items and \
                                tail expressions");

branches/batch/src/librustc/middle/check_match.rs

@@ -1012,7 +1012,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
         })
     }
 
-    let check_move = |&: p: &Pat, sub: Option<&Pat>| {
+    let check_move: |&Pat, Option<&Pat>| = |p, sub| {
         // check legality of moving out of the enum
 
         // x @ Foo(..) is legal, but x @ Foo(y) isn't.

branches/batch/src/librustc/middle/infer/region_inference/graphviz.rs

@@ -136,7 +136,7 @@ impl<'a, 'tcx> ConstraintGraph<'a, 'tcx> {
         let mut i = 0;
         let mut node_ids = FnvHashMap::new();
         {
-            let mut add_node = |&mut : node| {
+            let add_node = |node| {
                 if let Vacant(e) = node_ids.entry(node) {
                     e.set(i);
                     i += 1;

branches/batch/src/librustc/middle/mem_categorization.rs

@@ -1122,15 +1122,11 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
         })
     }
 
-    pub fn cat_pattern<F>(&self, cmt: cmt<'tcx>, pat: &ast::Pat, mut op: F) where
-        F: FnMut(&MemCategorizationContext<'t, TYPER>, cmt<'tcx>, &ast::Pat),
-    {
-        self.cat_pattern_(cmt, pat, &mut op)
-    }
-
-    // FIXME(#19596) This is a workaround, but there should be a better way to do this
-    fn cat_pattern_<F>(&self, cmt: cmt<'tcx>, pat: &ast::Pat, op: &mut F) where
-        F: FnMut(&MemCategorizationContext<'t, TYPER>, cmt<'tcx>, &ast::Pat),
+    // FIXME(#19596) unbox `op`
+    pub fn cat_pattern(&self,
+                       cmt: cmt<'tcx>,
+                       pat: &ast::Pat,
+                       op: |&MemCategorizationContext<'t, TYPER>, cmt<'tcx>, &ast::Pat|)
     {
         // Here, `cmt` is the categorization for the value being
         // matched and pat is the pattern it is being matched against.
@@ -1181,7 +1177,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                pat.id, pprust::pat_to_string(pat),
                cmt.repr(self.tcx()));
 
-        (*op)(self, cmt.clone(), pat);
+        op(self, cmt.clone(), pat);
 
         let def_map = self.tcx().def_map.borrow();
         let opt_def = def_map.get(&pat.id);
@@ -1218,7 +1214,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                                 pat, cmt.clone(), subpat_ty,
                                 InteriorField(PositionalField(i)));
 
-                        self.cat_pattern_(subcmt, &**subpat, op);
+                        self.cat_pattern(subcmt, &**subpat, |x,y,z| op(x,y,z));
                     }
                 }
                 Some(&def::DefStruct(..)) => {
@@ -1228,12 +1224,13 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                             self.cat_imm_interior(
                                 pat, cmt.clone(), subpat_ty,
                                 InteriorField(PositionalField(i)));
-                        self.cat_pattern_(cmt_field, &**subpat, op);
+                        self.cat_pattern(cmt_field, &**subpat,
+                                         |x,y,z| op(x,y,z));
                     }
                 }
                 Some(&def::DefConst(..)) => {
                     for subpat in subpats.iter() {
-                        self.cat_pattern_(cmt.clone(), &**subpat, op);
+                        self.cat_pattern(cmt.clone(), &**subpat, |x,y,z| op(x,y,z));
                     }
                 }
                 _ => {
@@ -1245,7 +1242,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
           }
 
           ast::PatIdent(_, _, Some(ref subpat)) => {
-              self.cat_pattern_(cmt, &**subpat, op);
+              self.cat_pattern(cmt, &**subpat, op);
           }
 
           ast::PatIdent(_, _, None) => {
@@ -1257,7 +1254,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             for fp in field_pats.iter() {
                 let field_ty = self.pat_ty(&*fp.node.pat); // see (*2)
                 let cmt_field = self.cat_field(pat, cmt.clone(), fp.node.ident.name, field_ty);
-                self.cat_pattern_(cmt_field, &*fp.node.pat, op);
+                self.cat_pattern(cmt_field, &*fp.node.pat, |x,y,z| op(x,y,z));
             }
           }
 
@@ -1269,28 +1266,29 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                     self.cat_imm_interior(
                         pat, cmt.clone(), subpat_ty,
                         InteriorField(PositionalField(i)));
-                self.cat_pattern_(subcmt, &**subpat, op);
+                self.cat_pattern(subcmt, &**subpat, |x,y,z| op(x,y,z));
             }
           }
 
           ast::PatBox(ref subpat) | ast::PatRegion(ref subpat) => {
             // @p1, ~p1, ref p1
             let subcmt = self.cat_deref(pat, cmt, 0, false);
-            self.cat_pattern_(subcmt, &**subpat, op);
+            self.cat_pattern(subcmt, &**subpat, op);
           }
 
           ast::PatVec(ref before, ref slice, ref after) => {
               let elt_cmt = self.cat_index(pat, self.deref_vec(pat, cmt));
               for before_pat in before.iter() {
-                  self.cat_pattern_(elt_cmt.clone(), &**before_pat, op);
+                  self.cat_pattern(elt_cmt.clone(), &**before_pat,
+                                   |x,y,z| op(x,y,z));
               }
               for slice_pat in slice.iter() {
                   let slice_ty = self.pat_ty(&**slice_pat);
                   let slice_cmt = self.cat_rvalue_node(pat.id(), pat.span(), slice_ty);
-                  self.cat_pattern_(slice_cmt, &**slice_pat, op);
+                  self.cat_pattern(slice_cmt, &**slice_pat, |x,y,z| op(x,y,z));
               }
               for after_pat in after.iter() {
-                  self.cat_pattern_(elt_cmt.clone(), &**after_pat, op);
+                  self.cat_pattern(elt_cmt.clone(), &**after_pat, |x,y,z| op(x,y,z));
               }
           }
 

branches/batch/src/librustc/middle/privacy.rs

@@ -749,7 +749,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
     fn check_path(&mut self, span: Span, path_id: ast::NodeId, path: &ast::Path) {
         debug!("privacy - path {}", self.nodestr(path_id));
         let orig_def = self.tcx.def_map.borrow()[path_id].clone();
-        let ck = |&: tyname: &str| {
+        let ck = |tyname: &str| {
             let ck_public = |def: ast::DefId| {
                 let name = token::get_ident(path.segments.last().unwrap().identifier);
                 let origdid = orig_def.def_id();
@@ -921,7 +921,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
                 }
             }
             ast::ExprPath(..) => {
-                let guard = |&: did: ast::DefId| {
+                let guard = |did: ast::DefId| {
                     let fields = ty::lookup_struct_fields(self.tcx, did);
                     let any_priv = fields.iter().any(|f| {
                         f.vis != ast::Public && (
@@ -1126,7 +1126,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
     /// later on down the road...
     fn check_sane_privacy(&self, item: &ast::Item) {
         let tcx = self.tcx;
-        let check_inherited = |&: sp: Span, vis: ast::Visibility, note: &str| {
+        let check_inherited = |sp: Span, vis: ast::Visibility, note: &str| {
             if vis != ast::Inherited {
                 tcx.sess.span_err(sp, "unnecessary visibility qualifier");
                 if note.len() > 0 {
@@ -1206,7 +1206,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
                 tcx.sess.span_err(sp, "visibility has no effect inside functions");
             }
         }
-        let check_struct = |&: def: &ast::StructDef| {
+        let check_struct = |def: &ast::StructDef| {
             for f in def.fields.iter() {
                match f.node.kind {
                     ast::NamedField(_, p) => check_inherited(tcx, f.span, p),

branches/batch/src/librustc/middle/region.rs

@@ -488,7 +488,7 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) {
 
     {
         let region_maps = &mut visitor.region_maps;
-        let terminating = |&: id| {
+        let terminating = |id| {
             let scope = CodeExtent::from_node_id(id);
             region_maps.mark_as_terminating_scope(scope)
         };