---

yaml
---
r: 190263
b: refs/heads/tmp
c: bb18a3c
h: refs/heads/master
i:
  190261: a8d94b5
  190259: 640cbfa
  190255: 653a454
v: v3

Author: dotdash

[refs]

@@ -34,6 +34,6 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 6af2721466018be0fcff43b56730073332eac160
+refs/heads/tmp: bb18a3cfe7554143622af4911028605e89c80104
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: d3c49d2140fc65e8bb7d7cf25bfe74dda6ce5ecf

branches/tmp/configure

@@ -823,11 +823,11 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-6]*)
+        (3.[5-6]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
-            err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
+            err "bad LLVM version: $LLVM_VERSION, need >=3.5"
             ;;
     esac
 fi

branches/tmp/mk/main.mk

@@ -290,7 +290,6 @@ LLVM_VERSION_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --version)
 LLVM_BINDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --bindir)
 LLVM_INCDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --includedir)
 LLVM_LIBDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libdir)
-LLVM_LIBDIR_RUSTFLAGS_$(1)=-L "$$(LLVM_LIBDIR_$(1))"
 LLVM_LIBS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libs $$(LLVM_COMPONENTS))
 LLVM_LDFLAGS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --ldflags)
 # On FreeBSD, it may search wrong headers (that are for pre-installed LLVM),

branches/tmp/mk/target.mk

@@ -84,7 +84,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 	    $$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) \
 		$$(RUST_LIB_FLAGS_ST$(1)) \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
-		$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
+		-L "$$(LLVM_LIBDIR_$(2))" \
 		$$(LLVM_STDCPP_RUSTFLAGS_$(2)) \
 		$$(RUSTFLAGS_$(4)) \
 		--out-dir $$(@D) \

branches/tmp/mk/tests.mk

@@ -372,7 +372,7 @@ $(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2)): \
 	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(3)) \
 	    $$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) -o $$@ $$< --test \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
-		$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
+		-L "$$(LLVM_LIBDIR_$(2))" \
 		$$(RUSTFLAGS_$(4))
 
 endef

branches/tmp/src/compiletest/compiletest.rs

@@ -20,6 +20,7 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(core)]
+#![feature(io)]
 #![feature(net)]
 #![feature(path_ext)]
 
@@ -33,6 +34,7 @@ extern crate log;
 
 use std::env;
 use std::fs;
+use std::old_io;
 use std::path::{Path, PathBuf};
 use std::thunk::Thunk;
 use getopts::{optopt, optflag, reqopt};
@@ -244,11 +246,7 @@ pub fn run_tests(config: &Config) {
     // sadly osx needs some file descriptor limits raised for running tests in
     // parallel (especially when we have lots and lots of child processes).
     // For context, see #8904
-    #[allow(deprecated)]
-    fn raise_fd_limit() {
-        std::old_io::test::raise_fd_limit();
-    }
-    raise_fd_limit();
+    old_io::test::raise_fd_limit();
     // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
     // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
     env::set_var("__COMPAT_LAYER", "RunAsInvoker");

branches/tmp/src/compiletest/runtest.rs

@@ -26,6 +26,7 @@ use std::io::BufReader;
 use std::io::prelude::*;
 use std::iter::repeat;
 use std::net::TcpStream;
+use std::old_io::timer;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, ExitStatus};
 use std::str;
@@ -451,11 +452,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 .expect(&format!("failed to exec `{:?}`", config.adb_path));
             loop {
                 //waiting 1 second for gdbserver start
-                #[allow(deprecated)]
-                fn sleep() {
-                    ::std::old_io::timer::sleep(Duration::milliseconds(1000));
-                }
-                sleep();
+                timer::sleep(Duration::milliseconds(1000));
                 if TcpStream::connect("127.0.0.1:5039").is_ok() {
                     break
                 }

branches/tmp/src/libcollections/btree/node.rs

@@ -348,8 +348,14 @@ impl<K, V> Node<K, V> {
     #[inline]
     pub fn as_slices<'a>(&'a self) -> (&'a [K], &'a [V]) {
         unsafe {(
-            slice::from_raw_parts(*self.keys, self.len()),
-            slice::from_raw_parts(*self.vals, self.len()),
+            mem::transmute(raw::Slice {
+                data: *self.keys as *const K,
+                len: self.len()
+            }),
+            mem::transmute(raw::Slice {
+                data: *self.vals as *const V,
+                len: self.len()
+            })
         )}
     }
 

branches/tmp/src/libcollections/string.rs

@@ -24,7 +24,7 @@ use core::iter::{IntoIterator, FromIterator};
 use core::mem;
 use core::ops::{self, Deref, Add, Index};
 use core::ptr;
-use core::slice;
+use core::raw::Slice as RawSlice;
 use unicode::str as unicode_str;
 use unicode::str::Utf16Item;
 
@@ -468,11 +468,11 @@ impl String {
         unsafe {
             // Attempt to not use an intermediate buffer by just pushing bytes
             // directly onto this string.
-            let slice = slice::from_raw_parts_mut (
-                self.vec.as_mut_ptr().offset(cur_len as isize),
-                4
-            );
-            let used = ch.encode_utf8(slice).unwrap_or(0);
+            let slice = RawSlice {
+                data: self.vec.as_ptr().offset(cur_len as isize),
+                len: 4,
+            };
+            let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0);
             self.vec.set_len(cur_len + used);
         }
     }

branches/tmp/src/libcollections/vec.rs

@@ -64,6 +64,7 @@ use core::ops::{Index, IndexMut, Deref, Add};
 use core::ops;
 use core::ptr;
 use core::ptr::Unique;
