---

yaml
---
r: 138357
b: refs/heads/auto
c: 4bb21f3
h: refs/heads/master
i:
  138355: 8f0f6d2
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: cef0b55c787bb8b827e0111e1c6ccc1373b663da
+refs/heads/auto: 4bb21f37efd7a22f2c7a2f639e6c76e645c760c3
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide.md

@@ -1255,8 +1255,9 @@ version, if we had forgotten the `Greater` case, for example, our program would
 have happily compiled. If we forget in the `match`, it will not. Rust helps us
 make sure to cover all of our bases.
 
-`match` is also an expression, which means we can use it on the right hand side
-of a `let` binding. We could also implement the previous line like this:
+`match` is also an expression, which means we can use it on the right
+hand side of a `let` binding or directly where an expression is
+used. We could also implement the previous line like this:
 
 ```{rust}
 fn cmp(a: int, b: int) -> Ordering {
@@ -1269,18 +1270,15 @@ fn main() {
     let x = 5i;
     let y = 10i;
 
-    let result = match cmp(x, y) {
+    println!("{}", match cmp(x, y) {
         Less    => "less",
         Greater => "greater",
         Equal   => "equal",
-    };
-
-    println!("{}", result);
+    });
 }
 ```
 
-In this case, it doesn't make a lot of sense, as we are just making a temporary
-string where we don't need to, but sometimes, it's a nice pattern.
+Sometimes, it's a nice pattern.
 
 # Looping
 

branches/auto/src/libcollections/lib.rs

@@ -10,7 +10,7 @@
 
 //! Collection types.
 //!
-//! See [../std/collections](std::collections) for a detailed discussion of collections in Rust.
+//! See [std::collections](../std/collections) for a detailed discussion of collections in Rust.
 
 
 #![crate_name = "collections"]

branches/auto/src/libcore/ops.rs

@@ -626,7 +626,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * struct Foo;
  *
  * impl Index<Foo, Foo> for Foo {
- *     fn index<'a>(&'a self, _rhs: &Foo) -> &'a Foo {
+ *     fn index<'a>(&'a self, _index: &Foo) -> &'a Foo {
  *         println!("Indexing!");
  *         self
  *     }
@@ -657,7 +657,7 @@ pub trait Index<Index, Result> {
  * struct Foo;
  *
  * impl IndexMut<Foo, Foo> for Foo {
- *     fn index_mut<'a>(&'a mut self, _rhs: &Foo) -> &'a mut Foo {
+ *     fn index_mut<'a>(&'a mut self, _index: &Foo) -> &'a mut Foo {
  *         println!("Indexing!");
  *         self
  *     }
@@ -687,20 +687,20 @@ pub trait IndexMut<Index, Result> {
  * ```ignore
  * struct Foo;
  *
- * impl ::core::ops::Slice<Foo, Foo> for Foo {
+ * impl Slice<Foo, Foo> for Foo {
  *     fn as_slice_<'a>(&'a self) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_from_or_fail<'a>(&'a self, from: &Foo) -> &'a Foo {
+ *     fn slice_from_or_fail<'a>(&'a self, _from: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_to_or_fail<'a>(&'a self, to: &Foo) -> &'a Foo {
+ *     fn slice_to_or_fail<'a>(&'a self, _to: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_or_fail<'a>(&'a self, from: &Foo, to: &Foo) -> &'a Foo {
+ *     fn slice_or_fail<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
@@ -736,20 +736,20 @@ pub trait Slice<Idx, Sized? Result> for Sized? {
  * ```ignore
  * struct Foo;
  *
- * impl ::core::ops::SliceMut<Foo, Foo> for Foo {
+ * impl SliceMut<Foo, Foo> for Foo {
  *     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_from_or_fail_mut<'a>(&'a mut self, from: &Foo) -> &'a mut Foo {
+ *     fn slice_from_or_fail_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_to_or_fail_mut<'a>(&'a mut self, to: &Foo) -> &'a mut Foo {
+ *     fn slice_to_or_fail_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_or_fail_mut<'a>(&'a mut self, from: &Foo, to: &Foo) -> &'a mut Foo {
+ *     fn slice_or_fail_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
@@ -901,4 +901,3 @@ def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12)
 def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13)
 def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14)
 def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15)
-

branches/auto/src/librustc/middle/check_static.rs

@@ -57,13 +57,15 @@ struct GlobalChecker {
     static_consumptions: NodeSet,
     const_borrows: NodeSet,
     static_interior_borrows: NodeSet,
+    static_local_borrows: NodeSet,
 }
 
 pub fn check_crate(tcx: &ty::ctxt) {
     let mut checker = GlobalChecker {
         static_consumptions: NodeSet::new(),
         const_borrows: NodeSet::new(),
         static_interior_borrows: NodeSet::new(),
+        static_local_borrows: NodeSet::new(),
     };
     {
         let visitor = euv::ExprUseVisitor::new(&mut checker, tcx);
@@ -200,6 +202,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> {
             }
         }
 
+        // local variables in a block expression in a static context (i.e. being
+        // assigned to a static variable) cannot be borrowed.
+        if self.checker.static_local_borrows.remove(&e.id) {
+            self.tcx.sess.span_err(e.span, "cannot borrow a local variable inside \
+                                            a static block, define a separate static \
+                                            instead");
+        }
+
         match e.node {
             ast::ExprAddrOf(ast::MutMutable, _) => {
                 if self.mode != InStaticMut {
@@ -298,8 +308,12 @@ impl euv::Delegate for GlobalChecker {
 
                 mc::cat_downcast(..) |
                 mc::cat_discr(..) |
-                mc::cat_upvar(..) |
-                mc::cat_local(..) => unreachable!(),
+                mc::cat_upvar(..) => unreachable!(),
+
+                mc::cat_local(..) => {
+                    self.static_local_borrows.insert(borrow_id);
+                    break
+                }
             }
         }
     }

branches/auto/src/librustc/middle/trans/_match.rs

@@ -1090,7 +1090,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let sw = if kind == Switch {
         build::Switch(bcx, test_val, else_cx.llbb, opts.len())
     } else {
-        C_int(ccx, 0) // Placeholder for when not using a switch
+        C_int(ccx, 0i) // Placeholder for when not using a switch
     };
 
     let defaults = enter_default(else_cx, dm, m, col, val);