---

yaml
---
r: 232906
b: refs/heads/try
c: 8213f01
h: refs/heads/master
v: v3

Author: jakerr

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: dfe93269418398e141e639c6ebf3b8d1d14c9769
+refs/heads/try: 8213f01a76a6114ff145f5d5cec335671d3b6c7e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/compiletest/compiletest.rs

@@ -178,7 +178,7 @@ pub fn log_config(config: &Config) {
     logv(c, format!("filter: {}",
                     opt_str(&config.filter
                                    .as_ref()
-                                   .map(|re| re.to_owned()))));
+                                   .map(|re| re.to_string()))));
     logv(c, format!("runtool: {}", opt_str(&config.runtool)));
     logv(c, format!("host-rustcflags: {}",
                     opt_str(&config.host_rustcflags)));
@@ -205,16 +205,19 @@ pub fn opt_str<'a>(maybestr: &'a Option<String>) -> &'a str {
 
 pub fn opt_str2(maybestr: Option<String>) -> String {
     match maybestr {
-        None => "(none)".to_owned(),
+        None => "(none)".to_string(),
         Some(s) => s,
     }
 }
 
 pub fn run_tests(config: &Config) {
     if config.target.contains("android") {
-        if let DebugInfoGdb = config.mode {
-            println!("{} debug-info test uses tcp 5039 port.\
-                     please reserve it", config.target);
+        match config.mode {
+            DebugInfoGdb => {
+                println!("{} debug-info test uses tcp 5039 port.\
+                         please reserve it", config.target);
+            }
+            _ =>{}
         }
 
         // android debug-info test uses remote debugger
@@ -286,10 +289,10 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool {
     // Pretty-printer does not work with .rc files yet
     let valid_extensions =
         match config.mode {
-          Pretty => vec!(".rs".to_owned()),
-          _ => vec!(".rc".to_owned(), ".rs".to_owned())
+          Pretty => vec!(".rs".to_string()),
+          _ => vec!(".rc".to_string(), ".rs".to_string())
         };
-    let invalid_prefixes = vec!(".".to_owned(), "#".to_owned(), "~".to_owned());
+    let invalid_prefixes = vec!(".".to_string(), "#".to_string(), "~".to_string());
     let name = testfile.file_name().unwrap().to_str().unwrap();
 
     let mut valid = false;
@@ -361,7 +364,7 @@ fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
                    full_version_line.char_at(pos + 3).is_digit(10) {
                     continue
                 }
-                return Some(full_version_line[pos..pos+3].to_owned());
+                return Some(full_version_line[pos..pos+3].to_string());
             }
             println!("Could not extract GDB version from line '{}'",
                      full_version_line);
@@ -383,8 +386,9 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
     // We are only interested in the major version number, so this function
     // will return `Some("179")` and `Some("300")` respectively.
 
-    if let Some(ref full_version_line) = full_version_line {
-        if !full_version_line.trim().is_empty() {
+    match full_version_line {
+        Some(ref full_version_line)
+          if !full_version_line.trim().is_empty() => {
             let full_version_line = full_version_line.trim();
 
             for (pos, l) in full_version_line.char_indices() {
@@ -406,7 +410,8 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
             }
             println!("Could not extract LLDB version from line '{}'",
                      full_version_line);
-        }
+            None
+        },
+        _ => None
     }
-    None
 }

branches/try/src/compiletest/errors.rs

@@ -76,7 +76,7 @@ fn parse_expected(last_nonfollow_error: Option<usize>,
     let letters = line[kind_start..].chars();
     let msg = letters.skip_while(|c| c.is_whitespace())
                      .skip_while(|c| !c.is_whitespace())
-                     .collect::<String>().trim().to_owned();
+                     .collect::<String>().trim().to_string();
 
     let (which, line) = if follow {
         assert!(adjusts == 0, "use either //~| or //~^, not both.");

branches/try/src/compiletest/header.rs

@@ -67,9 +67,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pretty_compare_only = false;
     let mut forbid_output = Vec::new();
     iter_header(testfile, &mut |ln| {
-        if let Some(ep) = parse_error_pattern(ln) {
-           error_patterns.push(ep);
-        }
+        match parse_error_pattern(ln) {
+          Some(ep) => error_patterns.push(ep),
+          None => ()
+        };
 
         if compile_flags.is_none() {
             compile_flags = parse_compile_flags(ln);
@@ -107,20 +108,24 @@ pub fn load_props(testfile: &Path) -> TestProps {
             pretty_compare_only = parse_pretty_compare_only(ln);
         }
 
-        if let  Some(ab) = parse_aux_build(ln) {
-            aux_builds.push(ab);
+        match parse_aux_build(ln) {
+            Some(ab) => { aux_builds.push(ab); }
+            None => {}
         }
 
-        if let Some(ee) = parse_exec_env(ln) {
-            exec_env.push(ee);
+        match parse_exec_env(ln) {
+            Some(ee) => { exec_env.push(ee); }
+            None => {}
         }
 
-        if let Some(cl) =  parse_check_line(ln) {
-            check_lines.push(cl);
-        }
+        match parse_check_line(ln) {
+            Some(cl) => check_lines.push(cl),
+            None => ()
+        };
 
-        if let Some(of) = parse_forbid_output(ln) {
-            forbid_output.push(of);
+        match parse_forbid_output(ln) {
+            Some(of) => forbid_output.push(of),
+            None => (),
         }
 
         true
@@ -129,8 +134,8 @@ pub fn load_props(testfile: &Path) -> TestProps {
     for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
         match env::var(key) {
             Ok(val) =>
-                if exec_env.iter().find(|&&(ref x, _)| *x == key).is_none() {
-                    exec_env.push((key.to_owned(), val))
+                if exec_env.iter().find(|&&(ref x, _)| *x == key.to_string()).is_none() {
+                    exec_env.push((key.to_string(), val))
                 },
             Err(..) => {}
         }
@@ -148,7 +153,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         check_stdout: check_stdout,
         no_prefer_dynamic: no_prefer_dynamic,
         pretty_expanded: pretty_expanded,
-        pretty_mode: pretty_mode.unwrap_or("normal".to_owned()),
+        pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
         pretty_compare_only: pretty_compare_only,
         forbid_output: forbid_output,
     }
@@ -177,21 +182,22 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
             return true;
         }
 
-        if let Some(ref actual_version) = config.gdb_version {
-            if line.contains("min-gdb-version") {
-                let min_version = line.trim()
-                                      .split(' ')
-                                      .last()
-                                      .expect("Malformed GDB version directive");
-                // Ignore if actual version is smaller the minimum required
-                // version
-                gdb_version_to_int(actual_version) <
-                    gdb_version_to_int(min_version)
-            } else {
-                false
+        match config.gdb_version {
+            Some(ref actual_version) => {
+                if line.contains("min-gdb-version") {
+                    let min_version = line.trim()
+                                          .split(' ')
+                                          .last()
+                                          .expect("Malformed GDB version directive");
+                    // Ignore if actual version is smaller the minimum required
+                    // version
+                    gdb_version_to_int(actual_version) <
+                        gdb_version_to_int(min_version)
+                } else {
+                    false
+                }
             }
-        } else {
-            false
+            None => false
         }
     }
 
@@ -204,21 +210,22 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
             return true;
         }
 
-        if let Some(ref actual_version) = config.lldb_version {
-            if line.contains("min-lldb-version") {
-                let min_version = line.trim()
-                                      .split(' ')
-                                      .last()
-                                      .expect("Malformed lldb version directive");
-                // Ignore if actual version is smaller the minimum required
-                // version
-                lldb_version_to_int(actual_version) <
-                    lldb_version_to_int(min_version)
-            } else {
-                false
+        match config.lldb_version {
+            Some(ref actual_version) => {
+                if line.contains("min-lldb-version") {
+                    let min_version = line.trim()
+                                          .split(' ')
+                                          .last()
+                                          .expect("Malformed lldb version directive");
+                    // Ignore if actual version is smaller the minimum required
+                    // version
+                    lldb_version_to_int(actual_version) <
+                        lldb_version_to_int(min_version)
+                } else {
+                    false
+                }
             }
-        } else {
-            false
+            None => false
         }
     }
 
@@ -309,11 +316,11 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
         // nv is either FOO or FOO=BAR
         let mut strs: Vec<String> = nv
                                       .splitn(2, '=')
-                                      .map(str::to_owned)
+                                      .map(|s| s.to_string())
                                       .collect();
 
         match strs.len() {
-          1 => (strs.pop().unwrap(), "".to_owned()),
+          1 => (strs.pop().unwrap(), "".to_string()),
           2 => {
               let end = strs.pop().unwrap();
               (strs.pop().unwrap(), end)
@@ -324,31 +331,33 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
 }
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<PathBuf> {
-    if let Some(s) = parse_name_value_directive(line, "pp-exact") {
-        Some(PathBuf::from(&s))
-    } else {
+    match parse_name_value_directive(line, "pp-exact") {
+      Some(s) => Some(PathBuf::from(&s)),
+      None => {
         if parse_name_directive(line, "pp-exact") {
-            testfile.file_name().map(PathBuf::from)
+            testfile.file_name().map(|s| PathBuf::from(s))
         } else {
             None
         }
+      }
     }
 }
 
 fn parse_name_directive(line: &str, directive: &str) -> bool {
     // This 'no-' rule is a quick hack to allow pretty-expanded and no-pretty-expanded to coexist
-    line.contains(directive) && !line.contains(&("no-".to_owned() + directive))
+    line.contains(directive) && !line.contains(&("no-".to_string() + directive))
 }
 
 pub fn parse_name_value_directive(line: &str, directive: &str)
                                   -> Option<String> {
     let keycolon = format!("{}:", directive);
-    if let Some(colon) = line.find(&keycolon) {
-        let value = line[(colon + keycolon.len()) .. line.len()].to_owned();
-        debug!("{}: {}", directive, value);
-        Some(value)
-    } else {
-        None
+    match line.find(&keycolon) {
+        Some(colon) => {
+            let value = line[(colon + keycolon.len()) .. line.len()].to_string();
+            debug!("{}: {}", directive, value);
+            Some(value)
+        }
+        None => None
     }
 }
 

branches/try/src/compiletest/procsrv.rs

@@ -17,8 +17,9 @@ fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
     // Need to be sure to put both the lib_path and the aux path in the dylib
     // search path for the child.
     let mut path = DynamicLibrary::search_path();
-    if let Some(p) = aux_path {
-        path.insert(0, PathBuf::from(p))
+    match aux_path {
+        Some(p) => path.insert(0, PathBuf::from(p)),
+        None => {}
     }
     path.insert(0, PathBuf::from(lib_path));