---

yaml
---
r: 159867
b: refs/heads/try
c: f7c1771
h: refs/heads/master
i:
  159865: 88da46e
  159863: c855f9f
v: v3

Author: Jorge Aparicio

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: e09d98603e608c9e47d4c89f7b4dca87a4b56da3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
-refs/heads/try: a0a7ab461283322215f0343cd2b5e66fc19a7bd5
+refs/heads/try: f7c1771fd18672a148979d334bf732d15a2c4023
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/libcore/ops.rs

@@ -638,7 +638,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * ```
  */
 #[lang="index"]
-pub trait Index<Index, Sized? Result> {
+pub trait Index<Index, Sized? Result> for Sized? {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index<'a>(&'a self, index: &Index) -> &'a Result;
 }
@@ -669,7 +669,7 @@ pub trait Index<Index, Sized? Result> {
  * ```
  */
 #[lang="index_mut"]
-pub trait IndexMut<Index, Result> {
+pub trait IndexMut<Index, Result> for Sized? {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Result;
 }

branches/try/src/libcore/slice.rs

@@ -256,7 +256,6 @@ pub trait SlicePrelude<T> for Sized? {
     #[inline]
     #[experimental = "not triaged yet"]
     fn is_empty(&self) -> bool { self.len() == 0 }
-
     /// Returns a mutable reference to the element at the given index,
     /// or `None` if the index is out of bounds
     #[unstable = "waiting on final error conventions"]
@@ -698,6 +697,22 @@ impl<T> SlicePrelude<T> for [T] {
     }
 }
 
+impl<T> ops::Index<uint, T> for [T] {
+    fn index(&self, &index: &uint) -> &T {
+        assert!(index < self.len());
+
+        unsafe { mem::transmute(self.repr().data.offset(index as int)) }
+    }
+}
+
+impl<T> ops::IndexMut<uint, T> for [T] {
+    fn index_mut(&mut self, &index: &uint) -> &mut T {
+        assert!(index < self.len());
+
+        unsafe { mem::transmute(self.repr().data.offset(index as int)) }
+    }
+}
+
 impl<T> ops::Slice<uint, [T]> for [T] {
     #[inline]
     fn as_slice_<'a>(&'a self) -> &'a [T] {

branches/try/src/librustc/middle/cfg/construct.rs

@@ -448,8 +448,8 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             }
 
             ast::ExprStruct(_, ref fields, ref base) => {
-                let field_cfg = self.straightline(expr, pred, fields.iter().map(|f| &*f.expr));
-                self.opt_expr(base, field_cfg)
+                let base_exit = self.opt_expr(base, pred);
+                self.straightline(expr, base_exit, fields.iter().map(|f| &*f.expr))
             }
 
             ast::ExprRepeat(ref elem, ref count) => {

branches/try/src/librustc/middle/expr_use_visitor.rs

@@ -672,10 +672,6 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
             }
         }
 
-        // walk the with expression so that complex expressions
-        // are properly handled.
-        self.walk_expr(with_expr);
-
         fn contains_field_named(field: &ty::field,
                                 fields: &Vec<ast::Field>)
                                 -> bool

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

@@ -451,7 +451,7 @@ pub fn from_str_radix_float<T: Float>(src: &str, radix: uint) -> Option<T> {
     };
 
     // The significand to accumulate
-    let mut sig = if is_positive { _0 } else { -_0 };
+    let mut sig = if is_positive { _0 } else { -_1 };
     // Necessary to detect overflow
     let mut prev_sig = sig;
     let mut cs = src.chars().enumerate();
@@ -647,22 +647,6 @@ mod test {
         let fe : Option<f32> = from_str_radix_float("1e40", 10);
         assert_eq!(fe, Some(Float::infinity()))
     }
-
-    #[test]
-    fn test_from_str_radix_float() {
-        let x1 : Option<f64> = from_str_radix_float("-123.456", 10);
-        assert_eq!(x1, Some(-123.456));
-        let x2 : Option<f32> = from_str_radix_float("123.456", 10);
-        assert_eq!(x2, Some(123.456));
-        let x3 : Option<f32> = from_str_radix_float("-0.0", 10);
-        assert_eq!(x3, Some(-0.0));
-        let x4 : Option<f32> = from_str_radix_float("0.0", 10);
-        assert_eq!(x4, Some(0.0));
-        let x4 : Option<f32> = from_str_radix_float("1.0", 10);
-        assert_eq!(x4, Some(1.0));
-        let x5 : Option<f32> = from_str_radix_float("-1.0", 10);
-        assert_eq!(x5, Some(-1.0));
-    }
 }
 
 #[cfg(test)]