---

yaml
---
r: 137190
b: refs/heads/release-prep
c: 4c166ab
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: a2e7c4da9b331d337fba0b3911c6d3d7f48e8305
+refs/heads/release-prep: 4c166abbbb4e11f9464f97a468fcd34dbc3d2fb5

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/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/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/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/release-prep/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -869,6 +869,19 @@ 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/release-prep/src/libsyntax/codemap.rs

@@ -291,8 +291,10 @@ impl FileMap {
 
     /// get a line from the list of pre-computed line-beginnings
     ///
+    /// NOTE(stage0, pcwalton): Remove `#[allow(unused_mut)]` after snapshot.
+    #[allow(unused_mut)]
     pub fn get_line(&self, line: int) -> String {
-        let lines = self.lines.borrow();
+        let mut lines = self.lines.borrow_mut();
         let begin: BytePos = *lines.get(line as uint) - self.start_pos;
         let begin = begin.to_uint();
         let slice = self.src.as_slice().slice_from(begin);
@@ -513,14 +515,16 @@ impl CodeMap {
         return a;
     }
 
+    // NOTE(stage0, pcwalton): Remove `#[allow(unused_mut)]` after snapshot.
+    #[allow(unused_mut)]
     fn lookup_line(&self, pos: BytePos) -> FileMapAndLine {
         let idx = self.lookup_filemap_idx(pos);
 
         let files = self.files.borrow();
         let f = files.get(idx).clone();
         let mut a = 0u;
         {
-            let lines = f.lines.borrow();
+            let mut lines = f.lines.borrow_mut();
             let mut b = lines.len();
             while b - a > 1u {
                 let m = (a + b) / 2u;

branches/release-prep/src/snapshots.txt

@@ -1,12 +1,3 @@
-S 2014-10-04 749ff5e
-  freebsd-x86_64 f39d94487d29b3d48217b1295ad2cda8c941e694
-  linux-i386 555aca74f9a268f80cab2df1147dc6406403e9e4
-  linux-x86_64 6a43c2f6c8ba2cbbcb9da1f7b58f748aef99f431
-  macos-i386 331bd7ef519cbb424188c546273e8c7d738f0894
-  macos-x86_64 2c83a79a9febfe1d326acb17c3af76ba053c6ca9
-  winnt-i386 fcf0526e5dc7ca4b149e074ff056ac03e2240ac7
-  winnt-x86_64 611f19816fbfe0730b1fee51481b8d25dd78fa10
-
 S 2014-09-28 7eb9337
   freebsd-x86_64 d45e0edd44f40a976ea0affaadd98732684cfca0
   linux-i386 3acb35755aa62b7ff78f76007d9a70696fce7aa7

branches/release-prep/src/test/run-pass-fulldeps/roman-numerals-macro.rs

@@ -10,10 +10,11 @@
 
 // aux-build:roman_numerals.rs
 // ignore-stage1
+// ignore-android
 
 #![feature(phase)]
 
-#[phase(plugin)]
+#[phase(plugin, link)]
 extern crate roman_numerals;
 
 pub fn main() {