---

yaml
---
r: 156459
b: refs/heads/snap-stage3
c: 7d0cc44
h: refs/heads/master
i:
  156457: d44fdb7
  156455: 5a042e6
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 96445a533e8ea40701e2a9bbd25347141e63c115
+refs/heads/snap-stage3: 7d0cc44f873ac338b400b20bcb62618aa5d36b70
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/guide.md

@@ -3095,10 +3095,10 @@ And try to run the test:
 
 ```{notrust,ignore}
 $ cargo test
-   Compiling testing v0.0.1 (file:///home/youg/projects/testing)
-/home/youg/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
-/home/youg/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
-                                                            ^~~~~~~~~~~~~~~~~~~~
+   Compiling testing v0.0.1 (file:///home/you/projects/testing)
+/home/you/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
+/home/you/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
+                                                           ^~~~~~~~~~~~~~~~~~~~
 error: aborting due to previous error
 Build failed, waiting for other jobs to finish...
 Could not compile `testing`.

branches/snap-stage3/src/libcore/num/f32.rs

@@ -259,7 +259,11 @@ impl Float for f32 {
 
     #[inline]
     fn sqrt(self) -> f32 {
-        unsafe { intrinsics::sqrtf32(self) }
+        if self < 0.0 {
+            NAN
+        } else {
+            unsafe { intrinsics::sqrtf32(self) }
+        }
     }
 
     #[inline]

branches/snap-stage3/src/libcore/num/f64.rs

@@ -266,7 +266,11 @@ impl Float for f64 {
 
     #[inline]
     fn sqrt(self) -> f64 {
-        unsafe { intrinsics::sqrtf64(self) }
+        if self < 0.0 {
+            NAN
+        } else {
+            unsafe { intrinsics::sqrtf64(self) }
+        }
     }
 
     #[inline]
@@ -377,4 +381,3 @@ impl Float for f64 {
         self * (value / 180.0)
     }
 }
-

branches/snap-stage3/src/libcore/num/mod.rs

@@ -1501,6 +1501,8 @@ pub trait Float: Signed + Primitive {
     fn frac_1_sqrt2() -> Self;
 
     /// Take the square root of a number.
+    ///
+    /// Returns NaN if `self` is not a non-negative number.
     fn sqrt(self) -> Self;
     /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
     fn rsqrt(self) -> Self;

branches/snap-stage3/src/librustc/middle/traits/mod.rs

@@ -77,6 +77,7 @@ pub enum ObligationCauseCode {
     AssignmentLhsSized,        // L = X implies that L is Sized
     StructInitializerSized,    // S { ... } must be Sized
     VariableType(ast::NodeId), // Type of each variable must be Sized
+    ReturnType,                // Return type must be Sized
     RepeatVec,                 // [T,..n] --> T must be Copy
 
     // Captures of variable the given id by a closure (span is the

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -555,16 +555,12 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
 
     // Remember return type so that regionck can access it later.
     let fn_sig_tys: Vec<ty::t> =
-        arg_tys.iter()
-        .chain([ret_ty].iter())
-        .map(|&ty| ty)
-        .collect();
+        arg_tys.iter().chain([ret_ty].iter()).map(|&ty| ty).collect();
     debug!("fn-sig-map: fn_id={} fn_sig_tys={}",
            fn_id,
            fn_sig_tys.repr(tcx));
-    inherited.fn_sig_map
-        .borrow_mut()
-        .insert(fn_id, fn_sig_tys);
+
+    inherited.fn_sig_map.borrow_mut().insert(fn_id, fn_sig_tys);
 
     {
         let mut visit = GatherLocalsVisitor { fcx: &fcx, };
@@ -591,6 +587,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
 
         visit.visit_block(body);
     }
+    fcx.require_type_is_sized(ret_ty, decl.output.span, traits::ReturnType);
 
     check_block_with_expected(&fcx, body, ExpectHasType(ret_ty));
 

branches/snap-stage3/src/librustc/middle/typeck/check/vtable2.rs

@@ -366,15 +366,20 @@ fn note_obligation_cause(fcx: &FnCtxt,
         traits::RepeatVec => {
             tcx.sess.span_note(
                 obligation.cause.span,
-                format!(
-                    "the `Copy` trait is required because the \
-                     repeated element will be copied").as_slice());
+                "the `Copy` trait is required because the \
+                 repeated element will be copied");
         }
         traits::VariableType(_) => {
             tcx.sess.span_note(
                 obligation.cause.span,
                 "all local variables must have a statically known size");
         }
+        traits::ReturnType => {
+            tcx.sess.span_note(
+                obligation.cause.span,
+                "the return type of a function must have a \
+                 statically known size");
+        }
         traits::AssignmentLhsSized => {
             tcx.sess.span_note(
                 obligation.cause.span,

branches/snap-stage3/src/libstd/io/buffered.rs

@@ -104,6 +104,9 @@ impl<R: Reader> Buffer for BufferedReader<R> {
 
 impl<R: Reader> Reader for BufferedReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+        if self.pos == self.cap && buf.len() >= self.buf.capacity() {
+            return self.inner.read(buf);
+        }
         let nread = {
             let available = try!(self.fill_buf());
             let nread = cmp::min(available.len(), buf.len());
@@ -409,13 +412,19 @@ mod test {
 
     #[test]
     fn test_buffered_reader() {
-        let inner = MemReader::new(vec!(0, 1, 2, 3, 4));
+        let inner = MemReader::new(vec!(5, 6, 7, 0, 1, 2, 3, 4));
         let mut reader = BufferedReader::with_capacity(2, inner);
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
+        assert_eq!(Ok(3), nread);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(buf.as_slice(), b);
+
+        let mut buf = [0, 0];
+        let nread = reader.read(buf);
         assert_eq!(Ok(2), nread);
-        let b: &[_] = &[0, 1, 0];
+        let b: &[_] = &[0, 1];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0];

branches/snap-stage3/src/libstd/num/f32.rs

@@ -764,4 +764,15 @@ mod tests {
         assert_eq!(NEG_INFINITY.integer_decode(), (8388608u64, 105i16, -1i8));
         assert_eq!(NAN.integer_decode(), (12582912u64, 105i16, 1i8));
     }
+
+    #[test]
+    fn test_sqrt_domain() {
+        assert!(NAN.sqrt().is_nan());
+        assert!(NEG_INFINITY.sqrt().is_nan());
+        assert!((-1.0f32).sqrt().is_nan());
+        assert_eq!((-0.0f32).sqrt(), -0.0);
+        assert_eq!(0.0f32.sqrt(), 0.0);
+        assert_eq!(1.0f32.sqrt(), 1.0);
+        assert_eq!(INFINITY.sqrt(), INFINITY);
+    }
 }

branches/snap-stage3/src/libstd/num/f64.rs

@@ -766,4 +766,15 @@ mod tests {
         assert_eq!(NEG_INFINITY.integer_decode(), (4503599627370496, 972, -1));
         assert_eq!(NAN.integer_decode(), (6755399441055744u64, 972i16, 1i8));
     }
+
+    #[test]
+    fn test_sqrt_domain() {
+        assert!(NAN.sqrt().is_nan());
+        assert!(NEG_INFINITY.sqrt().is_nan());
+        assert!((-1.0f64).sqrt().is_nan());
+        assert_eq!((-0.0f64).sqrt(), -0.0);
+        assert_eq!(0.0f64.sqrt(), 0.0);
+        assert_eq!(1.0f64.sqrt(), 1.0);
+        assert_eq!(INFINITY.sqrt(), INFINITY);
+    }
 }

branches/snap-stage3/src/libsyntax/print/pprust.rs

@@ -2680,8 +2680,9 @@ impl<'a> State<'a> {
                              ast_util::int_ty_to_string(st, Some(i as i64)).as_slice())
                     }
                     ast::SignedIntLit(st, ast::Minus) => {
+                        let istr = ast_util::int_ty_to_string(st, Some(-(i as i64)));
                         word(&mut self.s,
-                             ast_util::int_ty_to_string(st, Some(-(i as i64))).as_slice())
+                             format!("-{}", istr).as_slice())
                     }
                     ast::UnsignedIntLit(ut) => {
                         word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i)).as_slice())
@@ -2930,4 +2931,12 @@ mod test {
         let varstr = variant_to_string(&var);
         assert_eq!(&varstr,&"pub principal_skinner".to_string());
     }
+
+    #[test]
+    fn test_signed_int_to_string() {
+        let pos_int = ast::LitInt(42, ast::SignedIntLit(ast::TyI32, ast::Plus));
+        let neg_int = ast::LitInt((-42) as u64, ast::SignedIntLit(ast::TyI32, ast::Minus));
+        assert_eq!(format!("-{}", lit_to_string(&codemap::dummy_spanned(pos_int))),
+                   lit_to_string(&codemap::dummy_spanned(neg_int)));
+    }
 }

branches/snap-stage3/src/test/auxiliary/lang-item-public.rs

@@ -11,6 +11,9 @@
 #![no_std]
 #![feature(lang_items)]
 
+#[lang="sized"]
+pub trait Sized for Sized? {}
+
 #[lang="fail"]
 fn fail(_: &(&'static str, &'static str, uint)) -> ! { loop {} }
 

branches/snap-stage3/src/test/compile-fail/issue-17025.rs

@@ -13,8 +13,9 @@ enum A {
     C([Box<A>]),
 }
 
-fn c(c:char) -> A {
-    B(c) //~ ERROR cannot move a value of type A: the size of A cannot be statically determined
+fn c(c:char) {
+    B(c);
+    //~^ ERROR cannot move a value of type A: the size of A cannot be statically determined
 }
 
 pub fn main() {}

branches/snap-stage3/src/test/compile-fail/issue-18107.rs

@@ -0,0 +1,25 @@
+// 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.
+
+
+
+pub trait AbstractRenderer {}
+
+fn _create_render(_: &()) ->
+    AbstractRenderer
+//~^ ERROR: the trait `core::kinds::Sized` is not implemented
+{
+    match 0u {
+        _ => unimplemented!()
+    }
+}
+
+fn main() {
+}

branches/snap-stage3/src/test/compile-fail/issue-5883.rs

@@ -14,7 +14,8 @@ struct Struct {
     r: A+'static
 }
 
-fn new_struct(r: A+'static) -> Struct {
+fn new_struct(r: A+'static)
+    -> Struct { //~^  ERROR the trait `core::kinds::Sized` is not implemented
     //~^ ERROR the trait `core::kinds::Sized` is not implemented
     Struct { r: r }
     //~^ ERROR the trait `core::kinds::Sized` is not implemented

branches/snap-stage3/src/test/compile-fail/privacy4.rs

@@ -8,9 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(globs)]
+#![feature(globs, lang_items)]
 #![no_std] // makes debugging this test *a lot* easier (during resolve)
 
+#[lang = "sized"] pub trait Sized for Sized? {}
+
 // Test to make sure that private items imported through globs remain private
 // when  they're used.
 

branches/snap-stage3/src/test/compile-fail/required-lang-item.rs

@@ -8,8 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(lang_items)]
 #![no_std]
 
+#[lang="sized"] pub trait Sized for Sized? {}
+
 // error-pattern:requires `start` lang_item
 
 fn main() {}