---

yaml
---
r: 137015
b: refs/heads/dist-snap
c: fe8f430
h: refs/heads/master
i:
  137013: 0d34720
  137011: f704651
  137007: 7c90beb
v: v3

Author: lambda

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 189b7332968972f34cdbbbd9b62d97ababf53059
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 5ca68d4ac15c8ca056306928a5197030a50d3873
+refs/heads/dist-snap: fe8f43030a710eeee1043061145abf2b47c5e601
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/doc/rustdoc.md

@@ -67,7 +67,7 @@ pub use std::option::Option;
 ```
 
 Doc comments are markdown, and are currently parsed with the
-[sundown][sundown] library. rustdoc does not yet do any fanciness such as
+[hoedown][hoedown] library. rustdoc does not yet do any fanciness such as
 referencing other items inline, like javadoc's `@see`. One exception to this
 is that the first paragraph will be used as the "summary" of an item in the
 generated documentation:
@@ -123,7 +123,7 @@ documentation. There is a search bar at the top, which is powered by some
 JavaScript and a statically-generated search index. No special web server is
 required for the search.
 
-[sundown]: https://github.com/vmg/sundown/
+[hoedown]: https://github.com/hoedown/hoedown
 
 # Testing the Documentation
 

branches/dist-snap/src/libcollections/str.rs

@@ -778,11 +778,13 @@ pub trait StrAllocating: Str {
     /// Returns the Levenshtein Distance between two strings.
     fn lev_distance(&self, t: &str) -> uint {
         let me = self.as_slice();
-        if me.is_empty() { return t.char_len(); }
-        if t.is_empty() { return me.char_len(); }
+        let slen = me.len();
+        let tlen = t.len();
 
-        let mut dcol = Vec::from_fn(t.len() + 1, |x| x);
-        let mut t_last = 0;
+        if slen == 0 { return tlen; }
+        if tlen == 0 { return slen; }
+
+        let mut dcol = Vec::from_fn(tlen + 1, |x| x);
 
         for (i, sc) in me.chars().enumerate() {
 
@@ -797,15 +799,15 @@ pub trait StrAllocating: Str {
                     *dcol.get_mut(j + 1) = current;
                 } else {
                     *dcol.get_mut(j + 1) = cmp::min(current, next);
-                    *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1], dcol[j]) + 1;
+                    *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1],
+                                                    dcol[j]) + 1;
                 }
 
                 current = next;
-                t_last = j;
             }
         }
 
-        dcol[t_last + 1]
+        return dcol[tlen];
     }
 
     /// Returns an iterator over the string in Unicode Normalization Form D
@@ -1876,27 +1878,6 @@ mod tests {
         assert_eq!(words, vec!["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
     }
 
-    #[test]
-    fn test_lev_distance() {
-        use std::char::{ from_u32, MAX };
-        // Test bytelength agnosticity
-        for c in range(0u32, MAX as u32)
-                 .filter_map(|i| from_u32(i))
-                 .map(|i| String::from_char(1, i)) {
-            assert_eq!(c[].lev_distance(c[]), 0);
-        }
-
-        let a = "\nMäry häd ä little lämb\n\nLittle lämb\n";
-        let b = "\nMary häd ä little lämb\n\nLittle lämb\n";
-        let c = "Mary häd ä little lämb\n\nLittle lämb\n";
-        assert_eq!(a.lev_distance(b), 1);
-        assert_eq!(b.lev_distance(a), 1);
-        assert_eq!(a.lev_distance(c), 2);
-        assert_eq!(c.lev_distance(a), 2);
-        assert_eq!(b.lev_distance(c), 1);
-        assert_eq!(c.lev_distance(b), 1);
-    }
-
     #[test]
     fn test_nfd_chars() {
         macro_rules! t {

branches/dist-snap/src/libcore/atomic.rs

@@ -382,9 +382,9 @@ impl AtomicInt {
     /// # Examples
     ///
     /// ```
-    /// use std::sync::atomic::{AtomicInt, SeqCst};
+    /// use std::sync::atomic::{AtomicUint, SeqCst};
     ///
-    /// let foo = AtomicInt::new(0b101101);
+    /// let foo = AtomicUint::new(0b101101);
     /// assert_eq!(0b101101, foo.fetch_and(0b110011, SeqCst));
     /// assert_eq!(0b100001, foo.load(SeqCst));
     #[inline]
