---

yaml
---
r: 95871
b: refs/heads/dist-snap
c: d7b6502
h: refs/heads/master
i:
  95869: c85f0fc
  95867: f80d221
  95863: a78aa38
  95855: 8f4c5f3
  95839: df21312
  95807: 6b0b63e
  95743: 81399c7
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 70e9b5ab3912da84a32557bc1a34db5fb2178927
+refs/heads/dist-snap: d7b6502784cad759cee9961426313017f052d5ba
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -2063,7 +2063,7 @@ The currently implemented features of the compiler are:
 
 * `once_fns` - Onceness guarantees a closure is only executed once. Defining a
                closure as `once` is unlikely to be supported going forward. So
-               they are hidden behind this feature until they are to be removed.
+               they are hidden behind this feature until they are to be removed. 
 
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
@@ -2748,10 +2748,11 @@ do k(3) |j| {
 
 ~~~~ {.ebnf .gram}
 for_expr : "for" pat "in" expr '{' block '}' ;
-~~~~
+~~~~ 
 
-A `for` expression is a syntactic construct for looping over elements
-provided by an implementation of `std::iter::Iterator`.
+A `for` expression is a syntactic construct for looping
+over elements provided by an implementation of
+`std::iterator::Iterator`.
 
 An example of a for loop over the contents of a vector:
 

branches/dist-snap/doc/tutorial-container.md

@@ -69,7 +69,7 @@ heapsort.
 ## Iteration protocol
 
 The iteration protocol is defined by the `Iterator` trait in the
-`std::iter` module. The minimal implementation of the trait is a `next`
+`std::iterator` module. The minimal implementation of the trait is a `next`
 method, yielding the next element from an iterator object:
 
 ~~~

branches/dist-snap/doc/tutorial.md

@@ -759,7 +759,6 @@ different type from `Bar(1, 2)`), and tuple structs' _fields_ do not have
 names.
 
 For example:
-
 ~~~~
 struct MyTup(int, int, f64);
 let mytup: MyTup = MyTup(10, 20, 30.0);

branches/dist-snap/src/librustc/driver/driver.rs

@@ -441,8 +441,7 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
         };
         let analysis = phase_3_run_analysis_passes(sess, &expanded_crate);
         if stop_after_phase_3(sess) { return; }
-        let outputs = build_output_filenames(input, outdir, output,
-                                             expanded_crate.attrs, sess);
+        let outputs = build_output_filenames(input, outdir, output, [], sess);
         let trans = phase_4_translate_to_llvm(sess, expanded_crate,
                                               &analysis, outputs);
         (outputs, trans)

branches/dist-snap/src/librustc/middle/trans/intrinsic.rs

@@ -74,24 +74,14 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         }
     }
 
