---

yaml
---
r: 137181
b: refs/heads/release-prep
c: 1e22b20
h: refs/heads/master
i:
  137179: b2015f5
v: v3

Author: alexcrichton

[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: 8794107f74682607f368776cc8b78820629778e6
+refs/heads/release-prep: 1e22b2088466eb0e19a58aefcbdaa29858af68e4

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 }
     }
 }
@@ -5073,7 +5074,7 @@ The `channel()` function returns two endpoints: a `Receiver<T>` and a
 `Sender<T>`. You can use the `.send()` method on the `Sender<T>` end, and
 receive the message on the `Receiver<T>` side with the `recv()` method.  This
 method blocks until it gets a message. There's a similar method, `.try_recv()`,
-which returns an `Result<T, TryRecvError>` and does not block.
+which returns an `Option<T>` and does not block.
 
 If you want to send messages to the task as well, create two channels!
 

branches/release-prep/src/libcollections/string.rs

@@ -269,7 +269,7 @@ impl String {
     /// ```
     #[unstable = "error value in return may change"]
     pub fn from_utf16(v: &[u16]) -> Option<String> {
-        let mut s = String::with_capacity(v.len());
+        let mut s = String::with_capacity(v.len() / 2);
         for c in str::utf16_items(v) {
             match c {
                 str::ScalarValue(c) => s.push(c),

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

@@ -596,21 +596,17 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                           ty::FnMutUnboxedClosureKind => ast::Many,
                           ty::FnOnceUnboxedClosureKind => ast::Once,
                       };
-                      if self.typer.capture_mode(fn_node_id) == ast::CaptureByRef {
-                          self.cat_upvar(id, span, var_id, fn_node_id)
-                      } else {
-                          Ok(Rc::new(cmt_ {
-                              id: id,
-                              span: span,
-                              cat: cat_copied_upvar(CopiedUpvar {
-                                  upvar_id: var_id,
-                                  onceness: onceness,
-                                  capturing_proc: fn_node_id,
-                              }),
-                              mutbl: MutabilityCategory::from_local(self.tcx(), var_id),
-                              ty: expr_ty
-                          }))
-                      }
+                      Ok(Rc::new(cmt_ {
+                          id: id,
+                          span: span,
+                          cat: cat_copied_upvar(CopiedUpvar {
+                              upvar_id: var_id,
+                              onceness: onceness,
+                              capturing_proc: fn_node_id,
+                          }),
+                          mutbl: MutabilityCategory::from_local(self.tcx(), var_id),
+                          ty: expr_ty
+                      }))
                   }
                   _ => {
                       self.tcx().sess.span_bug(

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

@@ -301,7 +301,6 @@ fn load_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 fn load_unboxed_closure_environment<'blk, 'tcx>(
                                     bcx: Block<'blk, 'tcx>,
                                     arg_scope_id: ScopeId,
-                                    freevar_mode: ast::CaptureClause,
                                     freevars: &Vec<ty::Freevar>,
                                     closure_id: ast::DefId)
                                     -> Block<'blk, 'tcx> {
@@ -327,14 +326,11 @@ fn load_unboxed_closure_environment<'blk, 'tcx>(
     };
 
     for (i, freevar) in freevars.iter().enumerate() {
-        let mut upvar_ptr = GEPi(bcx, llenv, [0, i]);
-        if freevar_mode == ast::CaptureByRef {
-            upvar_ptr = Load(bcx, upvar_ptr);
-        }
+        let upvar_ptr = GEPi(bcx, llenv, [0, i]);
         let def_id = freevar.def.def_id();
         bcx.fcx.llupvars.borrow_mut().insert(def_id.node, upvar_ptr);
 
-        if kind == ty::FnOnceUnboxedClosureKind && freevar_mode == ast::CaptureByValue {
+        if kind == ty::FnOnceUnboxedClosureKind {
             bcx.fcx.schedule_drop_mem(arg_scope_id,
                                       upvar_ptr,
                                       node_id_type(bcx, def_id.node))
@@ -481,7 +477,6 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
     let freevars: Vec<ty::Freevar> =
         ty::with_freevars(bcx.tcx(), id, |fv| fv.iter().map(|&fv| fv).collect());
     let freevars_ptr = &freevars;
-    let freevar_mode = bcx.tcx().capture_mode(id);
 
     trans_closure(bcx.ccx(),
                   decl,
@@ -498,7 +493,6 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
                   |bcx, arg_scope| {
                       load_unboxed_closure_environment(bcx,
                                                        arg_scope,
-                                                       freevar_mode,
                                                        freevars_ptr,
                                                        closure_id)
                   });
@@ -524,14 +518,7 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
                                                    dest_addr,
                                                    0,
                                                    i);
-        match freevar_mode {
-            ast::CaptureByValue => {
-                bcx = datum.store_to(bcx, upvar_slot_dest);
-            }
-            ast::CaptureByRef => {
-                Store(bcx, datum.to_llref(), upvar_slot_dest);
-            }
-        }
+        bcx = datum.store_to(bcx, upvar_slot_dest);
     }
     adt::trans_set_discr(bcx, &*repr, dest_addr, 0);
 

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

@@ -4634,27 +4634,15 @@ pub struct UnboxedClosureUpvar {
 pub fn unboxed_closure_upvars(tcx: &ctxt, closure_id: ast::DefId)
                               -> Vec<UnboxedClosureUpvar> {
     if closure_id.krate == ast::LOCAL_CRATE {
-        let capture_mode = tcx.capture_modes.borrow().get_copy(&closure_id.node);
         match tcx.freevars.borrow().find(&closure_id.node) {
             None => vec![],
             Some(ref freevars) => {
                 freevars.iter().map(|freevar| {
                     let freevar_def_id = freevar.def.def_id();
-                    let mut freevar_ty = node_id_to_type(tcx, freevar_def_id.node);
-                    if capture_mode == ast::CaptureByRef {
-                        let borrow = tcx.upvar_borrow_map.borrow().get_copy(&ty::UpvarId {
-                            var_id: freevar_def_id.node,
-                            closure_expr_id: closure_id.node
-                        });
-                        freevar_ty = mk_rptr(tcx, borrow.region, ty::mt {
-                            ty: freevar_ty,
-                            mutbl: borrow.kind.to_mutbl_lossy()
-                        });
-                    }
                     UnboxedClosureUpvar {
                         def: freevar.def,
                         span: freevar.span,
-                        ty: freevar_ty
+                        ty: node_id_to_type(tcx, freevar_def_id.node),
                     }
                 }).collect()
             }

branches/release-prep/src/librustc/middle/typeck/check/regionck.rs

@@ -836,7 +836,7 @@ fn check_expr_fn_block(rcx: &mut Rcx,
                     // has static lifetime.
                 } else {
                     // Variables being referenced must outlive closure.
-                    constrain_free_variables_in_by_ref_closure(
+                    constrain_free_variables_in_stack_closure(
                         rcx, bounds.region_bound, expr, freevars);
 
                     // Closure is stack allocated and hence cannot
@@ -848,17 +848,20 @@ fn check_expr_fn_block(rcx: &mut Rcx,
             });
         }
         ty::ty_unboxed_closure(_, region) => {
-            let bounds = ty::region_existential_bound(region);
-            if tcx.capture_modes.borrow().get_copy(&expr.id) == ast::CaptureByRef {
-                ty::with_freevars(tcx, expr.id, |freevars| {
-                    if !freevars.is_empty() {
-                        // Variables being referenced must be constrained and registered
-                        // in the upvar borrow map
-                        constrain_free_variables_in_by_ref_closure(
-                            rcx, bounds.region_bound, expr, freevars);
-                    }
-                })
-            }
+            ty::with_freevars(tcx, expr.id, |freevars| {
+                // No free variables means that there is no environment and
+                // hence the closure has static lifetime. Otherwise, the
+                // closure must not outlive the variables it closes over
+                // by-reference.
+                //
+                // NDM -- this seems wrong, discuss with pcwalton, should
+                // be straightforward enough.
+                if !freevars.is_empty() {
+                    let bounds = ty::region_existential_bound(region);
+                    ensure_free_variable_types_outlive_closure_bound(
+                        rcx, bounds, expr, freevars);
+                }
+            })
         }
         _ => { }
     }
@@ -873,13 +876,6 @@ fn check_expr_fn_block(rcx: &mut Rcx,
                 propagate_upupvar_borrow_kind(rcx, expr, freevars);
             })
         }
-        ty::ty_unboxed_closure(..) => {
-            if tcx.capture_modes.borrow().get_copy(&expr.id) == ast::CaptureByRef {
-                ty::with_freevars(tcx, expr.id, |freevars| {
-                    propagate_upupvar_borrow_kind(rcx, expr, freevars);
-                });
-            }
-        }
         _ => {}
     }
 
@@ -889,12 +885,6 @@ fn check_expr_fn_block(rcx: &mut Rcx,
                 ensure_free_variable_types_outlive_closure_bound(rcx, bounds, expr, freevars);
             })
         }
-        ty::ty_unboxed_closure(_, region) => {
-            ty::with_freevars(tcx, expr.id, |freevars| {
-                let bounds = ty::region_existential_bound(region);
-                ensure_free_variable_types_outlive_closure_bound(rcx, bounds, expr, freevars);
-            })
-        }
         _ => {}
     }
 
@@ -961,7 +951,7 @@ fn check_expr_fn_block(rcx: &mut Rcx,
         }
     }
 
-    fn constrain_free_variables_in_by_ref_closure(
+    fn constrain_free_variables_in_stack_closure(
         rcx: &mut Rcx,
         region_bound: ty::Region,
         expr: &ast::Expr,