@@ -397,9 +397,9 @@ impl AtomicInt {
     /// # Examples
     ///
     /// ```
-    /// use std::sync::atomic::{AtomicInt, SeqCst};
+    /// use std::sync::atomic::{AtomicUint, SeqCst};
     ///
-    /// let foo = AtomicInt::new(0b101101);
+    /// let foo = AtomicUint::new(0b101101);
     /// assert_eq!(0b101101, foo.fetch_or(0b110011, SeqCst));
     /// assert_eq!(0b111111, foo.load(SeqCst));
     #[inline]
@@ -412,9 +412,9 @@ impl AtomicInt {
     /// # Examples
     ///
     /// ```
-    /// use std::sync::atomic::{AtomicInt, SeqCst};
+    /// use std::sync::atomic::{AtomicUint, SeqCst};
     ///
-    /// let foo = AtomicInt::new(0b101101);
+    /// let foo = AtomicUint::new(0b101101);
     /// assert_eq!(0b101101, foo.fetch_xor(0b110011, SeqCst));
     /// assert_eq!(0b011110, foo.load(SeqCst));
     #[inline]

branches/dist-snap/src/librustc/middle/trans/reflect.rs

@@ -127,22 +127,6 @@ impl<'a, 'blk, 'tcx> Reflector<'a, 'blk, 'tcx> {
         self.visit(name, []);
     }
 
-    fn visit_closure_ty(&mut self, fty: &ty::ClosureTy, is_unboxed: bool) {
-        let pureval = ast_fn_style_constant(fty.fn_style);
-        let sigilval = match fty.store {
-            ty::UniqTraitStore => 2u,
-            ty::RegionTraitStore(..) => 4u,
-        };
-        let retval = if ty::type_is_bot(fty.sig.output) {0u} else {1u};
-        let extra = vec!(self.c_uint(pureval),
-                         self.c_uint(sigilval),
-                         self.c_uint(fty.sig.inputs.len()),
-                         self.c_uint(retval));
-        self.visit("enter_fn", extra.as_slice());
-        self.visit_sig(retval, &fty.sig, is_unboxed);
-        self.visit("leave_fn", extra.as_slice());
-    }
-
     // Entrypoint
     pub fn visit_ty(&mut self, t: ty::t) {
         let bcx = self.bcx;
@@ -263,8 +247,20 @@ impl<'a, 'blk, 'tcx> Reflector<'a, 'blk, 'tcx> {
 
           // FIXME (#2594): fetch constants out of intrinsic
           // FIXME (#4809): visitor should break out bare fns from other fns
-          ty::ty_closure(box ref fty) => {
-              self.visit_closure_ty(fty, false);
+          ty::ty_closure(ref fty) => {
+            let pureval = ast_fn_style_constant(fty.fn_style);
+            let sigilval = match fty.store {
+                ty::UniqTraitStore => 2u,
+                ty::RegionTraitStore(..) => 4u,
+            };
+            let retval = if ty::type_is_bot(fty.sig.output) {0u} else {1u};
+            let extra = vec!(self.c_uint(pureval),
+                          self.c_uint(sigilval),
+                          self.c_uint(fty.sig.inputs.len()),
+                          self.c_uint(retval));
+            self.visit("enter_fn", extra.as_slice());
+            self.visit_sig(retval, &fty.sig);
+            self.visit("leave_fn", extra.as_slice());
           }
 
           // FIXME (#2594): fetch constants out of intrinsic:: for the
@@ -278,7 +274,7 @@ impl<'a, 'blk, 'tcx> Reflector<'a, 'blk, 'tcx> {
                           self.c_uint(fty.sig.inputs.len()),
                           self.c_uint(retval));
             self.visit("enter_fn", extra.as_slice());
-            self.visit_sig(retval, &fty.sig, false);
+            self.visit_sig(retval, &fty.sig);
             self.visit("leave_fn", extra.as_slice());
           }
 
@@ -392,30 +388,16 @@ impl<'a, 'blk, 'tcx> Reflector<'a, 'blk, 'tcx> {
           // Miscellaneous extra types
           ty::ty_infer(_) => self.leaf("infer"),
           ty::ty_err => self.leaf("err"),
-          ty::ty_unboxed_closure(ref def_id, _) => {
-              let closure_map = tcx.unboxed_closures.borrow();
-              let fty = &closure_map.find(def_id).unwrap().closure_type;
-              self.visit_closure_ty(fty, true);
-          }
+          ty::ty_unboxed_closure(..) => self.leaf("err"),
           ty::ty_param(ref p) => {
               let extra = vec!(self.c_uint(p.idx));
               self.visit("param", extra.as_slice())
           }
         }
     }
 
-    pub fn visit_sig(&mut self, retval: uint, sig: &ty::FnSig, is_unboxed: bool) {
-        let args = if is_unboxed {
-            match ty::get(sig.inputs[0]).sty {
-                ty::ty_tup(ref contents) => contents.iter(),
-                ty::ty_nil => [].iter(),
-                _ => unreachable!()
-            }
-        } else {
-            sig.inputs.iter()
-        };
-
-        for (i, arg) in args.enumerate() {
+    pub fn visit_sig(&mut self, retval: uint, sig: &ty::FnSig) {
+        for (i, arg) in sig.inputs.iter().enumerate() {
             let modeval = 5u;   // "by copy"
             let extra = vec!(self.c_uint(i),
                          self.c_uint(modeval),

branches/dist-snap/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -869,19 +869,6 @@ impl<'a, 'tcx> ErrorReporting for InferCtxt<'a, 'tcx> {
                         ast::TypeImplItem(_) => None,
                     }
                 },
-                ast_map::NodeTraitItem(ref item) => {
-                    match **item {
-                        ast::ProvidedMethod(ref m) => {
-                            Some((m.pe_fn_decl(),
-                                  m.pe_generics(),
-                                  m.pe_fn_style(),
-                                  m.pe_ident(),
-                                  Some(&m.pe_explicit_self().node),
-                                  m.span))
-                        }
-                        _ => None
-                    }
-                }
                 _ => None
             },
             None => None

branches/dist-snap/src/libstd/io/mod.rs

@@ -1293,10 +1293,10 @@ impl<'a> Writer for Box<Writer+'a> {
 
 impl<'a> Writer for &'a mut Writer+'a {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> { (**self).write(buf) }
+    fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.write(buf) }
 
     #[inline]
-    fn flush(&mut self) -> IoResult<()> { (**self).flush() }
+    fn flush(&mut self) -> IoResult<()> { self.flush() }
 }
 
 /// A `RefWriter` is a struct implementing `Writer` which contains a reference