-    fn copy_intrinsic(bcx: @mut Block, allow_overlap: bool, tp_ty: ty::t) {
+    fn memcpy_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
         let ccx = bcx.ccx();
         let lltp_ty = type_of::type_of(ccx, tp_ty);
         let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
-        let size = machine::llsize_of(ccx, lltp_ty);
-        let int_size = machine::llbitsize_of_real(ccx, ccx.int_type);
-        let name = if allow_overlap {
-            if int_size == 32 {
-                "llvm.memmove.p0i8.p0i8.i32"
-            } else {
-                "llvm.memmove.p0i8.p0i8.i64"
-            }
-        } else {
-            if int_size == 32 {
-                "llvm.memcpy.p0i8.p0i8.i32"
-            } else {
-                "llvm.memcpy.p0i8.p0i8.i64"
-            }
+        let size = match sizebits {
+            32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
+            64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
+            _ => ccx.sess.fatal("Invalid value for sizebits")
         };
 
         let decl = bcx.fcx.llfn;
@@ -105,15 +95,14 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         RetVoid(bcx);
     }
 
-    fn memset_intrinsic(bcx: @mut Block, tp_ty: ty::t) {
+    fn memset_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
         let ccx = bcx.ccx();
         let lltp_ty = type_of::type_of(ccx, tp_ty);
         let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
-        let size = machine::llsize_of(ccx, lltp_ty);
-        let name = if machine::llbitsize_of_real(ccx, ccx.int_type) == 32 {
-            "llvm.memset.p0i8.i32"
-        } else {
-            "llvm.memset.p0i8.i64"
+        let size = match sizebits {
+            32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
+            64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
+            _ => ccx.sess.fatal("Invalid value for sizebits")
         };
 
         let decl = bcx.fcx.llfn;
@@ -410,9 +399,12 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             let lladdr = InBoundsGEP(bcx, ptr, [offset]);
             Ret(bcx, lladdr);
         }
-        "copy_nonoverlapping_memory" => copy_intrinsic(bcx, false, substs.tys[0]),
-        "copy_memory" => copy_intrinsic(bcx, true, substs.tys[0]),
-        "set_memory" => memset_intrinsic(bcx, substs.tys[0]),
+        "memcpy32" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i32", substs.tys[0], 32),
+        "memcpy64" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i64", substs.tys[0], 64),
+        "memmove32" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i32", substs.tys[0], 32),
+        "memmove64" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i64", substs.tys[0], 64),
+        "memset32" => memset_intrinsic(bcx, "llvm.memset.p0i8.i32", substs.tys[0], 32),
+        "memset64" => memset_intrinsic(bcx, "llvm.memset.p0i8.i64", substs.tys[0], 64),
         "sqrtf32" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f32", 1),
         "sqrtf64" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f64", 1),
         "powif32" => simple_llvm_intrinsic(bcx, "llvm.powi.f32", 2),

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

@@ -3734,7 +3734,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                    mutbl: ast::MutImmutable
                }))
             }
