---

yaml
---
r: 190127
b: refs/heads/auto
c: 82bcc55
h: refs/heads/master
i:
  190125: f77c88f
  190123: 120f3f3
  190119: 158bae9
  190111: dfe9adb
v: v3

Author: Manishearth

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 766a4e1acc06061a30cf456840a9915526fb681e
+refs/heads/auto: 82bcc552327e1cb0b82d35caf04c4a3d07769561
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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 })
     }
 }
 

branches/auto/src/librustc_llvm/archive_ro.rs

@@ -14,7 +14,8 @@ use libc;
 use ArchiveRef;
 
 use std::ffi::CString;
-use std::slice;
+use std::mem;
+use std::raw;
 use std::path::Path;
 
 pub struct ArchiveRO {
@@ -61,7 +62,10 @@ impl ArchiveRO {
             if ptr.is_null() {
                 None
             } else {
-                Some(slice::from_raw_parts(ptr as *const u8, size as uint))
+                Some(mem::transmute(raw::Slice {
+                    data: ptr,
+                    len: size as uint,
+                }))
             }
         }
     }

branches/auto/src/librustc_llvm/lib.rs

@@ -26,6 +26,7 @@
 
 #![feature(box_syntax)]
 #![feature(collections)]
+#![feature(core)]
 #![feature(int_uint)]
 #![feature(libc)]
 #![feature(link_args)]
@@ -57,7 +58,7 @@ pub use self::Linkage::*;
 
 use std::ffi::CString;
 use std::cell::RefCell;
-use std::{slice, mem};
+use std::{raw, mem};
 use libc::{c_uint, c_ushort, uint64_t, c_int, size_t, c_char};
 use libc::{c_longlong, c_ulonglong, c_void};
 use debuginfo::{DIBuilderRef, DIDescriptor,
@@ -2225,7 +2226,10 @@ type RustStringRepr = *mut RefCell<Vec<u8>>;
 pub unsafe extern "C" fn rust_llvm_string_write_impl(sr: RustStringRef,
                                                      ptr: *const c_char,
                                                      size: size_t) {
-    let slice = slice::from_raw_parts(ptr as *const u8, size as uint);
+    let slice: &[u8] = mem::transmute(raw::Slice {
+        data: ptr as *const u8,
+        len: size as uint,
+    });
 
     let sr: RustStringRepr = mem::transmute(sr);
     (*sr).borrow_mut().push_all(slice);

branches/auto/src/libstd/old_io/mod.rs

@@ -931,15 +931,15 @@ impl<'a> Reader for &'a mut (Reader+'a) {
 // Private function here because we aren't sure if we want to expose this as
 // API yet. If so, it should be a method on Vec.
 unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -> &'a mut [T] {
-    use slice;
+    use raw::Slice;
     use ptr::PtrExt;
 
     assert!(start <= end);
     assert!(end <= v.capacity());
-    slice::from_raw_parts_mut(
-        v.as_mut_ptr().offset(start as int),
-        end - start
-    )
+    transmute(Slice {
+        data: v.as_ptr().offset(start as int),
+        len: end - start
+    })
 }
 
 /// A `RefReader` is a struct implementing `Reader` which contains a reference

branches/auto/src/libstd/sys/common/wtf8.rs

@@ -29,6 +29,7 @@ use core::prelude::*;
 
 use core::char::{encode_utf8_raw, encode_utf16_raw};
 use core::str::{char_range_at_raw, next_code_point};
+use core::raw::Slice as RawSlice;
 
 use ascii::*;
 use borrow::Cow;
@@ -213,10 +214,10 @@ impl Wtf8Buf {
         unsafe {
             // Attempt to not use an intermediate buffer by just pushing bytes
             // directly onto this string.
-            let slice = slice::from_raw_parts_mut(
-                self.bytes.as_mut_ptr().offset(cur_len as int),
-                4
-            );
+            let slice = RawSlice {
+                data: self.bytes.as_ptr().offset(cur_len as int),
+                len: 4,
+            };
             let used = encode_utf8_raw(code_point.value, mem::transmute(slice))
                 .unwrap_or(0);
             self.bytes.set_len(cur_len + used);
@@ -724,11 +725,10 @@ pub fn is_code_point_boundary(slice: &Wtf8, index: uint) -> bool {
 /// Copied from core::str::raw::slice_unchecked
 #[inline]
 pub unsafe fn slice_unchecked(s: &Wtf8, begin: uint, end: uint) -> &Wtf8 {
-    // memory layout of an &[u8] and &Wtf8 are the same
-    mem::transmute(slice::from_raw_parts(
-        s.bytes.as_ptr().offset(begin as int),
-        end - begin
-    ))
+    mem::transmute(RawSlice {
+        data: s.bytes.as_ptr().offset(begin as int),
+        len: end - begin,
+    })
 }
 
 /// Copied from core::str::raw::slice_error_fail

branches/auto/src/libtest/lib.rs

@@ -123,7 +123,6 @@ impl fmt::Display for TestName {
 #[derive(Clone, Copy)]
 enum NamePadding {
     PadNone,
-    #[allow(dead_code)]
     PadOnLeft,
     PadOnRight,
 }

branches/auto/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs

@@ -12,6 +12,7 @@
 // type is `&mut [u8]`, passes in a pointer to the lvalue and not a
 // temporary. Issue #19147.
 
+use std::raw;
 use std::mem;
 use std::slice;
 use std::old_io::IoResult;
@@ -26,10 +27,10 @@ impl<'a> MyWriter for &'a mut [u8] {
 
         let write_len = buf.len();
         unsafe {
-            *self = slice::from_raw_parts_mut(
-                self.as_mut_ptr().offset(write_len as isize),
-                self.len() - write_len
-            );
+            *self = mem::transmute(raw::Slice {
+                data: self.as_ptr().offset(write_len as int),
+                len: self.len() - write_len,
+            });
         }
 
         Ok(())