librustc: Disallow "mut" from distributing over bindings.

This is the backwards-incompatible part of per-binding-site "mut".

Author: pcwalton

doc/rust.md

@@ -2862,13 +2862,13 @@ call to the method `make_string`.
 Types in Rust are categorized into kinds, based on various properties of the components of the type.
 The kinds are:
 
-`Const`
+`Freeze`
   : Types of this kind are deeply immutable;
     they contain no mutable memory locations directly or indirectly via pointers.
-`Owned`
+`Send`
   : Types of this kind can be safely sent between tasks.
     This kind includes scalars, owning pointers, owned closures, and
-    structural types containing only other owned types. All `Owned` types are `Static`.
+    structural types containing only other owned types. All `Send` types are `Static`.
 `Static`
   : Types of this kind do not contain any borrowed pointers;
     this can be a useful guarantee for code that breaks borrowing assumptions using [`unsafe` operations](#unsafe-functions).
@@ -2882,7 +2882,7 @@ The kinds are:
     trait provides a single method `finalize` that takes no parameters, and is run
     when values of the type are dropped. Such a method is called a "destructor",
     and are always executed in "top-down" order: a value is completely destroyed
-    before any of the values it owns run their destructors. Only `Owned` types
+    before any of the values it owns run their destructors. Only `Send` types
     that do not implement `Copy` can implement `Drop`.
 
 > **Note:** The `finalize` method may be renamed in future versions of Rust.
@@ -2968,10 +2968,10 @@ frame they are allocated within.
 A task owns all memory it can *safely* reach through local variables,
 as well as managed, owning and borrowed pointers.
 
-When a task sends a value that has the `Owned` trait to another task,
+When a task sends a value that has the `Send` trait to another task,
 it loses ownership of the value sent and can no longer refer to it.
 This is statically guaranteed by the combined use of "move semantics",
-and the compiler-checked _meaning_ of the `Owned` trait:
+and the compiler-checked _meaning_ of the `Send` trait:
 it is only instantiated for (transitively) sendable kinds of data constructor and pointers,
 never including managed or borrowed pointers.
 
@@ -3116,7 +3116,7 @@ These include:
   - read-only and read-write shared variables with various safe mutual exclusion patterns
   - simple locks and semaphores
 
-When such facilities carry values, the values are restricted to the [`Owned` type-kind](#type-kinds).
+When such facilities carry values, the values are restricted to the [`Send` type-kind](#type-kinds).
 Restricting communication interfaces to this kind ensures that no borrowed or managed pointers move between tasks.
 Thus access to an entire data structure can be mediated through its owning "root" value;
 no further locking or copying is required to avoid data races within the substructure of such a value.

doc/tutorial-ffi.md

@@ -159,7 +159,7 @@ pub struct Unique<T> {
     priv ptr: *mut T
 }
 
-impl<T: Owned> Unique<T> {
+impl<T: Send> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         unsafe {
             let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
@@ -182,7 +182,7 @@ impl<T: Owned> Unique<T> {
 }
 
 #[unsafe_destructor]
-impl<T: Owned> Drop for Unique<T> {
+impl<T: Send> Drop for Unique<T> {
     fn drop(&self) {
         unsafe {
             let x = intrinsics::init(); // dummy value to swap in

src/libextra/md4.rs

@@ -59,7 +59,8 @@ pub fn md4(msg: &[u8]) -> Quad {
     while i < e {
         let (aa, bb, cc, dd) = (a, b, c, d);
 
-        let mut (j, base) = (0u, i);
+        let mut j = 0u;
+        let mut base = i;
         while j < 16u {
             x[j] = (msg[base] as u32) + (msg[base + 1u] as u32 << 8u32) +
                 (msg[base + 2u] as u32 << 16u32) +

src/libextra/net_url.rs

@@ -415,7 +415,9 @@ fn get_authority(rawurl: &str) ->
     let mut port = None;
 
     let mut colon_count = 0;
-    let mut (pos, begin, end) = (0, 2, len);
+    let mut pos = 0;
+    let mut begin = 2;
+    let mut end = len;
 
     for rawurl.iter().enumerate().advance |(i,c)| {
         if i < 2 { loop; } // ignore the leading //

src/libextra/num/bigint.rs

@@ -380,7 +380,10 @@ impl Integer for BigUint {
             let mut d = Zero::zero::<BigUint>();
             let mut n = 1;
             while m >= b {
-                let mut (d0, d_unit, b_unit) = div_estimate(&m, &b, n);
+                let (d0, d_unit, b_unit) = div_estimate(&m, &b, n);
+                let mut d0 = d0;
+                let mut d_unit = d_unit;
+                let mut b_unit = b_unit;
                 let mut prod = b * d0;
                 while prod > m {
                     // FIXME(#6050): overloaded operators force moves with generic types
@@ -442,7 +445,8 @@ impl Integer for BigUint {
 
     fn gcd(&self, other: &BigUint) -> BigUint {
         // Use Euclid's algorithm
-        let mut (m, n) = (copy *self, copy *other);
+        let mut m = copy *self;
+        let mut n = copy *other;
         while !m.is_zero() {
             let temp = m;
             m = n % temp;

src/libextra/timer.rs

@@ -123,7 +123,9 @@ pub fn recv_timeout<T:Copy + Send>(iotask: &IoTask,
                                    msecs: uint,
                                    wait_po: &Port<T>)
                                    -> Option<T> {
-    let mut (timeout_po, timeout_ch) = stream::<()>();
+    let (timeout_po, timeout_ch) = stream::<()>();
+    let mut timeout_po = timeout_po;
+    let mut timeout_ch = timeout_ch;
     delayed_send(iotask, msecs, &timeout_ch, ());
 
     // XXX: Workaround due to ports and channels not being &mut. They should

src/librustc/middle/trans/cabi_arm.rs

@@ -139,12 +139,14 @@ impl ABIInfo for ARM_ABIInfo {
             attrs.push(attr);
         }
 
-        let mut (ret_ty, ret_attr) = if ret_def {
+        let (ret_ty, ret_attr) = if ret_def {
             classify_ret_ty(rty)
         } else {
             (LLVMType { cast: false, ty: Type::void() }, None)
         };
 
+        let mut ret_ty = ret_ty;
+
         let sret = ret_attr.is_some();
         if sret {
             arg_tys.unshift(ret_ty);

src/librustc/middle/trans/cabi_mips.rs

@@ -178,12 +178,14 @@ impl ABIInfo for MIPS_ABIInfo {
                     atys: &[Type],
                     rty: Type,
                     ret_def: bool) -> FnType {
-        let mut (ret_ty, ret_attr) = if ret_def {
+        let (ret_ty, ret_attr) = if ret_def {
             classify_ret_ty(rty)
         } else {
             (LLVMType { cast: false, ty: Type::void() }, None)
         };
 
+        let mut ret_ty = ret_ty;
+
         let sret = ret_attr.is_some();
         let mut arg_tys = ~[];
         let mut attrs = ~[];

src/librustc/middle/trans/cabi_x86_64.rs

@@ -360,8 +360,9 @@ fn x86_64_tys(atys: &[Type],
         arg_tys.push(ty);
         attrs.push(attr);
     }
-    let mut (ret_ty, ret_attr) = x86_64_ty(rty, |cls| cls.is_ret_bysret(),
+    let (ret_ty, ret_attr) = x86_64_ty(rty, |cls| cls.is_ret_bysret(),
                                        StructRetAttribute);
+    let mut ret_ty = ret_ty;
     let sret = ret_attr.is_some();
     if sret {
         arg_tys = vec::append(~[ret_ty], arg_tys);

src/librustc/middle/trans/callee.rs

@@ -319,9 +319,10 @@ pub fn trans_fn_ref_with_vtables(
         // Should be either intra-crate or inlined.
         assert_eq!(def_id.crate, ast::local_crate);
 
-        let mut (val, must_cast) =
+        let (val, must_cast) =
             monomorphize::monomorphic_fn(ccx, def_id, &substs,
                                          vtables, opt_impl_did, Some(ref_id));
+        let mut val = val;
         if must_cast && ref_id != 0 {
             // Monotype of the REFERENCE to the function (type params
             // are subst'd)