Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit dccd17d

Browse files
committedMar 18, 2015
Remove the newly introduced trait impls for fixed-size arrays and use &b"..."[..] instead.
1 parent d2cccd0 commit dccd17d

File tree

10 files changed

+159
-175
lines changed

10 files changed

+159
-175
lines changed
 

‎src/librustc_trans/trans/debuginfo.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4054,7 +4054,7 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTree
40544054
/// .debug_gdb_scripts global is referenced, so it isn't removed by the linker.
40554055
pub fn insert_reference_to_gdb_debug_scripts_section_global(ccx: &CrateContext) {
40564056
if needs_gdb_debug_scripts_section(ccx) {
4057-
let empty = CString::new(b"").unwrap();
4057+
let empty = CString::new("").unwrap();
40584058
let gdb_debug_scripts_section_global =
40594059
get_or_insert_gdb_debug_scripts_section_global(ccx);
40604060
unsafe {

‎src/libstd/ffi/c_str.rs

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@
1111
#![unstable(feature = "std_misc")]
1212

1313
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
14-
use core::array::FixedSizeArray;
1514
use error::{Error, FromError};
1615
use fmt;
1716
use io;
@@ -59,7 +58,7 @@ use vec::Vec;
5958
/// fn my_printer(s: *const libc::c_char);
6059
/// }
6160
///
62-
/// let to_print = b"Hello, world!";
61+
/// let to_print = &b"Hello, world!"[..];
6362
/// let c_to_print = CString::new(to_print).unwrap();
6463
/// unsafe {
6564
/// my_printer(c_to_print.as_ptr());
@@ -451,9 +450,6 @@ impl IntoBytes for String {
451450
impl IntoBytes for Vec<u8> {
452451
fn into_bytes(self) -> Vec<u8> { self }
453452
}
454-
impl<'a, T: FixedSizeArray<u8>> IntoBytes for &'a T {
455-
fn into_bytes(self) -> Vec<u8> { self.as_slice().to_vec() }
456-
}
457453

458454
#[cfg(test)]
459455
mod tests {
@@ -473,14 +469,14 @@ mod tests {
473469

474470
#[test]
475471
fn simple() {
476-
let s = CString::new(b"1234").unwrap();
472+
let s = CString::new("1234").unwrap();
477473
assert_eq!(s.as_bytes(), b"1234");
478474
assert_eq!(s.as_bytes_with_nul(), b"1234\0");
479475
}
480476

481477
#[test]
482478
fn build_with_zero1() {
483-
assert!(CString::new(b"\0").is_err());
479+
assert!(CString::new(&b"\0"[..]).is_err());
484480
}
485481
#[test]
486482
fn build_with_zero2() {
@@ -497,7 +493,7 @@ mod tests {
497493

498494
#[test]
499495
fn formatted() {
500-
let s = CString::new(b"12").unwrap();
496+
let s = CString::new(&b"12"[..]).unwrap();
501497
assert_eq!(format!("{:?}", s), "\"12\"");
502498
}
503499

‎src/libstd/io/cursor.rs

Lines changed: 5 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@
1111
use prelude::v1::*;
1212
use io::prelude::*;
1313

14-
use core::array::FixedSizeArray;
1514
use cmp;
1615
use io::{self, SeekFrom, Error, ErrorKind};
1716
use iter::repeat;
@@ -73,7 +72,7 @@ macro_rules! seek {
7372
fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
7473
let pos = match style {
7574
SeekFrom::Start(n) => { self.pos = n; return Ok(n) }
76-
SeekFrom::End(n) => self.inner.as_slice().len() as i64 + n,
75+
SeekFrom::End(n) => self.inner.len() as i64 + n,
7776
SeekFrom::Current(n) => self.pos as i64 + n,
7877
};
7978

@@ -95,7 +94,6 @@ impl<'a> io::Seek for Cursor<&'a [u8]> { seek!(); }
9594
impl<'a> io::Seek for Cursor<&'a mut [u8]> { seek!(); }
9695
#[stable(feature = "rust1", since = "1.0.0")]
9796
impl io::Seek for Cursor<Vec<u8>> { seek!(); }
98-
impl<'a, T: FixedSizeArray<u8>> io::Seek for Cursor<&'a T> { seek!(); }
9997

10098
macro_rules! read {
10199
() => {
@@ -113,13 +111,12 @@ impl<'a> Read for Cursor<&'a [u8]> { read!(); }
113111
impl<'a> Read for Cursor<&'a mut [u8]> { read!(); }
114112
#[stable(feature = "rust1", since = "1.0.0")]
115113
impl Read for Cursor<Vec<u8>> { read!(); }
116-
impl<'a, T: FixedSizeArray<u8>> Read for Cursor<&'a T> { read!(); }
117114

118115
macro_rules! buffer {
119116
() => {
120117
fn fill_buf(&mut self) -> io::Result<&[u8]> {
121-
let amt = cmp::min(self.pos, self.inner.as_slice().len() as u64);
122-
Ok(&self.inner.as_slice()[(amt as usize)..])
118+
let amt = cmp::min(self.pos, self.inner.len() as u64);
119+
Ok(&self.inner[(amt as usize)..])
123120
}
124121
fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
125122
}
@@ -131,7 +128,6 @@ impl<'a> BufRead for Cursor<&'a [u8]> { buffer!(); }
131128
impl<'a> BufRead for Cursor<&'a mut [u8]> { buffer!(); }
132129
#[stable(feature = "rust1", since = "1.0.0")]
133130
impl<'a> BufRead for Cursor<Vec<u8>> { buffer!(); }
134-
impl<'a, T: FixedSizeArray<u8>> BufRead for Cursor<&'a T> { buffer!(); }
135131

136132
#[stable(feature = "rust1", since = "1.0.0")]
137133
impl<'a> Write for Cursor<&'a mut [u8]> {
@@ -332,7 +328,7 @@ mod tests {
332328

333329
#[test]
334330
fn test_read_char() {
335-
let b = b"Vi\xE1\xBB\x87t";
331+
let b = &b"Vi\xE1\xBB\x87t"[..];
336332
let mut c = Cursor::new(b).chars();
337333
assert_eq!(c.next(), Some(Ok('V')));
338334
assert_eq!(c.next(), Some(Ok('i')));
@@ -343,7 +339,7 @@ mod tests {
343339

344340
#[test]
345341
fn test_read_bad_char() {
346-
let b = b"\x80";
342+
let b = &b"\x80"[..];
347343
let mut c = Cursor::new(b).chars();
348344
assert!(c.next().unwrap().is_err());
349345
}

‎src/libstd/io/mod.rs

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -933,12 +933,12 @@ mod tests {
933933

934934
#[test]
935935
fn read_until() {
936-
let mut buf = Cursor::new(b"12");
936+
let mut buf = Cursor::new(&b"12"[..]);
937937
let mut v = Vec::new();
938938
assert_eq!(buf.read_until(b'3', &mut v), Ok(2));
939939
assert_eq!(v, b"12");
940940

941-
let mut buf = Cursor::new(b"1233");
941+
let mut buf = Cursor::new(&b"1233"[..]);
942942
let mut v = Vec::new();
943943
assert_eq!(buf.read_until(b'3', &mut v), Ok(3));
944944
assert_eq!(v, b"123");
@@ -952,12 +952,12 @@ mod tests {
952952

953953
#[test]
954954
fn split() {
955-
let buf = Cursor::new(b"12");
955+
let buf = Cursor::new(&b"12"[..]);
956956
let mut s = buf.split(b'3');
957957
assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
958958
assert_eq!(s.next(), None);
959959

960-
let buf = Cursor::new(b"1233");
960+
let buf = Cursor::new(&b"1233"[..]);
961961
let mut s = buf.split(b'3');
962962
assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
963963
assert_eq!(s.next(), Some(Ok(vec![])));
@@ -966,12 +966,12 @@ mod tests {
966966

967967
#[test]
968968
fn read_line() {
969-
let mut buf = Cursor::new(b"12");
969+
let mut buf = Cursor::new(&b"12"[..]);
970970
let mut v = String::new();
971971
assert_eq!(buf.read_line(&mut v), Ok(2));
972972
assert_eq!(v, "12");
973973

974-
let mut buf = Cursor::new(b"12\n\n");
974+
let mut buf = Cursor::new(&b"12\n\n"[..]);
975975
let mut v = String::new();
976976
assert_eq!(buf.read_line(&mut v), Ok(3));
977977
assert_eq!(v, "12\n");
@@ -985,12 +985,12 @@ mod tests {
985985

986986
#[test]
987987
fn lines() {
988-
let buf = Cursor::new(b"12");
988+
let buf = Cursor::new(&b"12"[..]);
989989
let mut s = buf.lines();
990990
assert_eq!(s.next(), Some(Ok("12".to_string())));
991991
assert_eq!(s.next(), None);
992992

993-
let buf = Cursor::new(b"12\n\n");
993+
let buf = Cursor::new(&b"12\n\n"[..]);
994994
let mut s = buf.lines();
995995
assert_eq!(s.next(), Some(Ok("12".to_string())));
996996
assert_eq!(s.next(), Some(Ok(String::new())));
@@ -999,30 +999,30 @@ mod tests {
999999

10001000
#[test]
10011001
fn read_to_end() {
1002-
let mut c = Cursor::new(b"");
1002+
let mut c = Cursor::new(&b""[..]);
10031003
let mut v = Vec::new();
10041004
assert_eq!(c.read_to_end(&mut v), Ok(0));
10051005
assert_eq!(v, []);
10061006

1007-
let mut c = Cursor::new(b"1");
1007+
let mut c = Cursor::new(&b"1"[..]);
10081008
let mut v = Vec::new();
10091009
assert_eq!(c.read_to_end(&mut v), Ok(1));
10101010
assert_eq!(v, b"1");
10111011
}
10121012

10131013
#[test]
10141014
fn read_to_string() {
1015-
let mut c = Cursor::new(b"");
1015+
let mut c = Cursor::new(&b""[..]);
10161016
let mut v = String::new();
10171017
assert_eq!(c.read_to_string(&mut v), Ok(0));
10181018
assert_eq!(v, "");
10191019

1020-
let mut c = Cursor::new(b"1");
1020+
let mut c = Cursor::new(&b"1"[..]);
10211021
let mut v = String::new();
10221022
assert_eq!(c.read_to_string(&mut v), Ok(1));
10231023
assert_eq!(v, "1");
10241024

1025-
let mut c = Cursor::new(b"\xff");
1025+
let mut c = Cursor::new(&b"\xff"[..]);
10261026
let mut v = String::new();
10271027
assert!(c.read_to_string(&mut v).is_err());
10281028
}

‎src/libstd/old_io/process.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1231,7 +1231,7 @@ mod tests {
12311231
cmd.env("path", "foo");
12321232
cmd.env("Path", "bar");
12331233
let env = &cmd.env.unwrap();
1234-
let val = env.get(&EnvKey(CString::new(b"PATH").unwrap()));
1235-
assert!(val.unwrap() == &CString::new(b"bar").unwrap());
1234+
let val = env.get(&EnvKey(CString::new("PATH").unwrap()));
1235+
assert!(val.unwrap() == &CString::new("bar").unwrap());
12361236
}
12371237
}

‎src/libstd/old_path/mod.rs

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,6 @@
6464
#![allow(deprecated)] // seriously this is all deprecated
6565
#![allow(unused_imports)]
6666

67-
use core::array::FixedSizeArray;
6867
use core::marker::Sized;
6968
use ffi::CString;
7069
use clone::Clone;
@@ -896,13 +895,6 @@ impl BytesContainer for [u8] {
896895
}
897896
}
898897

899-
impl<T: FixedSizeArray<u8>> BytesContainer for T {
900-
#[inline]
901-
fn container_as_bytes(&self) -> &[u8] {
902-
self.as_slice()
903-
}
904-
}
905-
906898
impl BytesContainer for Vec<u8> {
907899
#[inline]
908900
fn container_as_bytes(&self) -> &[u8] {

‎src/libstd/old_path/posix.rs

Lines changed: 93 additions & 93 deletions
Large diffs are not rendered by default.

‎src/libstd/old_path/windows.rs

Lines changed: 35 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1217,8 +1217,8 @@ mod tests {
12171217
fn test_paths() {
12181218
let empty: &[u8] = &[];
12191219
t!(v: Path::new(empty), b".");
1220-
t!(v: Path::new(b"\\"), b"\\");
1221-
t!(v: Path::new(b"a\\b\\c"), b"a\\b\\c");
1220+
t!(v: Path::new(&b"\\"[..]), b"\\");
1221+
t!(v: Path::new(&b"a\\b\\c"[..]), b"a\\b\\c");
12221222

12231223
t!(s: Path::new(""), ".");
12241224
t!(s: Path::new("\\"), "\\");
@@ -1250,8 +1250,8 @@ mod tests {
12501250
t!(s: Path::new("foo\\..\\..\\.."), "..\\..");
12511251
t!(s: Path::new("foo\\..\\..\\bar"), "..\\bar");
12521252

1253-
assert_eq!(Path::new(b"foo\\bar").into_vec(), b"foo\\bar");
1254-
assert_eq!(Path::new(b"\\foo\\..\\..\\bar").into_vec(), b"\\bar");
1253+
assert_eq!(Path::new(&b"foo\\bar"[..]).into_vec(), b"foo\\bar");
1254+
assert_eq!(Path::new(&b"\\foo\\..\\..\\bar"[..]).into_vec(), b"\\bar");
12551255

12561256
t!(s: Path::new("\\\\a"), "\\a");
12571257
t!(s: Path::new("\\\\a\\"), "\\a");
@@ -1304,9 +1304,9 @@ mod tests {
13041304

13051305
#[test]
13061306
fn test_opt_paths() {
1307-
assert!(Path::new_opt(b"foo\\bar\0") == None);
1308-
assert!(Path::new_opt(b"foo\\bar\x80") == None);
1309-
t!(v: Path::new_opt(b"foo\\bar").unwrap(), b"foo\\bar");
1307+
assert!(Path::new_opt(&b"foo\\bar\0"[..]) == None);
1308+
assert!(Path::new_opt(&b"foo\\bar\x80"[..]) == None);
1309+
t!(v: Path::new_opt(&b"foo\\bar"[..]).unwrap(), b"foo\\bar");
13101310
assert!(Path::new_opt("foo\\bar\0") == None);
13111311
t!(s: Path::new_opt("foo\\bar").unwrap(), "foo\\bar");
13121312
}
@@ -1315,38 +1315,38 @@ mod tests {
13151315
fn test_null_byte() {
13161316
use thread;
13171317
let result = thread::spawn(move|| {
1318-
Path::new(b"foo/bar\0");
1318+
Path::new(&b"foo/bar\0"[..]);
13191319
}).join();
13201320
assert!(result.is_err());
13211321

13221322
let result = thread::spawn(move|| {
1323-
Path::new("test").set_filename(b"f\0o")
1323+
Path::new("test").set_filename(&b"f\0o"[..])
13241324
}).join();
13251325
assert!(result.is_err());
13261326

13271327
let result = thread::spawn(move || {
1328-
Path::new("test").push(b"f\0o");
1328+
Path::new("test").push(&b"f\0o"[..]);
13291329
}).join();
13301330
assert!(result.is_err());
13311331
}
13321332

13331333
#[test]
13341334
#[should_panic]
13351335
fn test_not_utf8_panics() {
1336-
Path::new(b"hello\x80.txt");
1336+
Path::new(&b"hello\x80.txt"[..]);
13371337
}
13381338

13391339
#[test]
13401340
fn test_display_str() {
13411341
let path = Path::new("foo");
13421342
assert_eq!(path.display().to_string(), "foo");
1343-
let path = Path::new(b"\\");
1343+
let path = Path::new(&b"\\"[..]);
13441344
assert_eq!(path.filename_display().to_string(), "");
13451345

13461346
let path = Path::new("foo");
13471347
let mo = path.display().as_cow();
13481348
assert_eq!(mo, "foo");
1349-
let path = Path::new(b"\\");
1349+
let path = Path::new(&b"\\"[..]);
13501350
let mo = path.filename_display().as_cow();
13511351
assert_eq!(mo, "");
13521352
}
@@ -1397,7 +1397,7 @@ mod tests {
13971397
)
13981398
}
13991399

1400-
t!(v: b"a\\b\\c", filename, Some(&b"c"[..]));
1400+
t!(v: &b"a\\b\\c"[..], filename, Some(&b"c"[..]));
14011401
t!(s: "a\\b\\c", filename_str, "c");
14021402
t!(s: "\\a\\b\\c", filename_str, "c");
14031403
t!(s: "a", filename_str, "a");
@@ -1430,7 +1430,7 @@ mod tests {
14301430
t!(s: "\\\\.\\", filename_str, None, opt);
14311431
t!(s: "\\\\?\\a\\b\\", filename_str, "b");
14321432

1433-
t!(v: b"a\\b\\c", dirname, b"a\\b");
1433+
t!(v: &b"a\\b\\c"[..], dirname, b"a\\b");
14341434
t!(s: "a\\b\\c", dirname_str, "a\\b");
14351435
t!(s: "\\a\\b\\c", dirname_str, "\\a\\b");
14361436
t!(s: "a", dirname_str, ".");
@@ -1461,7 +1461,7 @@ mod tests {
14611461
t!(s: "\\\\.\\foo", dirname_str, "\\\\.\\foo");
14621462
t!(s: "\\\\?\\a\\b\\", dirname_str, "\\\\?\\a");
14631463

1464-
t!(v: b"hi\\there.txt", filestem, Some(&b"there"[..]));
1464+
t!(v: &b"hi\\there.txt"[..], filestem, Some(&b"there"[..]));
14651465
t!(s: "hi\\there.txt", filestem_str, "there");
14661466
t!(s: "hi\\there", filestem_str, "there");
14671467
t!(s: "there.txt", filestem_str, "there");
@@ -1476,8 +1476,8 @@ mod tests {
14761476
t!(s: "..\\..", filestem_str, None, opt);
14771477
// filestem is based on filename, so we don't need the full set of prefix tests
14781478

1479-
t!(v: b"hi\\there.txt", extension, Some(&b"txt"[..]));
1480-
t!(v: b"hi\\there", extension, None);
1479+
t!(v: &b"hi\\there.txt"[..], extension, Some(&b"txt"[..]));
1480+
t!(v: &b"hi\\there"[..], extension, None);
14811481
t!(s: "hi\\there.txt", extension_str, Some("txt"), opt);
14821482
t!(s: "hi\\there", extension_str, None, opt);
14831483
t!(s: "there.txt", extension_str, Some("txt"), opt);
@@ -1603,9 +1603,9 @@ mod tests {
16031603
t!(s: "a\\b\\c", ["d", "\\e"], "\\e");
16041604
t!(s: "a\\b\\c", ["d", "\\e", "f"], "\\e\\f");
16051605
t!(s: "a\\b\\c", ["d".to_string(), "e".to_string()], "a\\b\\c\\d\\e");
1606-
t!(v: b"a\\b\\c", [&b"d"[..], &b"e"[..]], b"a\\b\\c\\d\\e");
1607-
t!(v: b"a\\b\\c", [&b"d"[..], &b"\\e"[..], &b"f"[..]], b"\\e\\f");
1608-
t!(v: b"a\\b\\c", [b"d".to_vec(), b"e".to_vec()],
1606+
t!(v: &b"a\\b\\c"[..], [&b"d"[..], &b"e"[..]], b"a\\b\\c\\d\\e");
1607+
t!(v: &b"a\\b\\c"[..], [&b"d"[..], &b"\\e"[..], &b"f"[..]], b"\\e\\f");
1608+
t!(v: &b"a\\b\\c"[..], [b"d".to_vec(), b"e".to_vec()],
16091609
b"a\\b\\c\\d\\e");
16101610
}
16111611

@@ -1637,11 +1637,11 @@ mod tests {
16371637
t!(s: ".", ".", false);
16381638
t!(s: "\\a", "\\", true);
16391639
t!(s: "\\", "\\", false);
1640-
t!(b: b"a\\b\\c", b"a\\b", true);
1641-
t!(b: b"a", b".", true);
1642-
t!(b: b".", b".", false);
1643-
t!(b: b"\\a", b"\\", true);
1644-
t!(b: b"\\", b"\\", false);
1640+
t!(b: &b"a\\b\\c"[..], b"a\\b", true);
1641+
t!(b: &b"a"[..], b".", true);
1642+
t!(b: &b"."[..], b".", false);
1643+
t!(b: &b"\\a"[..], b"\\", true);
1644+
t!(b: &b"\\"[..], b"\\", false);
16451645

16461646
t!(s: "C:\\a\\b", "C:\\a", true);
16471647
t!(s: "C:\\a", "C:\\", true);
@@ -1690,8 +1690,8 @@ mod tests {
16901690
t!(s: Path::new("a\\b").join("\\c\\d"), "\\c\\d");
16911691
t!(s: Path::new(".").join("a\\b"), "a\\b");
16921692
t!(s: Path::new("\\").join("a\\b"), "\\a\\b");
1693-
t!(v: Path::new(b"a\\b\\c").join(b".."), b"a\\b");
1694-
t!(v: Path::new(b"\\a\\b\\c").join(b"d"), b"\\a\\b\\c\\d");
1693+
t!(v: Path::new(&b"a\\b\\c"[..]).join(&b".."[..]), b"a\\b");
1694+
t!(v: Path::new(&b"\\a\\b\\c"[..]).join(&b"d"[..]), b"\\a\\b\\c\\d");
16951695
// full join testing is covered under test_push_path, so no need for
16961696
// the full set of prefix tests
16971697
}
@@ -1742,8 +1742,8 @@ mod tests {
17421742
t!(s: "a\\b\\c", ["..", "d"], "a\\b\\d");
17431743
t!(s: "a\\b\\c", ["d", "\\e", "f"], "\\e\\f");
17441744
t!(s: "a\\b\\c", ["d".to_string(), "e".to_string()], "a\\b\\c\\d\\e");
1745-
t!(v: b"a\\b\\c", [b"d", b"e"], b"a\\b\\c\\d\\e");
1746-
t!(v: b"a\\b\\c", [b"d".to_vec(), b"e".to_vec()],
1745+
t!(v: &b"a\\b\\c"[..], [&b"d"[..], &b"e"[..]], b"a\\b\\c\\d\\e");
1746+
t!(v: &b"a\\b\\c"[..], [b"d".to_vec(), b"e".to_vec()],
17471747
b"a\\b\\c\\d\\e");
17481748
}
17491749

@@ -1855,15 +1855,15 @@ mod tests {
18551855
)
18561856
}
18571857

1858-
t!(v: b"a\\b\\c", set_filename, with_filename, b"d");
1859-
t!(v: b"\\", set_filename, with_filename, b"foo");
1858+
t!(v: &b"a\\b\\c"[..], set_filename, with_filename, &b"d"[..]);
1859+
t!(v: &b"\\"[..], set_filename, with_filename, &b"foo"[..]);
18601860
t!(s: "a\\b\\c", set_filename, with_filename, "d");
18611861
t!(s: "\\", set_filename, with_filename, "foo");
18621862
t!(s: ".", set_filename, with_filename, "foo");
18631863
t!(s: "a\\b", set_filename, with_filename, "");
18641864
t!(s: "a", set_filename, with_filename, "");
18651865

1866-
t!(v: b"hi\\there.txt", set_extension, with_extension, b"exe");
1866+
t!(v: &b"hi\\there.txt"[..], set_extension, with_extension, &b"exe"[..]);
18671867
t!(s: "hi\\there.txt", set_extension, with_extension, "exe");
18681868
t!(s: "hi\\there.", set_extension, with_extension, "txt");
18691869
t!(s: "hi\\there", set_extension, with_extension, "txt");
@@ -1898,7 +1898,7 @@ mod tests {
18981898
)
18991899
}
19001900

1901-
t!(v: Path::new(b"a\\b\\c"), Some(&b"c"[..]), b"a\\b", Some(&b"c"[..]), None);
1901+
t!(v: Path::new(&b"a\\b\\c"[..]), Some(&b"c"[..]), b"a\\b", Some(&b"c"[..]), None);
19021902
t!(s: Path::new("a\\b\\c"), Some("c"), Some("a\\b"), Some("c"), None);
19031903
t!(s: Path::new("."), None, Some("."), None, None);
19041904
t!(s: Path::new("\\"), None, Some("\\"), None, None);
@@ -2240,7 +2240,7 @@ mod tests {
22402240
);
22412241
}
22422242

2243-
t!(s: b"a\\b\\c", ["a", "b", "c"]);
2243+
t!(s: &b"a\\b\\c"[..], ["a", "b", "c"]);
22442244
t!(s: "a\\b\\c", ["a", "b", "c"]);
22452245
t!(s: "a\\b\\d", ["a", "b", "d"]);
22462246
t!(s: "a\\b\\cd", ["a", "b", "cd"]);

‎src/test/run-pass/rename-directory.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,11 +32,11 @@ fn rename_directory() {
3232

3333
/* Write the temp input file */
3434
let fromp = CString::new(test_file.as_vec()).unwrap();
35-
let modebuf = CString::new(b"w+b").unwrap();
35+
let modebuf = CString::new(&b"w+b"[..]).unwrap();
3636
let ostream = libc::fopen(fromp.as_ptr(), modebuf.as_ptr());
3737
assert!((ostream as uint != 0));
3838
let s = "hello".to_string();
39-
let buf = CString::new(b"hello").unwrap();
39+
let buf = CString::new(&b"hello"[..]).unwrap();
4040
let write_len = libc::fwrite(buf.as_ptr() as *mut _,
4141
1_usize as libc::size_t,
4242
(s.len() + 1_usize) as libc::size_t,

‎src/test/run-pass/variadic-ffi.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,11 @@ pub fn main() {
2828

2929
unsafe {
3030
// Call with just the named parameter
31-
let c = CString::new(b"Hello World\n").unwrap();
31+
let c = CString::new(&b"Hello World\n"[..]).unwrap();
3232
check("Hello World\n", |s| sprintf(s, c.as_ptr()));
3333

3434
// Call with variable number of arguments
35-
let c = CString::new(b"%d %f %c %s\n").unwrap();
35+
let c = CString::new(&b"%d %f %c %s\n"[..]).unwrap();
3636
check("42 42.500000 a %d %f %c %s\n\n", |s| {
3737
sprintf(s, c.as_ptr(), 42, 42.5f64, 'a' as c_int, c.as_ptr());
3838
});
@@ -43,11 +43,11 @@ pub fn main() {
4343
// A function that takes a function pointer
4444
unsafe fn call(p: unsafe extern fn(*mut c_char, *const c_char, ...) -> c_int) {
4545
// Call with just the named parameter
46-
let c = CString::new(b"Hello World\n").unwrap();
46+
let c = CString::new(&b"Hello World\n"[..]).unwrap();
4747
check("Hello World\n", |s| sprintf(s, c.as_ptr()));
4848

4949
// Call with variable number of arguments
50-
let c = CString::new(b"%d %f %c %s\n").unwrap();
50+
let c = CString::new(&b"%d %f %c %s\n"[..]).unwrap();
5151
check("42 42.500000 a %d %f %c %s\n\n", |s| {
5252
sprintf(s, c.as_ptr(), 42, 42.5f64, 'a' as c_int, c.as_ptr());
5353
});

0 commit comments

Comments
 (0)
Please sign in to comment.