---

yaml
---
r: 58323
b: refs/heads/auto
c: 7d22437
h: refs/heads/master
i:
  58321: e1801cb
  58319: d81768e
v: v3

Author: alexcrichton

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: c49cf8b3300a97201058debd63b0f7aef34d3c35
+refs/heads/auto: 7d22437ecdc5b52f8517ffde6207347739b26553
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/core.rc

@@ -228,6 +228,7 @@ pub mod rand;
 pub mod run;
 pub mod sys;
 pub mod cast;
+pub mod flate;
 pub mod repr;
 pub mod cleanup;
 pub mod reflect;

branches/auto/src/libstd/flate.rs renamed to branches/auto/src/libcore/flate.rs

@@ -15,14 +15,14 @@ Simple compression
 */
 
 use libc;
-use core::libc::{c_void, size_t, c_int};
+use libc::{c_void, size_t, c_int};
 use vec;
 
-#[cfg(test)] use core::rand;
-#[cfg(test)] use core::rand::RngUtil;
+#[cfg(test)] use rand;
+#[cfg(test)] use rand::RngUtil;
 
 pub mod rustrt {
-    use core::libc::{c_int, c_void, size_t};
+    use libc::{c_int, c_void, size_t};
 
     #[link_name = "rustrt"]
     pub extern {

branches/auto/src/libcore/util.rs

@@ -15,6 +15,7 @@ Miscellaneous helpers for common patterns.
 */
 
 use prelude::*;
+use unstable::intrinsics;
 
 /// The identity function.
 #[inline(always)]
@@ -49,18 +50,75 @@ pub fn with<T,R>(
  */
 #[inline(always)]
 pub fn swap<T>(x: &mut T, y: &mut T) {
-    *x <-> *y;
+    unsafe {
+        swap_ptr(ptr::to_mut_unsafe_ptr(x), ptr::to_mut_unsafe_ptr(y));
+    }
+}
+
+/**
+ * Swap the values at two mutable locations of the same type, without
+ * deinitialising or copying either one.
+ */
+#[inline]
+#[cfg(not(stage0))]
+pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
+    if x == y { return }
+
+    // Give ourselves some scratch space to work with
+    let mut tmp: T = intrinsics::uninit();
+    let t = ptr::to_mut_unsafe_ptr(&mut tmp);
+
+    // Perform the swap
+    ptr::copy_memory(t, x, 1);
+    ptr::copy_memory(x, y, 1);
+    ptr::copy_memory(y, t, 1);
+
+    // y and t now point to the same thing, but we need to completely forget t
+    // because it's no longer relevant.
+    cast::forget(tmp);
+}
+
+/**
+ * Swap the values at two mutable locations of the same type, without
+ * deinitialising or copying either one.
+ */
+#[inline]
+#[cfg(stage0)]
+pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
+    if x == y { return }
+
+    // Give ourselves some scratch space to work with
+    let mut tmp: T = intrinsics::init();
+    let t = ptr::to_mut_unsafe_ptr(&mut tmp);
+
+    // Perform the swap
+    ptr::copy_memory(t, x, 1);
+    ptr::copy_memory(x, y, 1);
+    ptr::copy_memory(y, t, 1);
+
+    // y and t now point to the same thing, but we need to completely forget t
+    // because it's no longer relevant.
+    cast::forget(tmp);
+}
+
+/**
+ * Replace the value at a mutable location with a new one, returning the old
+ * value, without deinitialising or copying either one.
+ */
+#[inline(always)]
+pub fn replace<T>(dest: &mut T, mut src: T) -> T {
+    swap(dest, &mut src);
+    src
 }
 
 /**
  * Replace the value at a mutable location with a new one, returning the old
  * value, without deinitialising or copying either one.
  */
 #[inline(always)]
-pub fn replace<T>(dest: &mut T, src: T) -> T {
-    let mut tmp = src;
-    swap(dest, &mut tmp);
-    tmp
+pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
+    swap_ptr(dest, ptr::to_mut_unsafe_ptr(&mut src));
+    src
 }
 
 /// A non-copyable dummy type.

branches/auto/src/librustc/metadata/encoder.rs

@@ -20,7 +20,7 @@ use middle::ty;
 use middle;
 use util::ppaux::ty_to_str;
 
-use std::flate;
+use core::flate;
 use core::hash::HashUtil;
 use core::hashmap::HashMap;
 use std::serialize::Encodable;

branches/auto/src/librustc/metadata/loader.rs

@@ -22,7 +22,7 @@ use syntax::parse::token::ident_interner;
 use syntax::print::pprust;
 use syntax::{ast, attr};
 
-use std::flate;
+use core::flate;
 use core::os::consts::{macos, freebsd, linux, android, win32};
 
 pub enum os {

branches/auto/src/libstd/std.rc

@@ -107,7 +107,6 @@ pub mod complex;
 pub mod stats;
 pub mod semver;
 pub mod fileinput;
-pub mod flate;
 
 #[cfg(unicode)]
 mod unicode;