OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cleanup: s/`v.slice*()`/`&v[a..b]`/g + remove redundant `as_slice()` calls

This commit is contained in:
Jorge Aparicio 2015-01-26 21:21:15 -05:00
parent d77f6d5366
commit bce81e2464
59 changed files with 156 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/compiletest/compiletest.rs
View File

@ -361,8 +361,8 @@ pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::Test
fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
match full_version_line {
Some(ref full_version_line)
if full_version_line.as_slice().trim().len() > 0 => {
let full_version_line = full_version_line.as_slice().trim();
if full_version_line.trim().len() > 0 => {
let full_version_line = full_version_line.trim();
// used to be a regex "(^|[^0-9])([0-9]\.[0-9])([^0-9]|$)"
for (pos, c) in full_version_line.char_indices() {
@ -401,8 +401,8 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
match full_version_line {
Some(ref full_version_line)
if full_version_line.as_slice().trim().len() > 0 => {
let full_version_line = full_version_line.as_slice().trim();
if full_version_line.trim().len() > 0 => {
let full_version_line = full_version_line.trim();
for (pos, l) in full_version_line.char_indices() {
if l != 'l' && l != 'L' { continue }

8
src/compiletest/header.rs
View File

@ -149,7 +149,7 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
}
fn ignore_stage(config: &Config) -> String {
format!("ignore-{}",
config.stage_id.as_slice().split('-').next().unwrap())
config.stage_id.split('-').next().unwrap())
}
fn ignore_gdb(config: &Config, line: &str) -> bool {
if config.mode != common::DebugInfoGdb {
@ -231,11 +231,11 @@ fn iter_header<F>(testfile: &Path, mut it: F) -> bool where
// module or function. This doesn't seem to be an optimization
// with a warm page cache. Maybe with a cold one.
let ln = ln.unwrap();
if ln.as_slice().starts_with("fn") ||
ln.as_slice().starts_with("mod") {
if ln.starts_with("fn") ||
ln.starts_with("mod") {
return true;
} else {
if !(it(ln.as_slice().trim())) {
if !(it(ln.trim())) {
return false;
}
}

12
src/compiletest/runtest.rs
View File

@ -777,7 +777,7 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
for line in reader.lines() {
match line {
Ok(line) => {
if line.as_slice().contains("#break") {
if line.contains("#break") {
breakpoint_lines.push(counter);
}
@ -843,7 +843,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
// check if each line in props.check_lines appears in the
// output (in order)
let mut i = 0u;
for line in debugger_run_result.stdout.as_slice().lines() {
for line in debugger_run_result.stdout.lines() {
let mut rest = line.trim();
let mut first = true;
let mut failed = false;
@ -895,7 +895,7 @@ fn check_error_patterns(props: &TestProps,
let mut next_err_idx = 0u;
let mut next_err_pat = &props.error_patterns[next_err_idx];
let mut done = false;
for line in output_to_check.as_slice().lines() {
for line in output_to_check.lines() {
if line.contains(next_err_pat.as_slice()) {
debug!("found error pattern {}", next_err_pat);
next_err_idx += 1u;
@ -924,7 +924,7 @@ fn check_error_patterns(props: &TestProps,
}
fn check_no_compiler_crash(proc_res: &ProcRes) {
for line in proc_res.stderr.as_slice().lines() {
for line in proc_res.stderr.lines() {
if line.starts_with("error: internal compiler error:") {
fatal_proc_rec("compiler encountered internal error",
proc_res);
@ -983,7 +983,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
// filename:line1:col1: line2:col2: *warning:* msg
// where line1:col1: is the starting point, line2:col2:
// is the ending point, and * represents ANSI color codes.
for line in proc_res.stderr.as_slice().lines() {
for line in proc_res.stderr.lines() {
let mut was_expected = false;
for (i, ee) in expected_errors.iter().enumerate() {
if !found_flags[i] {
@ -1536,7 +1536,7 @@ fn _arm_exec_compiled_test(config: &Config,
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
let mut exitcode: int = 0;
for c in exitcode_out.as_slice().chars() {
for c in exitcode_out.chars() {
if !c.is_numeric() { break; }
exitcode = exitcode * 10 + match c {
'0' ... '9' => c as int - ('0' as int),

21
src/grammar/verify.rs
View File

@ -43,8 +43,8 @@ fn parse_token_list(file: &str) -> HashMap<String, token::Token> {
None => continue
};
let val = line.slice_to(eq);
let num = line.slice_from(eq + 1);
let val = &line[..eq];
let num = &line[eq + 1..];
let tok = match val {
"SHR" => token::BinOp(token::Shr),
@ -136,27 +136,27 @@ fn str_to_binop(s: &str) -> token::BinOpToken {
fn fix(mut lit: &str) -> ast::Name {
if lit.char_at(0) == 'r' {
if lit.char_at(1) == 'b' {
lit = lit.slice_from(2)
lit = &lit[2..]
} else {
lit = lit.slice_from(1);
lit = &lit[1..];
}
} else if lit.char_at(0) == 'b' {
lit = lit.slice_from(1);
lit = &lit[1..];
}
let leading_hashes = count(lit);
// +1/-1 to adjust for single quotes
parse::token::intern(lit.slice(leading_hashes + 1, lit.len() - leading_hashes - 1))
parse::token::intern(&lit[leading_hashes + 1..lit.len() - leading_hashes - 1])
}
/// Assuming a char/byte literal, strip the 'b' prefix and the single quotes.
fn fixchar(mut lit: &str) -> ast::Name {
if lit.char_at(0) == 'b' {
lit = lit.slice_from(1);
lit = &lit[1..];
}
parse::token::intern(lit.slice(1, lit.len() - 1))
parse::token::intern(&lit[1..lit.len() - 1])
}
fn count(lit: &str) -> usize {
@ -187,8 +187,7 @@ fn parse_antlr_token(s: &str, tokens: &HashMap<String, token::Token>) -> TokenAn
let real_tok = match *proto_tok {
token::BinOp(..) => token::BinOp(str_to_binop(content)),
token::BinOpEq(..) => token::BinOpEq(str_to_binop(content.slice_to(
content.len() - 1))),
token::BinOpEq(..) => token::BinOpEq(str_to_binop(&content[..content.len() - 1])),
token::Literal(token::Str_(..), n) => token::Literal(token::Str_(fix(content)), n),
token::Literal(token::StrRaw(..), n) => token::Literal(token::StrRaw(fix(content),
count(content)), n),
@ -249,7 +248,7 @@ fn main() {
let mut stdin = std::io::stdin();
let mut lock = stdin.lock();
let lines = lock.lines();
let mut antlr_tokens = lines.map(|l| parse_antlr_token(l.unwrap().as_slice().trim(),
let mut antlr_tokens = lines.map(|l| parse_antlr_token(l.unwrap().trim(),
&token_map));
let code = File::open(&Path::new(args[1].as_slice())).unwrap().read_to_string().unwrap();

62
src/libcollections/slice.rs
View File

@ -1475,21 +1475,21 @@ mod tests {
#[test]
fn test_get() {
let mut a = vec![11i];
assert_eq!(a.as_slice().get(1), None);
assert_eq!(a.get(1), None);
a = vec![11i, 12];
assert_eq!(a.as_slice().get(1).unwrap(), &12);
assert_eq!(a.get(1).unwrap(), &12);
a = vec![11i, 12, 13];
assert_eq!(a.as_slice().get(1).unwrap(), &12);
assert_eq!(a.get(1).unwrap(), &12);
}
#[test]
fn test_first() {
let mut a = vec![];
assert_eq!(a.as_slice().first(), None);
assert_eq!(a.first(), None);
a = vec![11i];
assert_eq!(a.as_slice().first().unwrap(), &11);
assert_eq!(a.first().unwrap(), &11);
a = vec![11i, 12];
assert_eq!(a.as_slice().first().unwrap(), &11);
assert_eq!(a.first().unwrap(), &11);
}
#[test]
@ -1573,11 +1573,11 @@ mod tests {
#[test]
fn test_last() {
let mut a = vec![];
assert_eq!(a.as_slice().last(), None);
assert_eq!(a.last(), None);
a = vec![11i];
assert_eq!(a.as_slice().last().unwrap(), &11);
assert_eq!(a.last().unwrap(), &11);
a = vec![11i, 12];
assert_eq!(a.as_slice().last().unwrap(), &12);
assert_eq!(a.last().unwrap(), &12);
}
#[test]
@ -1798,7 +1798,7 @@ mod tests {
let (min_size, max_opt) = it.size_hint();
assert_eq!(min_size, 1);
assert_eq!(max_opt.unwrap(), 1);
assert_eq!(it.next(), Some(v.as_slice().to_vec()));
assert_eq!(it.next(), Some(v.to_vec()));
assert_eq!(it.next(), None);
}
{
@ -1807,7 +1807,7 @@ mod tests {
let (min_size, max_opt) = it.size_hint();
assert_eq!(min_size, 1);
assert_eq!(max_opt.unwrap(), 1);
assert_eq!(it.next(), Some(v.as_slice().to_vec()));
assert_eq!(it.next(), Some(v.to_vec()));
assert_eq!(it.next(), None);
}
{
@ -1911,10 +1911,10 @@ mod tests {
assert!([].position_elem(&1i).is_none());
let v1 = vec![1i, 2, 3, 3, 2, 5];
assert_eq!(v1.as_slice().position_elem(&1), Some(0u));
assert_eq!(v1.as_slice().position_elem(&2), Some(1u));
assert_eq!(v1.as_slice().position_elem(&5), Some(5u));
assert!(v1.as_slice().position_elem(&4).is_none());
assert_eq!(v1.position_elem(&1), Some(0u));
assert_eq!(v1.position_elem(&2), Some(1u));
assert_eq!(v1.position_elem(&5), Some(5u));
assert!(v1.position_elem(&4).is_none());
}
#[test]
@ -1985,13 +1985,13 @@ mod tests {
let mut v1 = v.clone();
v.sort();
assert!(v.as_slice().windows(2).all(|w| w[0] <= w[1]));
assert!(v.windows(2).all(|w| w[0] <= w[1]));
v1.sort_by(|a, b| a.cmp(b));
assert!(v1.as_slice().windows(2).all(|w| w[0] <= w[1]));
assert!(v1.windows(2).all(|w| w[0] <= w[1]));
v1.sort_by(|a, b| b.cmp(a));
assert!(v1.as_slice().windows(2).all(|w| w[0] >= w[1]));
assert!(v1.windows(2).all(|w| w[0] >= w[1]));
}
}
@ -2030,7 +2030,7 @@ mod tests {
// will need to be ordered with increasing
// counts... i.e. exactly asserting that this sort is
// stable.
assert!(v.as_slice().windows(2).all(|w| w[0] <= w[1]));
assert!(v.windows(2).all(|w| w[0] <= w[1]));
}
}
}
@ -2451,14 +2451,14 @@ mod tests {
assert!(a == [7i,2,3,4]);
let mut a = [1i,2,3,4,5];
let b = vec![5i,6,7,8,9,0];
assert_eq!(a.slice_mut(2, 4).move_from(b,1,6), 2);
assert_eq!(a[2..4].move_from(b,1,6), 2);
assert!(a == [1i,2,6,7,5]);
}
#[test]
fn test_reverse_part() {
let mut values = [1i,2,3,4,5];
values.slice_mut(1, 4).reverse();
values[1..4].reverse();
assert!(values == [1,4,3,2,5]);
}
@ -2505,9 +2505,9 @@ mod tests {
fn test_bytes_set_memory() {
use slice::bytes::MutableByteVector;
let mut values = [1u8,2,3,4,5];
values.slice_mut(0, 5).set_memory(0xAB);
values[0..5].set_memory(0xAB);
assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
values.slice_mut(2, 4).set_memory(0xFF);
values[2..4].set_memory(0xFF);
assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
}
@ -2765,7 +2765,7 @@ mod bench {
let xss: Vec<Vec<uint>> =
range(0, 100u).map(|i| range(0, i).collect()).collect();
b.iter(|| {
xss.as_slice().concat();
xss.concat();
});
}
@ -2774,7 +2774,7 @@ mod bench {
let xss: Vec<Vec<uint>> =
range(0, 100u).map(|i| range(0, i).collect()).collect();
b.iter(|| {
xss.as_slice().connect(&0)
xss.connect(&0)
});
}
@ -2791,7 +2791,7 @@ mod bench {
fn starts_with_same_vector(b: &mut Bencher) {
let vec: Vec<uint> = range(0, 100).collect();
b.iter(|| {
vec.as_slice().starts_with(vec.as_slice())
vec.starts_with(vec.as_slice())
})
}
@ -2799,7 +2799,7 @@ mod bench {
fn starts_with_single_element(b: &mut Bencher) {
let vec: Vec<uint> = vec![0];
b.iter(|| {
vec.as_slice().starts_with(vec.as_slice())
vec.starts_with(vec.as_slice())
})
}
@ -2809,7 +2809,7 @@ mod bench {
let mut match_vec: Vec<uint> = range(0, 99).collect();
match_vec.push(0);
b.iter(|| {
vec.as_slice().starts_with(match_vec.as_slice())
vec.starts_with(match_vec.as_slice())
})
}
@ -2817,7 +2817,7 @@ mod bench {
fn ends_with_same_vector(b: &mut Bencher) {
let vec: Vec<uint> = range(0, 100).collect();
b.iter(|| {
vec.as_slice().ends_with(vec.as_slice())
vec.ends_with(vec.as_slice())
})
}
@ -2825,7 +2825,7 @@ mod bench {
fn ends_with_single_element(b: &mut Bencher) {
let vec: Vec<uint> = vec![0];
b.iter(|| {
vec.as_slice().ends_with(vec.as_slice())
vec.ends_with(vec.as_slice())
})
}
@ -2835,7 +2835,7 @@ mod bench {
let mut match_vec: Vec<uint> = range(0, 100).collect();
match_vec.as_mut_slice()[0] = 200;
b.iter(|| {
vec.as_slice().starts_with(match_vec.as_slice())
vec.starts_with(match_vec.as_slice())
})
}

34
src/libcollections/str.rs
View File

@ -1401,28 +1401,28 @@ mod tests {
assert!("banana".find_str("apple pie").is_none());
let data = "abcabc";
assert_eq!(data.slice(0u, 6u).find_str("ab"), Some(0u));
assert_eq!(data.slice(2u, 6u).find_str("ab"), Some(3u - 2u));
assert!(data.slice(2u, 4u).find_str("ab").is_none());
assert_eq!(data[0u..6u].find_str("ab"), Some(0u));
assert_eq!(data[2u..6u].find_str("ab"), Some(3u - 2u));
assert!(data[2u..4u].find_str("ab").is_none());
let string = "ประเทศไทย中华Việt Nam";
let mut data = String::from_str(string);
data.push_str(string);
assert!(data.find_str("ไท华").is_none());
assert_eq!(data.slice(0u, 43u).find_str(""), Some(0u));
assert_eq!(data.slice(6u, 43u).find_str(""), Some(6u - 6u));
assert_eq!(data[0u..43u].find_str(""), Some(0u));
assert_eq!(data[6u..43u].find_str(""), Some(6u - 6u));
assert_eq!(data.slice(0u, 43u).find_str("ประ"), Some( 0u));
assert_eq!(data.slice(0u, 43u).find_str("ทศไ"), Some(12u));
assert_eq!(data.slice(0u, 43u).find_str("ย中"), Some(24u));
assert_eq!(data.slice(0u, 43u).find_str("iệt"), Some(34u));
assert_eq!(data.slice(0u, 43u).find_str("Nam"), Some(40u));
assert_eq!(data[0u..43u].find_str("ประ"), Some( 0u));
assert_eq!(data[0u..43u].find_str("ทศไ"), Some(12u));
assert_eq!(data[0u..43u].find_str("ย中"), Some(24u));
assert_eq!(data[0u..43u].find_str("iệt"), Some(34u));
assert_eq!(data[0u..43u].find_str("Nam"), Some(40u));
assert_eq!(data.slice(43u, 86u).find_str("ประ"), Some(43u - 43u));
assert_eq!(data.slice(43u, 86u).find_str("ทศไ"), Some(55u - 43u));
assert_eq!(data.slice(43u, 86u).find_str("ย中"), Some(67u - 43u));
assert_eq!(data.slice(43u, 86u).find_str("iệt"), Some(77u - 43u));
assert_eq!(data.slice(43u, 86u).find_str("Nam"), Some(83u - 43u));
assert_eq!(data[43u..86u].find_str("ประ"), Some(43u - 43u));
assert_eq!(data[43u..86u].find_str("ทศไ"), Some(55u - 43u));
assert_eq!(data[43u..86u].find_str("ย中"), Some(67u - 43u));
assert_eq!(data[43u..86u].find_str("iệt"), Some(77u - 43u));
assert_eq!(data[43u..86u].find_str("Nam"), Some(83u - 43u));
}
#[test]
@ -1908,8 +1908,8 @@ mod tests {
#[test]
fn test_subslice_offset() {
let a = "kernelsprite";
let b = a.slice(7, a.len());
let c = a.slice(0, a.len() - 6);
let b = &a[7..a.len()];
let c = &a[0..a.len() - 6];
assert_eq!(a.subslice_offset(b), 7);
assert_eq!(a.subslice_offset(c), 0);

6
src/libcollections/string.rs
View File

@ -1171,11 +1171,11 @@ mod tests {
fn test_push_str() {
let mut s = String::new();
s.push_str("");
assert_eq!(s.slice_from(0), "");
assert_eq!(&s[0..], "");
s.push_str("abc");
assert_eq!(s.slice_from(0), "abc");
assert_eq!(&s[0..], "abc");
s.push_str("ประเทศไทย中华Việt Nam");
assert_eq!(s.slice_from(0), "abcประเทศไทย中华Việt Nam");
assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
}
#[test]

2
src/libcore/result.rs
View File

@ -454,7 +454,7 @@ impl<T, E> Result<T, E> {
/// let line: IoResult<String> = buffer.read_line();
/// // Convert the string line to a number using `map` and `from_str`
/// let val: IoResult<int> = line.map(|line| {
/// line.as_slice().trim_right().parse::<int>().unwrap_or(0)
/// line.trim_right().parse::<int>().unwrap_or(0)
/// });
/// // Add the value if there were no errors, otherwise add 0
/// sum += val.ok().unwrap_or(0);

2
src/libcoretest/str.rs
View File

@ -19,7 +19,7 @@ fn check_contains_all_substrings(s: &str) {
assert!(s.contains(""));
for i in range(0, s.len()) {
for j in range(i+1, s.len() + 1) {
assert!(s.contains(s.slice(i, j)));
assert!(s.contains(&s[i..j]));
}
}
}

33
src/librustc_back/sha2.rs
View File

@ -139,14 +139,14 @@ impl FixedBuffer for FixedBuffer64 {
let buffer_remaining = size - self.buffer_idx;
if input.len() >= buffer_remaining {
copy_memory(
self.buffer.slice_mut(self.buffer_idx, size),
&mut self.buffer[self.buffer_idx..size],
&input[..buffer_remaining]);
self.buffer_idx = 0;
func(&self.buffer);
i += buffer_remaining;
} else {
copy_memory(
self.buffer.slice_mut(self.buffer_idx, self.buffer_idx + input.len()),
&mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()],
input);
self.buffer_idx += input.len();
return;
@ -165,7 +165,7 @@ impl FixedBuffer for FixedBuffer64 {
// be empty.
let input_remaining = input.len() - i;
copy_memory(
self.buffer.slice_to_mut(input_remaining),
&mut self.buffer[..input_remaining],
&input[i..]);
self.buffer_idx += input_remaining;
}
@ -176,13 +176,13 @@ impl FixedBuffer for FixedBuffer64 {
fn zero_until(&mut self, idx: uint) {
assert!(idx >= self.buffer_idx);
self.buffer.slice_mut(self.buffer_idx, idx).set_memory(0);
self.buffer[self.buffer_idx..idx].set_memory(0);
self.buffer_idx = idx;
}
fn next<'s>(&'s mut self, len: uint) -> &'s mut [u8] {
self.buffer_idx += len;
return self.buffer.slice_mut(self.buffer_idx - len, self.buffer_idx);
return &mut self.buffer[self.buffer_idx - len..self.buffer_idx];
}
fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
@ -362,7 +362,7 @@ impl Engine256State {
)
}
read_u32v_be(w.slice_mut(0, 16), data);
read_u32v_be(&mut w[0..16], data);
// Putting the message schedule inside the same loop as the round calculations allows for
// the compiler to generate better code.
@ -498,14 +498,14 @@ impl Digest for Sha256 {
fn result(&mut self, out: &mut [u8]) {
self.engine.finish();
write_u32_be(out.slice_mut(0, 4), self.engine.state.h0);
write_u32_be(out.slice_mut(4, 8), self.engine.state.h1);
write_u32_be(out.slice_mut(8, 12), self.engine.state.h2);
write_u32_be(out.slice_mut(12, 16), self.engine.state.h3);
write_u32_be(out.slice_mut(16, 20), self.engine.state.h4);
write_u32_be(out.slice_mut(20, 24), self.engine.state.h5);
write_u32_be(out.slice_mut(24, 28), self.engine.state.h6);
write_u32_be(out.slice_mut(28, 32), self.engine.state.h7);
write_u32_be(&mut out[0..4], self.engine.state.h0);
write_u32_be(&mut out[4..8], self.engine.state.h1);
write_u32_be(&mut out[8..12], self.engine.state.h2);
write_u32_be(&mut out[12..16], self.engine.state.h3);
write_u32_be(&mut out[16..20], self.engine.state.h4);
write_u32_be(&mut out[20..24], self.engine.state.h5);
write_u32_be(&mut out[24..28], self.engine.state.h6);
write_u32_be(&mut out[28..32], self.engine.state.h7);
}
fn reset(&mut self) {
@ -571,8 +571,7 @@ mod tests {
let mut left = len;
while left > 0u {
let take = (left + 1u) / 2u;
sh.input_str(t.input
.slice(len - left, take + len - left));
sh.input_str(&t.input[len - left..take + len - left]);
left = left - take;
}
let out_str = sh.result_str();
@ -623,7 +622,7 @@ mod tests {
let next: uint = rng.gen_range(0, 2 * blocksize + 1);
let remaining = total_size - count;
let size = if next > remaining { remaining } else { next };
digest.input(buffer.slice_to(size));
digest.input(&buffer[..size]);
count += size;
}

2
src/librustc_trans/back/lto.rs
View File

@ -121,7 +121,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
})
};
let ptr = bc_decoded.as_slice().as_ptr();
let ptr = bc_decoded.as_ptr();
debug!("linking {}, part {}", name, i);
time(sess.time_passes(),
&format!("ll link {}.{}", name, i)[],

2
src/librustdoc/html/format.rs
View File

@ -753,7 +753,7 @@ impl fmt::Display for ModuleSummary {
try!(write!(f, "<tr>"));
try!(write!(f, "<td><a href='{}'>{}</a></td>", {
let mut url = context.slice_from(1).to_vec();
let mut url = context[1..].to_vec();
url.push("index.html");
url.connect("/")
},

8
src/librustdoc/html/render.rs
View File

@ -1348,7 +1348,7 @@ impl<'a> Item<'a> {
};
Some(format!("{root}{path}/{file}?gotosrc={goto}",
root = root,
path = path.slice_to(path.len() - 1).connect("/"),
path = path[..path.len() - 1].connect("/"),
file = item_path(self.item),
goto = self.item.def_id.node))
}
@ -1793,7 +1793,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
cx.current.connect("/")
} else {
let path = &cache.external_paths[it.def_id];
path.slice_to(path.len() - 1).connect("/")
path[..path.len() - 1].connect("/")
},
ty = shortty(it).to_static_str(),
name = *it.name.as_ref().unwrap()));
@ -2197,9 +2197,7 @@ impl<'a> fmt::Display for Sidebar<'a> {
try!(write!(fmt, "::<wbr>"));
}
try!(write!(fmt, "<a href='{}index.html'>{}</a>",
cx.root_path
.as_slice()
.slice_to((cx.current.len() - i - 1) * 3),
&cx.root_path[..(cx.current.len() - i - 1) * 3],
*name));
}
try!(write!(fmt, "</p>"));

2
src/librustdoc/lib.rs
View File

@ -218,7 +218,7 @@ pub fn main_args(args: &[String]) -> int {
let test_args = matches.opt_strs("test-args");
let test_args: Vec<String> = test_args.iter()
.flat_map(|s| s.as_slice().words())
.flat_map(|s| s.words())
.map(|s| s.to_string())
.collect();

2
src/libserialize/hex.rs
View File

@ -107,7 +107,7 @@ impl FromHex for str {
/// fn main () {
/// let hello_str = "Hello, World".as_bytes().to_hex();
/// println!("{}", hello_str);
/// let bytes = hello_str.as_slice().from_hex().unwrap();
/// let bytes = hello_str.from_hex().unwrap();
/// println!("{:?}", bytes);
/// let result_str = String::from_utf8(bytes).unwrap();
/// println!("{}", result_str);

6
src/libstd/old_io/fs.rs
View File

@ -936,11 +936,11 @@ mod test {
{
let mut read_stream = File::open_mode(filename, Open, Read);
{
let read_buf = read_mem.slice_mut(0, 4);
let read_buf = &mut read_mem[0..4];
check!(read_stream.read(read_buf));
}
{
let read_buf = read_mem.slice_mut(4, 8);
let read_buf = &mut read_mem[4..8];
check!(read_stream.read(read_buf));
}
}
@ -971,7 +971,7 @@ mod test {
}
check!(unlink(filename));
let read_str = str::from_utf8(&read_mem).unwrap();
assert_eq!(read_str, message.slice(4, 8));
assert_eq!(read_str, &message[4..8]);
assert_eq!(tell_pos_pre_read, set_cursor);
assert_eq!(tell_pos_post_read, message.len() as u64);
}

2
src/libstd/old_io/mem.rs
View File

@ -645,7 +645,7 @@ mod test {
assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
let b: &[_] = &[1, 2, 3];
assert_eq!(buf, b);
assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
assert!(r.read_at_least(0, &mut buf[..0]).is_ok());
assert_eq!(buf, b);
assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
let b: &[_] = &[4, 5, 6];

2
src/libstd/old_io/net/udp.rs
View File

@ -47,7 +47,7 @@ use sys_common;
/// match socket.recv_from(&mut buf) {
/// Ok((amt, src)) => {
/// // Send a reply to the socket we received data from
/// let buf = buf.slice_to_mut(amt);
/// let buf = &mut buf[..amt];
/// buf.reverse();
/// socket.send_to(buf, src);
/// }

4
src/libstd/path/posix.rs
View File

@ -109,7 +109,7 @@ impl GenericPathUnsafe for Path {
unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Path {
let path = Path::normalize(path.container_as_bytes());
assert!(!path.is_empty());
let idx = path.as_slice().rposition_elem(&SEP_BYTE);
let idx = path.rposition_elem(&SEP_BYTE);
Path{ repr: path, sepidx: idx }
}
@ -290,7 +290,7 @@ impl GenericPath for Path {
}
}
}
Some(Path::new(comps.as_slice().connect(&SEP_BYTE)))
Some(Path::new(comps.connect(&SEP_BYTE)))
}
}

2
src/libstd/rand/reader.rs
View File

@ -107,7 +107,7 @@ mod test {
let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
let mut w = [0u8; 8];
let mut rng = ReaderRng::new(MemReader::new(v.as_slice().to_vec()));
let mut rng = ReaderRng::new(MemReader::new(v.to_vec()));
rng.fill_bytes(&mut w);
assert!(v == w);

2
src/libstd/sys/common/backtrace.rs
View File

@ -94,7 +94,7 @@ pub fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> {
($($pat:expr, => $demangled:expr),*) => ({
$(if rest.starts_with($pat) {
try!(writer.write_str($demangled));
rest = rest.slice_from($pat.len());
rest = &rest[$pat.len()..];
} else)*
{
try!(writer.write_str(rest));

2
src/libtest/stats.rs
View File

@ -942,7 +942,7 @@ mod bench {
let v = range(0, 500).map(|i| nums[i%5]).collect::<Vec<_>>();
b.iter(|| {
v.as_slice().sum();
v.sum();
})
}
}

2
src/test/auxiliary/roman_numerals.rs
View File

@ -52,7 +52,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
match NUMERALS.iter().find(|&&(rn, _)| text.starts_with(rn)) {
Some(&(rn, val)) => {
total += val;
text = text.slice_from(rn.len());
text = &text[rn.len()..];
}
None => {
cx.span_err(sp, "invalid Roman numeral");

2
src/test/bench/core-std.rs
View File

@ -25,7 +25,7 @@ use std::vec;
fn main() {
let argv = os::args();
let _tests = argv.slice(1, argv.len());
let _tests = &argv[1..argv.len()];
macro_rules! bench {
($id:ident) =>

4
src/test/bench/shootout-fannkuch-redux.rs
View File

@ -50,7 +50,7 @@ fn rotate(x: &mut [i32]) {
fn next_permutation(perm: &mut [i32], count: &mut [i32]) {
for i in range(1, perm.len()) {
rotate(perm.slice_to_mut(i + 1));
rotate(&mut perm[..i + 1]);
let count_i = &mut count[i];
if *count_i >= i as i32 {
*count_i = 0;
@ -129,7 +129,7 @@ impl Perm {
fn reverse(tperm: &mut [i32], k: uint) {
tperm.slice_to_mut(k).reverse()
tperm[..k].reverse()
}
fn work(mut perm: Perm, n: uint, max: uint) -> (i32, i32) {

4
src/test/bench/shootout-fasta-redux.rs
View File

@ -127,7 +127,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
copy_memory(buf.as_mut_slice(), alu);
let buf_len = buf.len();
copy_memory(buf.slice_mut(alu_len, buf_len),
copy_memory(&mut buf[alu_len..buf_len],
&alu[..LINE_LEN]);
let mut pos = 0;
@ -135,7 +135,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
let mut n = n;
while n > 0 {
bytes = min(LINE_LEN, n);
try!(self.out.write(buf.slice(pos, pos + bytes)));
try!(self.out.write(&buf[pos..pos + bytes]));
try!(self.out.write_u8('\n' as u8));
pos += bytes;
if pos > alu_len {

4
src/test/bench/shootout-k-nucleotide-pipes.rs
View File

@ -184,7 +184,7 @@ fn main() {
let mut proc_mode = false;
for line in rdr.lines() {
let line = line.unwrap().as_slice().trim().to_string();
let line = line.unwrap().trim().to_string();
if line.len() == 0u { continue; }
@ -192,7 +192,7 @@ fn main() {
// start processing if this is the one
('>', false) => {
match line.as_slice().slice_from(1).find_str("THREE") {
match line[1..].find_str("THREE") {
Some(_) => { proc_mode = true; }
None => { }
}

4
src/test/bench/shootout-k-nucleotide.rs
View File

@ -285,9 +285,9 @@ fn print_occurrences(frequencies: &mut Table, occurrence: &'static str) {
fn get_sequence<R: Buffer>(r: &mut R, key: &str) -> Vec<u8> {
let mut res = Vec::new();
for l in r.lines().map(|l| l.ok().unwrap())
.skip_while(|l| key != l.as_slice().slice_to(key.len())).skip(1)
.skip_while(|l| key != &l[..key.len()]).skip(1)
{
res.push_all(l.as_slice().trim().as_bytes());
res.push_all(l.trim().as_bytes());
}
res.into_ascii_uppercase()
}

2
src/test/bench/shootout-mandelbrot.rs
View File

@ -134,7 +134,7 @@ fn mandelbrot<W: old_io::Writer>(w: uint, mut out: W) -> old_io::IoResult<()> {
(i + 1) * chunk_size
};
for &init_i in vec_init_i.slice(start, end).iter() {
for &init_i in vec_init_i[start..end].iter() {
write_line(init_i, init_r_slice, &mut res);
}

2
src/test/bench/shootout-nbody.rs
View File

@ -174,7 +174,7 @@ fn main() {
let n = if std::os::getenv("RUST_BENCH").is_some() {
5000000
} else {
std::os::args().as_slice().get(1)
std::os::args().get(1)
.and_then(|arg| arg.parse())
.unwrap_or(1000)
};

2
src/test/bench/shootout-pfib.rs
View File

@ -55,7 +55,7 @@ fn parse_opts(argv: Vec<String> ) -> Config {
let opts = vec!(getopts::optflag("", "stress", ""));
let argv = argv.iter().map(|x| x.to_string()).collect::<Vec<_>>();
let opt_args = argv.slice(1, argv.len());
let opt_args = &argv[1..argv.len()];
match getopts::getopts(opt_args, opts.as_slice()) {
Ok(ref m) => {

2
src/test/bench/shootout-reverse-complement.rs
View File

@ -155,7 +155,7 @@ impl<'a> Iterator for MutDnaSeqs<'a> {
fn next(&mut self) -> Option<&'a mut [u8]> {
let tmp = std::mem::replace(&mut self.s, &mut []);
let tmp = match memchr(tmp, b'\n') {
Some(i) => tmp.slice_from_mut(i + 1),
Some(i) => &mut tmp[i + 1..],
None => return None,
};
let (seq, tmp) = match memchr(tmp, b'>') {

2
src/test/compile-fail/drop-with-active-borrows-1.rs
View File

@ -10,7 +10,7 @@
fn main() {
let a = "".to_string();
let b: Vec<&str> = a.as_slice().lines().collect();
let b: Vec<&str> = a.lines().collect();
drop(a); //~ ERROR cannot move out of `a` because it is borrowed
for s in b.iter() {
println!("{}", *s);

2
src/test/compile-fail/drop-with-active-borrows-2.rs
View File

@ -10,7 +10,7 @@
fn read_lines_borrowed<'a>() -> Vec<&'a str> {
let raw_lines: Vec<String> = vec!("foo ".to_string(), " bar".to_string());
raw_lines.iter().map(|l| l.as_slice().trim()).collect()
raw_lines.iter().map(|l| l.trim()).collect()
//~^ ERROR `raw_lines` does not live long enough
}

2
src/test/compile-fail/issue-13497-2.rs
View File

@ -11,7 +11,7 @@
fn read_lines_borrowed<'a>() -> Vec<&'a str> {
let rawLines: Vec<String> = vec!["foo ".to_string(), " bar".to_string()];
rawLines //~ ERROR `rawLines` does not live long enough
.iter().map(|l| l.as_slice().trim()).collect()
.iter().map(|l| l.trim()).collect()
}
fn main() {}

2
src/test/compile-fail/issue-13497.rs
View File

@ -12,7 +12,7 @@ fn read_lines_borrowed1() -> Vec<
&str //~ ERROR missing lifetime specifier
> {
let rawLines: Vec<String> = vec!["foo ".to_string(), " bar".to_string()];
rawLines.iter().map(|l| l.as_slice().trim()).collect()
rawLines.iter().map(|l| l.trim()).collect()
}
fn main() {}

2
src/test/compile-fail/issue-15381.rs
View File

@ -14,7 +14,7 @@ fn main() {
for
[x,y,z]
//~^ ERROR refutable pattern in `for` loop binding: `[]` not covered
in values.as_slice().chunks(3).filter(|&xs| xs.len() == 3) {
in values.chunks(3).filter(|&xs| xs.len() == 3) {
println!("y={}", y);
}
}

2
src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
View File

@ -40,5 +40,5 @@ fn main() {
// positive test so that this test will be updated when the
// compiler changes.
assert!(err.as_slice().contains("unknown start of token"))
assert!(err.contains("unknown start of token"))
}

2
src/test/run-make/unicode-input/multiple_files.rs
View File

@ -65,6 +65,6 @@ fn main() {
// positive test so that this test will be updated when the
// compiler changes.
assert!(err.as_slice().contains("expected item, found"))
assert!(err.contains("expected item, found"))
}
}

2
src/test/run-make/unicode-input/span_length.rs
View File

@ -63,6 +63,6 @@ fn main() {
// the span should end the line (e.g no extra ~'s)
let expected_span = format!("^{}\n", repeat("~").take(n - 1)
.collect::<String>());
assert!(err.as_slice().contains(expected_span.as_slice()));
assert!(err.contains(expected_span.as_slice()));
}
}

4
src/test/run-pass/backtrace.rs
View File

@ -78,9 +78,9 @@ fn runtest(me: &str) {
let s = str::from_utf8(out.error.as_slice()).unwrap();
let mut i = 0;
for _ in range(0i, 2) {
i += s.slice_from(i + 10).find_str("stack backtrace").unwrap() + 10;
i += s[i + 10..].find_str("stack backtrace").unwrap() + 10;
}
assert!(s.slice_from(i + 10).find_str("stack backtrace").is_none(),
assert!(s[i + 10..].find_str("stack backtrace").is_none(),
"bad output4: {}", s);
}

2
src/test/run-pass/borrow-by-val-method-receiver.rs
View File

@ -19,5 +19,5 @@ impl<'a> Foo for &'a [int] {
pub fn main() {
let items = vec!( 3, 5, 1, 2, 4 );
items.as_slice().foo();
items.foo();
}

2
src/test/run-pass/byte-literals.rs
View File

@ -52,7 +52,7 @@ pub fn main() {
}
let buf = vec!(97u8, 98, 99, 100);
assert_eq!(match buf.slice(0, 3) {
assert_eq!(match &buf[0..3] {
b"def" => 1u,
b"abc" => 2u,
_ => 3u

4
src/test/run-pass/capturing-logging.rs
View File

@ -41,6 +41,6 @@ fn main() {
info!("info");
});
let s = r.read_to_string().unwrap();
assert!(s.as_slice().contains("info"));
assert!(!s.as_slice().contains("debug"));
assert!(s.contains("info"));
assert!(!s.contains("debug"));
}

2
src/test/run-pass/drop-with-type-ascription-1.rs
View File

@ -10,7 +10,7 @@
fn main() {
let foo = "hello".to_string();
let foo: Vec<&str> = foo.as_slice().words().collect();
let foo: Vec<&str> = foo.words().collect();
let invalid_string = &foo[0];
assert_eq!(*invalid_string, "hello");
}

2
src/test/run-pass/drop-with-type-ascription-2.rs
View File

@ -10,7 +10,7 @@
fn main() {
let args = vec!("foobie", "asdf::asdf");
let arr: Vec<&str> = args[1].as_slice().split_str("::").collect();
let arr: Vec<&str> = args[1].split_str("::").collect();
assert_eq!(arr[0], "asdf");
assert_eq!(arr[0], "asdf");
}

2
src/test/run-pass/issue-5550.rs
View File

@ -13,5 +13,5 @@
pub fn main() {
let s: String = "foobar".to_string();
let mut t: &str = s.as_slice();
t = t.slice(0, 3); // for master: str::view(t, 0, 3) maybe
t = &t[0..3]; // for master: str::view(t, 0, 3) maybe
}

2
src/test/run-pass/linear-for-loop.rs
View File

@ -18,7 +18,7 @@ pub fn main() {
assert_eq!(y, 6);
let s = "hello there".to_string();
let mut i: int = 0;
for c in s.as_slice().bytes() {
for c in s.bytes() {
if i == 0 { assert!((c == 'h' as u8)); }
if i == 1 { assert!((c == 'e' as u8)); }
if i == 2 { assert!((c == 'l' as u8)); }

2
src/test/run-pass/out-of-stack-new-thread-no-split.rs
View File

@ -44,6 +44,6 @@ fn main() {
let error = String::from_utf8_lossy(recurse.error.as_slice());
println!("wut");
println!("`{}`", error);
assert!(error.as_slice().contains("has overflowed its stack"));
assert!(error.contains("has overflowed its stack"));
}
}

2
src/test/run-pass/out-of-stack-no-split.rs
View File

@ -42,6 +42,6 @@ fn main() {
let recurse = Command::new(args[0].as_slice()).arg("recurse").output().unwrap();
assert!(!recurse.status.success());
let error = String::from_utf8_lossy(recurse.error.as_slice());
assert!(error.as_slice().contains("has overflowed its stack"));
assert!(error.contains("has overflowed its stack"));
}
}

4
src/test/run-pass/out-of-stack.rs
View File

@ -44,11 +44,11 @@ fn main() {
let silent = Command::new(args[0].as_slice()).arg("silent").output().unwrap();
assert!(!silent.status.success());
let error = String::from_utf8_lossy(silent.error.as_slice());
assert!(error.as_slice().contains("has overflowed its stack"));
assert!(error.contains("has overflowed its stack"));
let loud = Command::new(args[0].as_slice()).arg("loud").output().unwrap();
assert!(!loud.status.success());
let error = String::from_utf8_lossy(silent.error.as_slice());
assert!(error.as_slice().contains("has overflowed its stack"));
assert!(error.contains("has overflowed its stack"));
}
}

2
src/test/run-pass/process-remove-from-env.rs
View File

@ -48,6 +48,6 @@ fn main() {
let result = prog.wait_with_output().unwrap();
let output = String::from_utf8_lossy(result.output.as_slice());
assert!(!output.as_slice().contains("RUN_TEST_NEW_ENV"),
assert!(!output.contains("RUN_TEST_NEW_ENV"),
"found RUN_TEST_NEW_ENV inside of:\n\n{}", output);
}

4
src/test/run-pass/rcvr-borrowed-to-slice.rs
View File

@ -29,12 +29,12 @@ pub fn main() {
assert_eq!(y, 6);
let x = vec!(1, 2, 3);
let y = x.as_slice().sum_();
let y = x.sum_();
println!("y=={}", y);
assert_eq!(y, 6);
let x = vec!(1, 2, 3);
let y = x.as_slice().sum_();
let y = x.sum_();
println!("y=={}", y);
assert_eq!(y, 6);
}

2
src/test/run-pass/segfault-no-out-of-stack.rs
View File

@ -20,6 +20,6 @@ fn main() {
let segfault = Command::new(args[0].as_slice()).arg("segfault").output().unwrap();
assert!(!segfault.status.success());
let error = String::from_utf8_lossy(segfault.error.as_slice());
assert!(!error.as_slice().contains("has overflowed its stack"));
assert!(!error.contains("has overflowed its stack"));
}
}

2
src/test/run-pass/syntax-extension-source-utils.rs
View File

@ -40,7 +40,7 @@ pub fn main() {
include_bytes!("syntax-extension-source-utils-files/includeme.fragment")
[1] == (42 as u8)); // '*'
// The Windows tests are wrapped in an extra module for some reason
assert!((m1::m2::where_am_i().as_slice().ends_with("m1::m2")));
assert!((m1::m2::where_am_i().ends_with("m1::m2")));
assert!(match (45, "( 2 * 3 ) + 5") {
(line!(), stringify!((2*3) + 5)) => true,

2
src/test/run-pass/task-stderr.rs
View File

@ -26,5 +26,5 @@ fn main() {
assert!(res.is_err());
let output = reader.read_to_string().unwrap();
assert!(output.as_slice().contains("Hello, world!"));
assert!(output.contains("Hello, world!"));
}

2
src/test/run-pass/utf8.rs
View File

@ -44,7 +44,7 @@ pub fn main() {
fn check_str_eq(a: String, b: String) {
let mut i: int = 0;
for ab in a.as_slice().bytes() {
for ab in a.bytes() {
println!("{}", i);
println!("{}", ab);
let bb: u8 = b.as_bytes()[i as uint];

2
src/test/run-pass/vec-slice.rs
View File

@ -10,7 +10,7 @@
pub fn main() {
let v = vec!(1i,2,3,4,5);
let v2 = v.slice(1, 3);
let v2 = &v[1..3];
assert_eq!(v2[0], 2);
assert_eq!(v2[1], 3);
}

4
src/test/run-pass/vec-tail-matching.rs
View File

@ -31,8 +31,8 @@ pub fn main() {
unreachable!();
}
[Foo { string: ref a }, Foo { string: ref b }] => {
assert_eq!("bar", a.as_slice().slice(0, a.len()));
assert_eq!("baz", b.as_slice().slice(0, b.len()));
assert_eq!("bar", &a[0..a.len()]);
assert_eq!("baz", &b[0..b.len()]);
}
_ => {
unreachable!();