libstd: Change Path::new to Path::init.

Author: pcwalton

src/compiletest/compiletest.rs

@@ -103,15 +103,15 @@ pub fn parse_config(args: ~[~str]) -> config {
     }
 
     fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
-        Path::new(m.opt_str(nm).unwrap())
+        Path::init(m.opt_str(nm).unwrap())
     }
 
     config {
         compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
         run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
-        clang_path: matches.opt_str("clang-path").map(|s| Path::new(s)),
-        llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::new(s)),
+        clang_path: matches.opt_str("clang-path").map(|s| Path::init(s)),
+        llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::init(s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
@@ -124,10 +124,10 @@ pub fn parse_config(args: ~[~str]) -> config {
             } else {
                 None
             },
-        logfile: matches.opt_str("logfile").map(|s| Path::new(s)),
-        save_metrics: matches.opt_str("save-metrics").map(|s| Path::new(s)),
+        logfile: matches.opt_str("logfile").map(|s| Path::init(s)),
+        save_metrics: matches.opt_str("save-metrics").map(|s| Path::init(s)),
         ratchet_metrics:
-            matches.opt_str("ratchet-metrics").map(|s| Path::new(s)),
+            matches.opt_str("ratchet-metrics").map(|s| Path::init(s)),
         ratchet_noise_percent:
             matches.opt_str("ratchet-noise-percent").and_then(|s| from_str::<f64>(s)),
         runtool: matches.opt_str("runtool"),

src/compiletest/header.rs

@@ -160,10 +160,10 @@ fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
     match parse_name_value_directive(line, ~"pp-exact") {
-      Some(s) => Some(Path::new(s)),
+      Some(s) => Some(Path::init(s)),
       None => {
         if parse_name_directive(line, "pp-exact") {
-            testfile.filename().map(|s| Path::new(s))
+            testfile.filename().map(|s| Path::init(s))
         } else {
             None
         }

src/compiletest/runtest.rs

@@ -45,7 +45,7 @@ pub fn run_metrics(config: config, testfile: ~str, mm: &mut MetricMap) {
         // We're going to be dumping a lot of info. Start on a new line.
         print!("\n\n");
     }
-    let testfile = Path::new(testfile);
+    let testfile = Path::init(testfile);
     debug!("running {}", testfile.display());
     let props = load_props(&testfile);
     debug!("loaded props");
@@ -852,7 +852,7 @@ fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
 }
 
 fn output_testname(testfile: &Path) -> Path {
-    Path::new(testfile.filestem().unwrap())
+    Path::init(testfile.filestem().unwrap())
 }
 
 fn output_base_name(config: &config, testfile: &Path) -> Path {

src/libextra/glob.rs

@@ -90,7 +90,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> GlobIterator {
 
     // calculate root this way to handle volume-relative Windows paths correctly
     let mut root = os::getcwd();
-    let pat_root = Path::new(pattern).root_path();
+    let pat_root = Path::init(pattern).root_path();
     if pat_root.is_some() {
         if check_windows_verbatim(pat_root.get_ref()) {
             // XXX: How do we want to handle verbatim paths? I'm inclined to return nothing,
@@ -766,9 +766,9 @@ mod test {
 
     #[test]
     fn test_matches_path() {
-        // on windows, (Path::new("a/b").as_str().unwrap() == "a\\b"), so this
+        // on windows, (Path::init("a/b").as_str().unwrap() == "a\\b"), so this
         // tests that / and \ are considered equivalent on windows
-        assert!(Pattern::new("a/b").matches_path(&Path::new("a/b")));
+        assert!(Pattern::new("a/b").matches_path(&Path::init("a/b")));
     }
 }
 

src/libextra/terminfo/searcher.rs

@@ -29,7 +29,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option<~Path> {
 
     // Find search directory
     match getenv("TERMINFO") {
-        Some(dir) => dirs_to_search.push(Path::new(dir)),
+        Some(dir) => dirs_to_search.push(Path::init(dir)),
         None => {
             if homedir.is_some() {
                 // ncurses compatability;
@@ -38,17 +38,17 @@ pub fn get_dbpath_for_term(term: &str) -> Option<~Path> {
             match getenv("TERMINFO_DIRS") {
                 Some(dirs) => for i in dirs.split(':') {
                     if i == "" {
-                        dirs_to_search.push(Path::new("/usr/share/terminfo"));
+                        dirs_to_search.push(Path::init("/usr/share/terminfo"));
                     } else {
-                        dirs_to_search.push(Path::new(i.to_owned()));
+                        dirs_to_search.push(Path::init(i.to_owned()));
                     }
                 },
                 // Found nothing, use the default paths
                 // /usr/share/terminfo is the de facto location, but it seems
                 // Ubuntu puts it in /lib/terminfo
                 None => {
-                    dirs_to_search.push(Path::new("/usr/share/terminfo"));
-                    dirs_to_search.push(Path::new("/lib/terminfo"));
+                    dirs_to_search.push(Path::init("/usr/share/terminfo"));
+                    dirs_to_search.push(Path::init("/lib/terminfo"));
                 }
             }
         }

src/libextra/test.rs

@@ -276,20 +276,20 @@ pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
     let run_ignored = matches.opt_present("ignored");
 
     let logfile = matches.opt_str("logfile");
-    let logfile = logfile.map(|s| Path::new(s));
+    let logfile = logfile.map(|s| Path::init(s));
 
     let run_benchmarks = matches.opt_present("bench");
     let run_tests = ! run_benchmarks ||
         matches.opt_present("test");
 
     let ratchet_metrics = matches.opt_str("ratchet-metrics");
-    let ratchet_metrics = ratchet_metrics.map(|s| Path::new(s));
+    let ratchet_metrics = ratchet_metrics.map(|s| Path::init(s));
 
     let ratchet_noise_percent = matches.opt_str("ratchet-noise-percent");
     let ratchet_noise_percent = ratchet_noise_percent.map(|s| from_str::<f64>(s).unwrap());
 
     let save_metrics = matches.opt_str("save-metrics");
-    let save_metrics = save_metrics.map(|s| Path::new(s));
+    let save_metrics = save_metrics.map(|s| Path::init(s));
 
     let test_shard = matches.opt_str("test-shard");
     let test_shard = opt_shard(test_shard);

src/librustc/back/rpath.rs

@@ -148,7 +148,7 @@ pub fn get_install_prefix_rpath(target_triple: &str) -> ~str {
     let install_prefix = env!("CFG_PREFIX");
 
     let tlib = filesearch::relative_target_lib_path(target_triple);
-    let mut path = Path::new(install_prefix);
+    let mut path = Path::init(install_prefix);
     path.push(&tlib);
     let path = os::make_absolute(&path);
     // FIXME (#9639): This needs to handle non-utf8 paths
@@ -183,7 +183,7 @@ mod test {
     #[test]
     fn test_prefix_rpath() {
         let res = get_install_prefix_rpath("triple");
-        let mut d = Path::new(env!("CFG_PREFIX"));
+        let mut d = Path::init(env!("CFG_PREFIX"));
         d.push("lib/rustc/triple/lib");
         debug!("test_prefix_path: {} vs. {}",
                res,
@@ -194,7 +194,7 @@ mod test {
     #[test]
     fn test_prefix_rpath_abs() {
         let res = get_install_prefix_rpath("triple");
-        assert!(Path::new(res).is_absolute());
+        assert!(Path::init(res).is_absolute());
     }
 
     #[test]
@@ -218,7 +218,7 @@ mod test {
     fn test_rpath_relative() {
       let o = abi::OsLinux;
       let res = get_rpath_relative_to_output(o,
-            &Path::new("bin/rustc"), &Path::new("lib/libstd.so"));
+            &Path::init("bin/rustc"), &Path::init("lib/libstd.so"));
       assert_eq!(res.as_slice(), "$ORIGIN/../lib");
     }
 
@@ -227,7 +227,7 @@ mod test {
     fn test_rpath_relative() {
         let o = abi::OsFreebsd;
         let res = get_rpath_relative_to_output(o,
-            &Path::new("bin/rustc"), &Path::new("lib/libstd.so"));
+            &Path::init("bin/rustc"), &Path::init("lib/libstd.so"));
         assert_eq!(res.as_slice(), "$ORIGIN/../lib");
     }
 
@@ -236,15 +236,15 @@ mod test {
     fn test_rpath_relative() {
         let o = abi::OsMacos;
         let res = get_rpath_relative_to_output(o,
-                                               &Path::new("bin/rustc"),
-                                               &Path::new("lib/libstd.so"));
+                                               &Path::init("bin/rustc"),
+                                               &Path::init("lib/libstd.so"));
         assert_eq!(res.as_slice(), "@loader_path/../lib");
     }
 
     #[test]
     fn test_get_absolute_rpath() {
-        let res = get_absolute_rpath(&Path::new("lib/libstd.so"));
-        let lib = os::make_absolute(&Path::new("lib"));
+        let res = get_absolute_rpath(&Path::init("lib/libstd.so"));
+        let lib = os::make_absolute(&Path::init("lib"));
         debug!("test_get_absolute_rpath: {} vs. {}",
                res.to_str(), lib.display());
 

src/librustc/driver/driver.rs

@@ -719,7 +719,7 @@ pub fn build_session_options(binary: @str,
         } else if matches.opt_present("emit-llvm") {
             link::output_type_bitcode
         } else { link::output_type_exe };
-    let sysroot_opt = matches.opt_str("sysroot").map(|m| @Path::new(m));
+    let sysroot_opt = matches.opt_str("sysroot").map(|m| @Path::init(m));
     let target = matches.opt_str("target").unwrap_or(host_triple());
     let target_cpu = matches.opt_str("target-cpu").unwrap_or(~"generic");
     let target_feature = matches.opt_str("target-feature").unwrap_or(~"");
@@ -753,7 +753,7 @@ pub fn build_session_options(binary: @str,
     let statik = debugging_opts & session::statik != 0;
 
     let addl_lib_search_paths = matches.opt_strs("L").map(|s| {
-      Path::new(s.as_slice())
+      Path::init(s.as_slice())
     }).move_iter().collect();
     let linker = matches.opt_str("linker");
     let linker_args = matches.opt_strs("link-args").flat_map( |a| {

src/librustc/lib.rs

@@ -248,16 +248,16 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
             let src = str::from_utf8(io::stdin().read_to_end());
             str_input(src.to_managed())
         } else {
-            file_input(Path::new(ifile))
+            file_input(Path::init(ifile))
         }
       }
       _ => early_error(demitter, "multiple input filenames provided")
     };
 
     let sopts = build_session_options(binary, matches, demitter);
     let sess = build_session(sopts, demitter);
-    let odir = matches.opt_str("out-dir").map(|o| Path::new(o));
-    let ofile = matches.opt_str("o").map(|o| Path::new(o));
+    let odir = matches.opt_str("out-dir").map(|o| Path::init(o));
+    let ofile = matches.opt_str("o").map(|o| Path::init(o));
     let cfg = build_configuration(sess);
     let pretty = matches.opt_default("pretty", "normal").map(|a| {
         parse_pretty(sess, a)

src/librustc/metadata/creader.rs

@@ -143,7 +143,7 @@ fn visit_view_item(e: @mut Env, i: &ast::view_item) {
           let meta_items = match path_opt {
               None => meta_items.clone(),
               Some((p, _path_str_style)) => {
-                  let p_path = Path::new(p);
+                  let p_path = Path::init(p);
                   match p_path.filestem_str() {
                       None|Some("") =>
                           e.diag.span_bug(i.span, "Bad package path in `extern mod` item"),
@@ -275,7 +275,7 @@ fn resolve_crate(e: @mut Env,
         };
         let (lident, ldata) = loader::load_library_crate(&load_ctxt);
 
-        let cfilename = Path::new(lident);
+        let cfilename = Path::init(lident);
         let cdata = ldata;
 
         let attrs = decoder::get_crate_attributes(cdata);