auto merge of #9655 : kballard/rust/path-rewrite, r=alexcrichton

Rewrite the entire `std::path` module from scratch.

`PosixPath` is now based on `~[u8]`, which fixes #7225.
Unnecessary allocation has been eliminated.

There are a lot of clients of `Path` that still assume utf-8 paths.
This is covered in #9639.

3 files changed, 27 insertions, 29 deletions

diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index e76ade0dc3d..1c13beb790d 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -81,7 +81,7 @@ pub fn expand_include(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
     let file = get_single_str_from_tts(cx, sp, tts, "include!");
     let p = parse::new_sub_parser_from_file(
         cx.parse_sess(), cx.cfg(),
-        &res_rel_file(cx, sp, &Path(file)), sp);
+        &res_rel_file(cx, sp, &Path::new(file)), sp);
     base::MRExpr(p.parse_expr())
 }
 
@@ -89,7 +89,7 @@ pub fn expand_include(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
 pub fn expand_include_str(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include_str!");
-    let res = io::read_whole_file_str(&res_rel_file(cx, sp, &Path(file)));
+    let res = io::read_whole_file_str(&res_rel_file(cx, sp, &Path::new(file)));
     match res {
       result::Ok(res) => {
           base::MRExpr(cx.expr_str(sp, res.to_managed()))
@@ -103,7 +103,7 @@ pub fn expand_include_str(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
 pub fn expand_include_bin(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include_bin!");
-    match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) {
+    match io::read_whole_file(&res_rel_file(cx, sp, &Path::new(file))) {
       result::Ok(src) => {
         let u8_exprs: ~[@ast::Expr] = src.iter().map(|char| cx.expr_u8(sp, *char)).collect();
         base::MRExpr(cx.expr_vec(sp, u8_exprs))
@@ -144,10 +144,12 @@ fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo {
 // isn't already)
 fn res_rel_file(cx: @ExtCtxt, sp: codemap::Span, arg: &Path) -> Path {
     // NB: relative paths are resolved relative to the compilation unit
-    if !arg.is_absolute {
-        let cu = Path(cx.codemap().span_to_filename(sp));
-        cu.dir_path().push_many(arg.components)
+    if !arg.is_absolute() {
+        let mut cu = Path::new(cx.codemap().span_to_filename(sp));
+        cu.pop();
+        cu.push(arg);
+        cu
     } else {
-        (*arg).clone()
+        arg.clone()
     }
 }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 67bcab31956..05998d80213 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -261,7 +261,8 @@ pub fn new_parser_from_tts(sess: @mut ParseSess,
 pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<Span>)
     -> @FileMap {
     match io::read_whole_file_str(path) {
-        Ok(src) => string_to_filemap(sess, src.to_managed(), path.to_str().to_managed()),
+        // FIXME (#9639): This needs to handle non-utf8 paths
+        Ok(src) => string_to_filemap(sess, src.to_managed(), path.as_str().unwrap().to_managed()),
         Err(e) => {
             match spanopt {
                 Some(span) => sess.span_diagnostic.span_fatal(span, e),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index e7c579d2f19..c776e5bfd38 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3992,27 +3992,20 @@ impl Parser {
                     outer_attrs: &[ast::Attribute],
                     id_sp: Span)
                     -> (ast::item_, ~[ast::Attribute]) {
-        let prefix = Path(self.sess.cm.span_to_filename(*self.span));
-        let prefix = prefix.dir_path();
+        let mut prefix = Path::new(self.sess.cm.span_to_filename(*self.span));
+        prefix.pop();
         let mod_path_stack = &*self.mod_path_stack;
-        let mod_path = Path(".").push_many(*mod_path_stack);
-        let dir_path = prefix.push_many(mod_path.components);
+        let mod_path = Path::new(".").join_many(*mod_path_stack);
+        let dir_path = prefix.join(&mod_path);
         let file_path = match ::attr::first_attr_value_str_by_name(
                 outer_attrs, "path") {
-            Some(d) => {
-                let path = Path(d);
-                if !path.is_absolute {
-                    dir_path.push(d)
-                } else {
-                    path
-                }
-            }
+            Some(d) => dir_path.join(d),
             None => {
                 let mod_name = token::interner_get(id.name).to_owned();
                 let default_path_str = mod_name + ".rs";
                 let secondary_path_str = mod_name + "/mod.rs";
-                let default_path = dir_path.push(default_path_str);
-                let secondary_path = dir_path.push(secondary_path_str);
+                let default_path = dir_path.join(default_path_str.as_slice());
+                let secondary_path = dir_path.join(secondary_path_str.as_slice());
                 let default_exists = default_path.exists();
                 let secondary_exists = secondary_path.exists();
                 match (default_exists, secondary_exists) {
@@ -4039,28 +4032,30 @@ impl Parser {
                               path: Path,
                               outer_attrs: ~[ast::Attribute],
                               id_sp: Span) -> (ast::item_, ~[ast::Attribute]) {
-        let full_path = path.normalize();
-
-        let maybe_i = do self.sess.included_mod_stack.iter().position |p| { *p == full_path };
+        let maybe_i = do self.sess.included_mod_stack.iter().position |p| { *p == path };
         match maybe_i {
             Some(i) => {
                 let stack = &self.sess.included_mod_stack;
                 let mut err = ~"circular modules: ";
                 for p in stack.slice(i, stack.len()).iter() {
-                    err.push_str(p.to_str());
+                    do p.display().with_str |s| {
+                        err.push_str(s);
+                    }
                     err.push_str(" -> ");
                 }
-                err.push_str(full_path.to_str());
+                do path.display().with_str |s| {
+                    err.push_str(s);
+                }
                 self.span_fatal(id_sp, err);
             }
             None => ()
         }
-        self.sess.included_mod_stack.push(full_path.clone());
+        self.sess.included_mod_stack.push(path.clone());
 
         let p0 =
             new_sub_parser_from_file(self.sess,
                                      self.cfg.clone(),
-                                     &full_path,
+                                     &path,
                                      id_sp);
         let (inner, next) = p0.parse_inner_attrs_and_next();
         let mod_attrs = vec::append(outer_attrs, inner);