-            "copy_nonoverlapping_memory" => {
+            "memcpy32" => {
               (1,
                ~[
                   ty::mk_ptr(tcx, ty::mt {
@@ -3745,11 +3745,11 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                       ty: param(ccx, 0),
                       mutbl: ast::MutImmutable
                   }),
-                  ty::mk_uint()
+                  ty::mk_u32()
                ],
                ty::mk_nil())
             }
-            "copy_memory" => {
+            "memcpy64" => {
               (1,
                ~[
                   ty::mk_ptr(tcx, ty::mt {
@@ -3760,19 +3760,61 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                       ty: param(ccx, 0),
                       mutbl: ast::MutImmutable
                   }),
-                  ty::mk_uint()
+                  ty::mk_u64()
                ],
                ty::mk_nil())
             }
-            "set_memory" => {
+            "memmove32" => {
+              (1,
+               ~[
+                  ty::mk_ptr(tcx, ty::mt {
+                      ty: param(ccx, 0),
+                      mutbl: ast::MutMutable
+                  }),
+                  ty::mk_ptr(tcx, ty::mt {
+                      ty: param(ccx, 0),
+                      mutbl: ast::MutImmutable
+                  }),
+                  ty::mk_u32()
+               ],
+               ty::mk_nil())
+            }
+            "memmove64" => {
+              (1,
+               ~[
+                  ty::mk_ptr(tcx, ty::mt {
+                      ty: param(ccx, 0),
+                      mutbl: ast::MutMutable
+                  }),
+                  ty::mk_ptr(tcx, ty::mt {
+                      ty: param(ccx, 0),
+                      mutbl: ast::MutImmutable
+                  }),
+                  ty::mk_u64()
+               ],
+               ty::mk_nil())
+            }
+            "memset32" => {
+              (1,
+               ~[
+                  ty::mk_ptr(tcx, ty::mt {
+                      ty: param(ccx, 0),
+                      mutbl: ast::MutMutable
+                  }),
+                  ty::mk_u8(),
+                  ty::mk_u32()
+               ],
+               ty::mk_nil())
+            }
+            "memset64" => {
               (1,
                ~[
                   ty::mk_ptr(tcx, ty::mt {
                       ty: param(ccx, 0),
                       mutbl: ast::MutMutable
                   }),
                   ty::mk_u8(),
-                  ty::mk_uint()
+                  ty::mk_u64()
                ],
                ty::mk_nil())
             }

branches/dist-snap/src/librustpkg/lib.rs

@@ -699,9 +699,7 @@ impl CtxMethods for BuildContext {
                 debug!("test: test_exec = {}", test_exec.display());
                 // FIXME (#9639): This needs to handle non-utf8 paths
                 let status = run::process_status(test_exec.as_str().unwrap(), [~"--test"]);
-                if status != 0 {
-                    fail!("Some tests failed");
-                }
+                os::set_exit_status(status);
             }
             None => {
                 error(format!("Internal error: test executable for package ID {} in workspace {} \

branches/dist-snap/src/librustpkg/tests.rs

@@ -2097,20 +2097,6 @@ fn test_rustpkg_test_output() {
     assert!(output_str.contains("1 passed; 0 failed; 0 ignored; 0 measured"));
 }
 
-#[test]
-fn test_rustpkg_test_failure_exit_status() {
-    let foo_id = PkgId::new("foo");
-    let foo_workspace = create_local_package(&foo_id);
-    let foo_workspace = foo_workspace.path();
-    writeFile(&foo_workspace.join_many(["src", "foo-0.1", "test.rs"]),
-              "#[test] fn f() { assert!('a' != 'a'); }");
-    let res = command_line_test_partial([~"test", ~"foo"], foo_workspace);
-    match res {
-        Fail(_) => {},
-        Success(*) => fail!("Expected test failure but got success")
-    }
-}
-
 #[test]
 fn test_rebuild_when_needed() {
     let foo_id = PkgId::new("foo");
@@ -2132,7 +2118,6 @@ fn test_rebuild_when_needed() {
 }
 
 #[test]
-#[ignore] // FIXME (#10257): This doesn't work as is since a read only file can't execute
 fn test_no_rebuilding() {
     let foo_id = PkgId::new("foo");
     let foo_workspace = create_local_package(&foo_id);

branches/dist-snap/src/libstd/c_str.rs

@@ -330,7 +330,7 @@ fn check_for_null(v: &[u8], buf: *mut libc::c_char) {
 
 /// External iterator for a CString's bytes.
 ///
-/// Use with the `std::iter` module.
+/// Use with the `std::iterator` module.
 pub struct CStringIterator<'self> {
     priv ptr: *libc::c_char,
     priv lifetime: &'self libc::c_char, // FIXME: #5922

branches/dist-snap/src/libstd/cast.rs

@@ -13,15 +13,26 @@
 use ptr::RawPtr;
 use mem;
 use unstable::intrinsics;
-use ptr::copy_nonoverlapping_memory;
 
 /// Casts the value at `src` to U. The two types must have the same length.
+#[cfg(target_word_size = "32")]
 #[inline]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = intrinsics::uninit();
     let dest_ptr: *mut u8 = transmute(&mut dest);
     let src_ptr: *u8 = transmute(src);
-    copy_nonoverlapping_memory(dest_ptr, src_ptr, mem::size_of::<U>());
+    intrinsics::memcpy32(dest_ptr, src_ptr, mem::size_of::<U>() as u32);
+    dest
+}
+
+/// Casts the value at `src` to U. The two types must have the same length.
+#[cfg(target_word_size = "64")]
+#[inline]
+pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
+    let mut dest: U = intrinsics::uninit();
+    let dest_ptr: *mut u8 = transmute(&mut dest);
+    let src_ptr: *u8 = transmute(src);
+    intrinsics::memcpy64(dest_ptr, src_ptr, mem::size_of::<U>() as u64);
     dest
 }
 

branches/dist-snap/src/libstd/prelude.rs

@@ -67,6 +67,7 @@ pub use num::{Orderable, Signed, Unsigned, Round};
 pub use num::{Primitive, Int, Float, ToStrRadix, ToPrimitive, FromPrimitive};
 pub use path::{GenericPath, Path, PosixPath, WindowsPath};
 pub use ptr::RawPtr;
+pub use rt::io::{Writer, Reader, Seek};
 pub use send_str::{SendStr, SendStrOwned, SendStrStatic, IntoSendStr};
 pub use str::{Str, StrVector, StrSlice, OwnedStr};
 pub use to_bytes::IterBytes;