Some clippy fixes (rust-lang#1389)

Author: giltho

tools/compiletest/src/main.rs

@@ -177,7 +177,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
                 let mut root_folder = top_level().expect(
                     format!("Cannot find root directory. Please provide --{} option.", nm).as_str(),
                 );
-                default.into_iter().for_each(|f| root_folder.push(f));
+                default.iter().for_each(|f| root_folder.push(f));
                 root_folder
             }
         }
@@ -272,8 +272,7 @@ pub fn run_tests(config: Config) {
 
     let opts = test_opts(&config);
 
-    let mut configs = Vec::new();
-    configs.push(config.clone());
+    let configs = vec![config.clone()];
 
     let mut tests = Vec::new();
     for c in &configs {

tools/compiletest/src/runtest.rs

@@ -176,10 +176,8 @@ impl<'test> TestCx<'test> {
             if proc_res.status.success() {
                 self.fatal_proc_rec("test failed: expected check failure, got success", &proc_res);
             }
-        } else {
-            if !proc_res.status.success() {
-                self.fatal_proc_rec("test failed: expected check success, got failure", &proc_res);
-            }
+        } else if !proc_res.status.success() {
+            self.fatal_proc_rec("test failed: expected check success, got failure", &proc_res);
         }
     }
 
@@ -202,13 +200,8 @@ impl<'test> TestCx<'test> {
                     &proc_res,
                 );
             }
-        } else {
-            if !proc_res.status.success() {
-                self.fatal_proc_rec(
-                    "test failed: expected codegen success, got failure",
-                    &proc_res,
-                );
-            }
+        } else if !proc_res.status.success() {
+            self.fatal_proc_rec("test failed: expected codegen success, got failure", &proc_res);
         }
     }
 
@@ -247,13 +240,11 @@ impl<'test> TestCx<'test> {
                         &proc_res,
                     );
                 }
-            } else {
-                if !proc_res.status.success() {
-                    self.fatal_proc_rec(
-                        "test failed: expected verification success, got failure",
-                        &proc_res,
-                    );
-                }
+            } else if !proc_res.status.success() {
+                self.fatal_proc_rec(
+                    "test failed: expected verification success, got failure",
+                    &proc_res,
+                );
             }
         }
     }
@@ -278,12 +269,10 @@ impl<'test> TestCx<'test> {
     /// If the test file contains expected failures in some locations, ensure
     /// that verification does not succeed in those locations.
     fn verify_expect_fail(str: &str) -> Vec<usize> {
-        let re = Regex::new(r"line [0-9]+ EXPECTED FAIL: SUCCESS").unwrap();
+        let re = Regex::new(r"line ([0-9]+) EXPECTED FAIL: SUCCESS").unwrap();
         let mut lines = vec![];
-        for m in re.find_iter(str) {
-            let splits = m.as_str().split_ascii_whitespace();
-            let num_str = splits.skip(1).next().unwrap();
-            let num = num_str.parse().unwrap();
+        for m in re.captures_iter(str) {
+            let num = m.get(1).unwrap().as_str().parse().unwrap();
             lines.push(num);
         }
         lines
@@ -365,35 +354,36 @@ impl<'test> TestCx<'test> {
     fn verify_output(&self, proc_res: &ProcRes, expected: &str) {
         // Include the output from stderr here for cases where there are exceptions
         let output = proc_res.stdout.to_string() + &proc_res.stderr;
-        if let Some(lines) =
-            TestCx::contains_lines(&output.split('\n').collect(), expected.split('\n').collect())
-        {
+        if let Some(lines) = TestCx::contains_lines(
+            &output.split('\n').collect::<Vec<_>>(),
+            expected.split('\n').collect(),
+        ) {
             self.fatal_proc_rec(
                 &format!(
                     "test failed: expected output to contain the line(s):\n{}",
                     lines.join("\n")
                 ),
-                &proc_res,
+                proc_res,
             );
         }
     }
 
     /// Looks for each line or set of lines in `str`. Returns `None` if all
     /// lines are in `str`.  Otherwise, it returns the first line not found in
     /// `str`.
-    fn contains_lines<'a>(str: &Vec<&str>, lines: Vec<&'a str>) -> Option<Vec<&'a str>> {
+    fn contains_lines<'a>(str: &[&str], lines: Vec<&'a str>) -> Option<Vec<&'a str>> {
         let mut consecutive_lines: Vec<&str> = Vec::new();
         for line in lines {
             // A line that ends in "\" indicates that the next line in the
             // expected file should appear on the consecutive line in the
             // output. This is a temporary mechanism until we have more robust
             // json-based checking of verification results
-            if let Some(prefix) = line.strip_suffix("\\") {
+            if let Some(prefix) = line.strip_suffix('\\') {
                 // accumulate the lines
                 consecutive_lines.push(prefix);
             } else {
                 consecutive_lines.push(line);
-                if !TestCx::contains(&str, &consecutive_lines) {
+                if !TestCx::contains(str, &consecutive_lines) {
                     return Some(consecutive_lines);
                 }
                 consecutive_lines.clear();
@@ -404,7 +394,7 @@ impl<'test> TestCx<'test> {
 
     /// Check if there is a set of consecutive lines in `str` where each line
     /// contains a line from `lines`
-    fn contains(str: &Vec<&str>, lines: &Vec<&str>) -> bool {
+    fn contains(str: &[&str], lines: &[&str]) -> bool {
         let mut i = str.iter();
         while let Some(output_line) = i.next() {
             if output_line.contains(&lines[0]) {
@@ -413,9 +403,9 @@ impl<'test> TestCx<'test> {
                 let mut matches = true;
                 // Clone the iterator so that we keep i unchanged
                 let mut j = i.clone();
-                for i in 1..lines.len() {
+                for line in lines.iter().skip(1) {
                     if let Some(output_line) = j.next() {
-                        if output_line.contains(lines[i]) {
+                        if output_line.contains(line) {
                             continue;
                         }
                     }
@@ -431,7 +421,7 @@ impl<'test> TestCx<'test> {
     }
 
     fn create_stamp(&self) {
-        let stamp = crate::stamp(&self.config, self.testpaths, self.revision);
+        let stamp = crate::stamp(self.config, self.testpaths, self.revision);
         fs::write(&stamp, "we only support one configuration").unwrap();
     }
 }