---

yaml
---
r: 158646
b: refs/heads/master
c: 932eec7
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f7c1771fd18672a148979d334bf732d15a2c4023
+refs/heads/master: 932eec7d702cf2cf55554e2431c3cb0fecd19014
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/src/librustc/middle/cfg/construct.rs

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

trunk/src/librustc/middle/expr_use_visitor.rs

@@ -672,6 +672,10 @@ 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

trunk/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 { -_1 };
+    let mut sig = if is_positive { _0 } else { -_0 };
     // Necessary to detect overflow
     let mut prev_sig = sig;
     let mut cs = src.chars().enumerate();
@@ -647,6 +647,22 @@ 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)]

trunk/src/test/compile-fail/walk-struct-literal-with.rs

@@ -0,0 +1,28 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Mine{
+    test: String,
+    other_val: int
+}
+
+impl Mine{
+    fn make_string_bar(mut self) -> Mine{
+        self.test = "Bar".to_string();
+        self
+    }
+}
+
+fn main(){
+    let start = Mine{test:"Foo".to_string(), other_val:0};
+    let end = Mine{other_val:1, ..start.make_string_bar()};
+    println!("{}", start.test); //~ ERROR use of moved value: `start.test`
+}
+