---

yaml
---
r: 162043
b: refs/heads/auto
c: 8c07db5
h: refs/heads/master
i:
  162041: ce0538c
  162039: 31fb714
v: v3

Author: liigo

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: fb52e69a503fbe1c5f7641655bc45def875584b3
+refs/heads/auto: 8c07db5aac1bf87bce734d34b2c63a0890e02bd4
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc_trans/trans/closure.rs

@@ -272,24 +272,21 @@ fn load_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let mut i = 0u;
     for freevar in freevars.iter() {
         let mut upvarptr = GEPi(bcx, llcdata, &[0u, i]);
-        let captured_by_ref = match store {
-            ty::RegionTraitStore(..) => {
-                upvarptr = Load(bcx, upvarptr);
-                true
-            }
-            ty::UniqTraitStore => false
-        };
+        match store {
+            ty::RegionTraitStore(..) => { upvarptr = Load(bcx, upvarptr); }
+            ty::UniqTraitStore => {}
+        }
         let def_id = freevar.def.def_id();
 
         bcx.fcx.llupvars.borrow_mut().insert(def_id.node, upvarptr);
-        if let Some(env_pointer_alloca) = env_pointer_alloca {
+        for &env_pointer_alloca in env_pointer_alloca.iter() {
             debuginfo::create_captured_var_metadata(
                 bcx,
                 def_id.node,
                 cdata_ty,
                 env_pointer_alloca,
                 i,
-                captured_by_ref,
+                store,
                 freevar.span);
         }
 
@@ -323,25 +320,11 @@ fn load_unboxed_closure_environment<'blk, 'tcx>(
         bcx.fcx.llenv.unwrap()
     };
 
-    // Store the pointer to closure data in an alloca for debug info because that's what the
-    // llvm.dbg.declare intrinsic expects
-    let env_pointer_alloca = if bcx.sess().opts.debuginfo == FullDebugInfo {
-        let alloc = alloc_ty(bcx, ty::mk_mut_ptr(bcx.tcx(), self_type), "__debuginfo_env_ptr");
-        Store(bcx, llenv, alloc);
-        Some(alloc)
-    } else {
-        None
-    };
-
     for (i, freevar) in freevars.iter().enumerate() {
         let mut upvar_ptr = GEPi(bcx, llenv, &[0, i]);
-        let captured_by_ref = match freevar_mode {
-            ast::CaptureByRef => {
-                upvar_ptr = Load(bcx, upvar_ptr);
-                true
-            }
-            ast::CaptureByValue => false
-        };
+        if freevar_mode == ast::CaptureByRef {
+            upvar_ptr = Load(bcx, upvar_ptr);
+        }
         let def_id = freevar.def.def_id();
         bcx.fcx.llupvars.borrow_mut().insert(def_id.node, upvar_ptr);
 
@@ -350,17 +333,6 @@ fn load_unboxed_closure_environment<'blk, 'tcx>(
                                       upvar_ptr,
                                       node_id_type(bcx, def_id.node))
         }
-
-        if let Some(env_pointer_alloca) = env_pointer_alloca {
-            debuginfo::create_captured_var_metadata(
-                bcx,
-                def_id.node,
-                self_type,
-                env_pointer_alloca,
-                i,
-                captured_by_ref,
-                freevar.span);
-        }
     }
 
     bcx

branches/auto/src/librustc_trans/trans/debuginfo.rs

@@ -885,7 +885,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                                 env_data_type: Ty<'tcx>,
                                                 env_pointer: ValueRef,
                                                 env_index: uint,
-                                                captured_by_ref: bool,
+                                                closure_store: ty::TraitStore,
                                                 span: Span) {
     if fn_should_be_ignored(bcx.fcx) {
         return;
@@ -940,10 +940,13 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
          llvm::LLVMDIBuilderCreateOpDeref(Type::i64(cx).to_ref())]
     };
 