+use core::raw::Slice as RawSlice;
 use core::slice;
 use core::usize;
 
@@ -434,7 +435,10 @@ impl<T> Vec<T> {
         unsafe {
             let ptr = *self.ptr;
             assume(!ptr.is_null());
-            slice::from_raw_parts_mut(ptr, self.len)
+            mem::transmute(RawSlice {
+                data: ptr,
+                len: self.len,
+            })
         }
     }
 
@@ -1556,7 +1560,10 @@ impl<T> AsSlice<T> for Vec<T> {
         unsafe {
             let p = *self.ptr;
             assume(p != 0 as *mut T);
-            slice::from_raw_parts(p, self.len)
+            mem::transmute(RawSlice {
+                data: p,
+                len: self.len
+            })
         }
     }
 }

branches/tmp/src/libcollections/vec_deque.rs

@@ -29,7 +29,7 @@ use core::num::{Int, UnsignedInt};
 use core::num::wrapping::WrappingOps;
 use core::ops::{Index, IndexMut};
 use core::ptr::{self, Unique};
-use core::slice;
+use core::raw::Slice as RawSlice;
 
 use core::hash::{Hash, Hasher};
 use core::cmp;
@@ -91,13 +91,13 @@ impl<T> VecDeque<T> {
     /// Turn ptr into a slice
     #[inline]
     unsafe fn buffer_as_slice(&self) -> &[T] {
-        slice::from_raw_parts(*self.ptr, self.cap)
+        mem::transmute(RawSlice { data: *self.ptr as *const T, len: self.cap })
     }
 
     /// Turn ptr into a mut slice
     #[inline]
     unsafe fn buffer_as_mut_slice(&mut self) -> &mut [T] {
-        slice::from_raw_parts_mut(*self.ptr, self.cap)
+        mem::transmute(RawSlice { data: *self.ptr as *const T, len: self.cap })
     }
 
     /// Moves an element out of the buffer

branches/tmp/src/libcore/panicking.rs

@@ -35,14 +35,8 @@ use fmt;
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="panic"]
 pub fn panic(expr_file_line: &(&'static str, &'static str, u32)) -> ! {
-    // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially
-    // reduce size overhead. The format_args! macro uses str's Display trait to
-    // write expr, which calls Formatter::pad, which must accommodate string
-    // truncation and padding (even though none is used here). Using
-    // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
-    // output binary, saving up to a few kilobytes.
     let (expr, file, line) = *expr_file_line;
-    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line))
+    panic_fmt(format_args!("{}", expr), &(file, line))
 }
 
 #[cold] #[inline(never)]

branches/tmp/src/libcore/slice.rs

@@ -520,10 +520,10 @@ impl<T> ops::Index<ops::Range<usize>> for [T] {
         assert!(index.start <= index.end);
         assert!(index.end <= self.len());
         unsafe {
-            from_raw_parts (
-                self.as_ptr().offset(index.start as isize),
-                index.end - index.start
-            )
+            transmute(RawSlice {
+                    data: self.as_ptr().offset(index.start as isize),
+                    len: index.end - index.start
+                })
         }
     }
 }
@@ -559,10 +559,10 @@ impl<T> ops::IndexMut<ops::Range<usize>> for [T] {
         assert!(index.start <= index.end);
         assert!(index.end <= self.len());
         unsafe {
-            from_raw_parts_mut(
-                self.as_mut_ptr().offset(index.start as isize),
-                index.end - index.start
-            )
+            transmute(RawSlice {
+                    data: self.as_ptr().offset(index.start as isize),
+                    len: index.end - index.start
+                })
         }
     }
 }
@@ -731,21 +731,7 @@ macro_rules! make_slice {
             diff / mem::size_of::<$t>()
         };
         unsafe {
-            from_raw_parts($start, len)
-        }
-    }}
-}
-
-macro_rules! make_mut_slice {
-    ($t: ty => $result: ty: $start: expr, $end: expr) => {{
-        let diff = $end as usize - $start as usize;
-        let len = if mem::size_of::<T>() == 0 {
-            diff
-        } else {
-            diff / mem::size_of::<$t>()
-        };
-        unsafe {
-            from_raw_parts_mut($start, len)
+            transmute::<_, $result>(RawSlice { data: $start, len: len })
         }
     }}
 }
@@ -912,7 +898,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<usize>> for IterMut<'a, T> {
 impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {
     #[inline]
     fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
-        make_mut_slice!(T => &mut [T]: self.ptr, self.end)
+        make_slice!(T => &mut [T]: self.ptr, self.end)
     }
 }
 
@@ -926,7 +912,7 @@ impl<'a, T> IterMut<'a, T> {
     /// restricted lifetimes that do not consume the iterator.
     #[unstable(feature = "core")]
     pub fn into_slice(self) -> &'a mut [T] {
-        make_mut_slice!(T => &'a mut [T]: self.ptr, self.end)
+        make_slice!(T => &'a mut [T]: self.ptr, self.end)
     }
 }
 
@@ -1418,15 +1404,16 @@ impl<'a, T> ExactSizeIterator for ChunksMut<'a, T> {}
 #[unstable(feature = "core")]
 pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
     unsafe {
-        from_raw_parts(s, 1)
+        transmute(RawSlice { data: s, len: 1 })
     }
 }
 
 /// Converts a pointer to A into a slice of length 1 (without copying).
 #[unstable(feature = "core")]
 pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
     unsafe {
-        from_raw_parts_mut(s, 1)
+        let ptr: *const A = transmute(s);
+        transmute(RawSlice { data: ptr, len: 1 })
     }
 }