---

yaml
---
r: 137212
b: refs/heads/release-prep
c: 1f7a8bc
h: refs/heads/master
v: v3

Author: bkoropoff

[refs]

@@ -29,4 +29,4 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/heads/libuv-update-temp-branch: 6ed22c618766f1f2a2e108eef8ce3f51be0f70b7
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
-refs/heads/release-prep: 027d6b4d5301edb1595c23bd55bd893f53a726b7
+refs/heads/release-prep: 1f7a8bcb4b804c9198c2b7315368c9bf8226dfb5

branches/release-prep/mk/docs.mk

@@ -112,8 +112,8 @@ HTML_DEPS += doc/version_info.html
 doc/version_info.html: $(D)/version_info.html.template $(MKFILE_DEPS) \
                        $(wildcard $(D)/*.*) | doc/
 	@$(call E, version-info: $@)
-	$(Q)sed -e "s/VERSION/$(CFG_RELEASE)/; \
-                s/SHORT_HASH/$(CFG_SHORT_VER_HASH)/; \
+	$(Q)sed -e "s/VERSION/$(CFG_RELEASE)/; s/SHORT_HASH/$( \
+                    CFG_SHORT_VER_HASH)/; \
                 s/STAMP/$(CFG_VER_HASH)/;" $< >$@
 
 GENERATED += doc/version.tex doc/version_info.html

branches/release-prep/mk/main.mk

@@ -246,7 +246,7 @@ endif
 ######################################################################
 
 # FIXME: x86-ism
-LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser mcjit \
+LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser jit mcjit \
                 interpreter instrumentation
 
 # Only build these LLVM tools

branches/release-prep/src/doc/guide.md

@@ -961,7 +961,7 @@ struct Point {
 }
 
 fn main() {
-    let origin = Point { x: 0i, y: 0i };
+    let origin = Point { x: 0i, y:  0i };
 
     println!("The origin is at ({}, {})", origin.x, origin.y);
 }
@@ -988,7 +988,7 @@ struct Point {
 }
 
 fn main() {
-    let mut point = Point { x: 0i, y: 0i };
+    let mut point = Point { x: 0i, y:  0i };
 
     point.x = 5;
 
@@ -1140,13 +1140,13 @@ You can have any number of values in an enum:
 ```{rust}
 enum OptionalColor {
     Color(int, int, int),
-    Missing,
+    Missing
 }
 ```
 
 Enums with values are quite useful, but as I mentioned, they're even more
 useful when they're generic across types. But before we get to generics, let's
-talk about how to fix these big `if`/`else` statements we've been writing. We'll
+talk about how to fix this big `if`/`else` statements we've been writing. We'll
 do that with `match`.
 
 # Match
@@ -1561,7 +1561,7 @@ println!("The second name is: {}", names[1]);
 
 These subscripts start at zero, like in most programming languages, so the
 first name is `names[0]` and the second name is `names[1]`. The above example
-prints `The second name is: Brian`.
+prints `The second name is Brian`.
 
 There's a whole lot more to vectors, but that's enough to get started. We have
 now learned all of the most basic Rust concepts. We're ready to start building
@@ -2084,7 +2084,7 @@ fn main() {
     match cmp(input, secret_number) {
         Less    => println!("Too small!"),
         Greater => println!("Too big!"),
-        Equal   => println!("You win!"),
+        Equal   => { println!("You win!"); },
     }
 }
 
@@ -2176,12 +2176,14 @@ fn main() {
                            .expect("Failed to read line");
     let input_num: Option<uint> = from_str(input.as_slice());
 
+
+
     println!("You guessed: {}", input_num);
 
     match cmp(input_num, secret_number) {
         Less    => println!("Too small!"),
         Greater => println!("Too big!"),
-        Equal   => println!("You win!"),
+        Equal   => { println!("You win!"); },
     }
 }
 
@@ -2239,7 +2241,7 @@ fn main() {
     match cmp(num, secret_number) {
         Less    => println!("Too small!"),
         Greater => println!("Too big!"),
-        Equal   => println!("You win!"),
+        Equal   => { println!("You win!"); },
     }
 }
 
@@ -2305,7 +2307,7 @@ fn main() {
     match cmp(num, secret_number) {
         Less    => println!("Too small!"),
         Greater => println!("Too big!"),
-        Equal   => println!("You win!"),
+        Equal   => { println!("You win!"); },
     }
 }
 
@@ -2380,7 +2382,7 @@ fn main() {
         match cmp(num, secret_number) {
             Less    => println!("Too small!"),
             Greater => println!("Too big!"),
-            Equal   => println!("You win!"),
+            Equal   => { println!("You win!"); },
         }
     }
 }
@@ -2617,7 +2619,7 @@ Rust's more unique features.
 
 Rust features a strong module system, but it works a bit differently than in
 other programming languages. Rust's module system has two main components:
-**crate**s and **module**s.
+**crate**s, and **module**s.
 
 A crate is Rust's unit of independent compilation. Rust always compiles one
 crate at a time, producing either a library or an executable. However, executables
@@ -2638,7 +2640,6 @@ Enough talk, let's build something! Let's make a new project called `modules`.
 ```{bash,ignore}
 $ cd ~/projects
 $ cargo new modules --bin
-$ cd modules
 ```
 
 Let's double check our work by compiling:
@@ -3621,7 +3622,7 @@ let x = box 5i;
 ```
 
 This allocates an integer `5` on the heap, and creates a binding `x` that
-refers to it. The great thing about boxed pointers is that we don't have to
+refers to it.. The great thing about boxed pointers is that we don't have to
 manually free this allocation! If we write
 
 ```{rust}
@@ -3993,7 +3994,7 @@ Let's make a closure:
 ```{rust}
 let add_one = |x| { 1i + x };
 
-println!("The sum of 5 plus 1 is {}.", add_one(5i));
+println!("The 5 plus 1 is {}.", add_one(5i));
 ```
 
 We create a closure using the `|...| { ... }` syntax, and then we create a
@@ -4088,7 +4089,7 @@ fn main() {
 }
 ```
 
-Let's break the example down, starting with `main`:
+Let's break example down, starting with `main`:
 
 ```{rust}
 let square = |x: int| { x * x };
@@ -4209,7 +4210,7 @@ loop {
     match range.next() {
         Some(x) => {
             println!("{}", x);
-        },
+        }
         None => { break }
     }
 }

branches/release-prep/src/doc/rustdoc.md

@@ -67,7 +67,7 @@ pub use std::option::Option;
 ```
 
 Doc comments are markdown, and are currently parsed with the
-[hoedown][hoedown] library. rustdoc does not yet do any fanciness such as
+[sundown][sundown] 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.
 
-[hoedown]: https://github.com/hoedown/hoedown
+[sundown]: https://github.com/vmg/sundown/
 
 # Testing the Documentation
 

branches/release-prep/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/release-prep/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/release-prep/src/libcore/intrinsics.rs

@@ -250,13 +250,6 @@ extern "rust-intrinsic" {
     /// Abort the execution of the process.
     pub fn abort() -> !;
 
-    /// Tell LLVM that this point in the code is not reachable,
-    /// enabling further optimizations.
-    ///
-    /// NB: This is very different from the `unreachable!()` macro!
-    #[cfg(not(stage0))]
-    pub fn unreachable() -> !;
-
     /// Execute a breakpoint trap, for inspection by a debugger.
     pub fn breakpoint();
 

branches/release-prep/src/libnative/io/c_unix.rs

@@ -232,9 +232,11 @@ mod signal {
     pub static SA_SIGINFO: libc::c_int = 0x0040;
     pub static SIGCHLD: libc::c_int = 20;
 
-    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "ios")]
     pub type sigset_t = u32;
-    #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg(target_os = "freebsd")]
+    #[cfg(target_os = "dragonfly")]
     #[repr(C)]
     pub struct sigset_t {
         bits: [u32, ..4],
@@ -252,7 +254,8 @@ mod signal {
         pub status: libc::c_int,
     }
 
-    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "ios")]
     #[repr(C)]
     pub struct sigaction {
         pub sa_handler: extern fn(libc::c_int),
@@ -261,7 +264,8 @@ mod signal {
         pub sa_flags: libc::c_int,
     }
 
-    #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg(target_os = "freebsd")]
+    #[cfg(target_os = "dragonfly")]
     #[repr(C)]
     pub struct sigaction {
         pub sa_handler: extern fn(libc::c_int),

branches/release-prep/src/librustc/middle/resolve.rs

@@ -5852,8 +5852,11 @@ impl<'a> Resolver<'a> {
                 visit::walk_expr(self, expr);
             }
 
-            ExprFnBlock(capture_clause, ref fn_decl, ref block) => {
-                self.capture_mode_map.insert(expr.id, capture_clause);
+            ExprFnBlock(_, ref fn_decl, ref block) => {
+                // NOTE(stage0): After snapshot, change to:
+                //
+                //self.capture_mode_map.insert(expr.id, capture_clause);
+                self.capture_mode_map.insert(expr.id, ast::CaptureByRef);
                 self.resolve_function(ClosureRibKind(expr.id, ast::DUMMY_NODE_ID),
                                       Some(&**fn_decl), NoTypeParameters,
                                       &**block);

branches/release-prep/src/librustc/middle/trans/debuginfo.rs

@@ -3164,7 +3164,8 @@ fn populate_scope_map(cx: &CrateContext,
                 parent_scope,
                 file_metadata,
                 loc.line as c_uint,
-                loc.col.to_uint() as c_uint)
+                loc.col.to_uint() as c_uint,
+                0)
         };
 
         scope_stack.push(ScopeStackEntry { scope_metadata: scope_metadata,
@@ -3289,7 +3290,8 @@ fn populate_scope_map(cx: &CrateContext,
                                 parent_scope,
                                 file_metadata,
                                 loc.line as c_uint,
-                                loc.col.to_uint() as c_uint)
+                                loc.col.to_uint() as c_uint,
+                                0)
                         };
 
                         scope_stack.push(ScopeStackEntry {

branches/release-prep/src/librustc/middle/trans/glue.rs

@@ -429,7 +429,7 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
                     tvec::make_drop_glue_unboxed(bcx, v0, ty, true)
                 }
                 ty::ty_str => {
-                    let unit_ty = ty::sequence_element_type(bcx.tcx(), t);
+                    let unit_ty = ty::sequence_element_type(bcx.tcx(), content_ty);
                     tvec::make_drop_glue_unboxed(bcx, v0, unit_ty, true)
                 }
                 ty::ty_trait(..) => {

branches/release-prep/src/librustc/middle/trans/intrinsic.rs

@@ -228,10 +228,6 @@ pub fn trans_intrinsic_call<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, node: ast::N
             Unreachable(bcx);
             v
         }
-        (_, "unreachable") => {
-            Unreachable(bcx);
-            C_nil(ccx)
-        }
         (_, "breakpoint") => {
             let llfn = ccx.get_intrinsic(&("llvm.debugtrap"));
             Call(bcx, llfn, [], None)