-    let address_op_count = if captured_by_ref {
-        address_operations.len()
-    } else {
-        address_operations.len() - 1
+    let address_op_count = match closure_store {
+        ty::RegionTraitStore(..) => {
+            address_operations.len()
+        }
+        ty::UniqTraitStore => {
+            address_operations.len() - 1
+        }
     };
 
     let variable_access = IndirectVariable {

branches/auto/src/librustrt/stack_overflow.rs

@@ -277,6 +277,7 @@ mod imp {
               all(target_os = "linux", target_arch = "x86_64"),
               all(target_os = "linux", target_arch = "arm"), // may not match
               all(target_os = "linux", target_arch = "mips"), // may not match
+              all(target_os = "linux", target_arch = "mipsel"), // may not match
               target_os = "android"))] // may not match
     mod signal {
         use libc;

branches/auto/src/libstd/macros.rs

@@ -217,11 +217,12 @@ macro_rules! debug_assert_eq(
 /// Iterators:
 ///
 /// ```rust
-/// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3
-///     for i in std::iter::count(0_u32, 1) {
-///         if 3*i < i { panic!("u32 overflow"); }
-///         if x < 3*i { return i-1; }
+/// fn divide_by_three(x: i32) -> i32 { // one of the poorest implementations of x/3
+///     for i in std::iter::count(0_i32, 1) {
+///         if i < 0 { panic!("i32 overflow"); }
+///         if x < 3*i { return i; }
 ///     }
+///
 ///     unreachable!();
 /// }
 /// ```

branches/auto/src/libstd/num/strconv.rs

@@ -83,6 +83,13 @@ pub enum SignFormat {
 /// - `f`             - a callback which will be invoked for each ascii character
 ///                     which composes the string representation of this integer
 ///
+/// # Return value
+///
+/// A tuple containing the byte vector, and a boolean flag indicating
+/// whether it represents a special value like `inf`, `-inf`, `NaN` or not.
+/// It returns a tuple because there can be ambiguity between a special value
+/// and a number representation at higher bases.
+///
 /// # Panics
 ///
 /// - Panics if `radix` < 2 or `radix` > 36.
@@ -140,41 +147,40 @@ fn int_to_str_bytes_common<T: Int>(num: T, radix: uint, sign: SignFormat, f: |u8
     }
 }
 
-/// Converts a number to its string representation as a byte vector.
-/// This is meant to be a common base implementation for all numeric string
-/// conversion functions like `to_string()` or `to_str_radix()`.
-///
-/// # Arguments
-///
-/// - `num`           - The number to convert. Accepts any number that
-///                     implements the numeric traits.
-/// - `radix`         - Base to use. Accepts only the values 2-36. If the exponential notation
-///                     is used, then this base is only used for the significand. The exponent
-///                     itself always printed using a base of 10.
-/// - `negative_zero` - Whether to treat the special value `-0` as
-///                     `-0` or as `+0`.
-/// - `sign`          - How to emit the sign. See `SignFormat`.
-/// - `digits`        - The amount of digits to use for emitting the fractional
-///                     part, if any. See `SignificantDigits`.
-/// - `exp_format`   - Whether or not to use the exponential (scientific) notation.
-///                    See `ExponentFormat`.
-/// - `exp_capital`   - Whether or not to use a capital letter for the exponent sign, if
-///                     exponential notation is desired.
-///
-/// # Return value
-///
-/// A tuple containing the byte vector, and a boolean flag indicating
-/// whether it represents a special value like `inf`, `-inf`, `NaN` or not.
-/// It returns a tuple because there can be ambiguity between a special value
-/// and a number representation at higher bases.
-///
-/// # Panics
-///
-/// - Panics if `radix` < 2 or `radix` > 36.
-/// - Panics if `radix` > 14 and `exp_format` is `ExpDec` due to conflict
-///   between digit and exponent sign `'e'`.
-/// - Panics if `radix` > 25 and `exp_format` is `ExpBin` due to conflict
-///   between digit and exponent sign `'p'`.
+/**
+ * Converts a number to its string representation as a byte vector.
+ * This is meant to be a common base implementation for all numeric string
+ * conversion functions like `to_string()` or `to_str_radix()`.
+ *
+ * # Arguments
+ * - `num`           - The number to convert. Accepts any number that
+ *                     implements the numeric traits.
+ * - `radix`         - Base to use. Accepts only the values 2-36. If the exponential notation
+ *                     is used, then this base is only used for the significand. The exponent
+ *                     itself always printed using a base of 10.
+ * - `negative_zero` - Whether to treat the special value `-0` as
+ *                     `-0` or as `+0`.
+ * - `sign`          - How to emit the sign. See `SignFormat`.
+ * - `digits`        - The amount of digits to use for emitting the fractional
+ *                     part, if any. See `SignificantDigits`.
+ * - `exp_format`   - Whether or not to use the exponential (scientific) notation.
+ *                    See `ExponentFormat`.
+ * - `exp_capital`   - Whether or not to use a capital letter for the exponent sign, if
+ *                     exponential notation is desired.
+ *
+ * # Return value
+ * A tuple containing the byte vector, and a boolean flag indicating
+ * whether it represents a special value like `inf`, `-inf`, `NaN` or not.
+ * It returns a tuple because there can be ambiguity between a special value
+ * and a number representation at higher bases.
+ *
+ * # Panics
+ * - Panics if `radix` < 2 or `radix` > 36.
+ * - Panics if `radix` > 14 and `exp_format` is `ExpDec` due to conflict
+ *   between digit and exponent sign `'e'`.
+ * - Panics if `radix` > 25 and `exp_format` is `ExpBin` due to conflict
+ *   between digit and exponent sign `'p'`.
+ */
 pub fn float_to_str_bytes_common<T: Float>(
         num: T, radix: uint, negative_zero: bool,
         sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_upper: bool

branches/auto/src/libstd/rt/backtrace.rs

@@ -252,7 +252,7 @@ mod imp {
     #[cfg(all(target_os = "ios", target_arch = "arm"))]
     #[inline(never)]
     pub fn write(w: &mut Writer) -> IoResult<()> {
-        use iter::{IteratorExt, range};
+        use iter::{Iterator, range};
         use result;
         use slice::{SlicePrelude};
 

branches/auto/src/test/debuginfo/var-captured-in-sendable-closure.rs

@@ -23,11 +23,7 @@
 // gdb-check:$2 = {a = -2, b = 3.5, c = 4}
 // gdb-command:print *owned
 // gdb-check:$3 = 5
-// gdb-command:continue
 
-// gdb-command:print constant2
-// gdb-check:$4 = 6
-// gdb-command:continue
 
 // === LLDB TESTS ==================================================================================
 
@@ -41,7 +37,6 @@
 // lldb-check:[...]$2 = 5
 
 #![allow(unused_variables)]
-#![feature(unboxed_closures)]
 
 struct Struct {
     a: int,
@@ -60,24 +55,12 @@ fn main() {
 
     let owned = box 5;
 
-    let closure = move |:| {
+    let closure: proc() = proc() {
         zzz(); // #break
         do_something(&constant, &a_struct.a, &*owned);
     };
 
     closure();
-
-    let constant2 = 6u;
-
-    // The `self` argument of the following closure should be passed by value
-    // to FnOnce::call_once(self, args), which gets translated a bit differently
-    // than the regular case. Let's make sure this is supported too.
-    let immedate_env = move |:| {
-        zzz(); // #break
-        return constant2;
-    };
-
-    immedate_env();
 }
 
 fn do_something(_: &int, _:&int, _:&int) {