auto merge of #8978 : pnkfelix/rust/make-path-api-less-allocation-happy, r=huonw

bors · bors · commit 8827b94e5b02 · 2013-09-04T18:10:45.000-07:00
A [dialogue](#8909 (diff)) on PR #8909 inspired me to make this change. r? anyone (It is possible that `std::path` itself will soon be replaced with a new implementation that kballard's working on, as mentioned in the dialogue linked above, but this revision is simple enough that I figured I'd offer it up.)
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
@@ -307,8 +307,9 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
     // Try to elide redundant long paths
     fn shorten(path: &Path) -> ~str {
         let filename = path.filename();
-        let dir = path.pop().filename();
-        fmt!("%s/%s", dir.unwrap_or_default(~""), filename.unwrap_or_default(~""))
+        let p = path.pop();
+        let dir = p.filename();
+        fmt!("%s/%s", dir.unwrap_or_default(""), filename.unwrap_or_default(""))
     }
 
     test::DynTestName(fmt!("[%s] %s",
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
@@ -880,7 +880,7 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
     let dirs = os::list_dir_path(&Path(tstr));
     for file in dirs.iter() {
 
-        if (file.filetype() == Some(~".so")) {
+        if (file.filetype() == Some(".so")) {
 
             let copy_result = procsrv::run("", config.adb_path,
                 [~"push", file.to_str(), config.adb_test_dir.clone()],
diff --git a/src/librust/rust.rs b/src/librust/rust.rs
@@ -162,7 +162,8 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
 fn cmd_test(args: &[~str]) -> ValidUsage {
     match args {
         [ref filename] => {
-            let test_exec = Path(*filename).filestem().unwrap() + "test~";
+            let p = Path(*filename);
+            let test_exec = p.filestem().unwrap() + "test~";
             invoke("rustc", &[~"--test", filename.to_owned(),
                               ~"-o", test_exec.to_owned()], rustc::main_args);
             let exit_code = run::process_status(~"./" + test_exec, []);
@@ -175,7 +176,8 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
 fn cmd_run(args: &[~str]) -> ValidUsage {
     match args {
         [ref filename, ..prog_args] => {
-            let exec = Path(*filename).filestem().unwrap() + "~";
+            let p = Path(*filename);
+            let exec = p.filestem().unwrap() + "~";
             invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
                    rustc::main_args);
             let exit_code = run::process_status(~"./"+exec, prog_args);
diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
@@ -952,13 +952,13 @@ pub fn link_args(sess: Session,
     let cstore = sess.cstore;
     let r = cstore::get_used_crate_files(cstore);
     for cratepath in r.iter() {
-        if cratepath.filetype() == Some(~".rlib") {
+        if cratepath.filetype() == Some(".rlib") {
             args.push(cratepath.to_str());
             loop;
         }
         let dir = cratepath.dirname();
         if dir != ~"" { args.push(~"-L" + dir); }
-        let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap());
+        let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap().to_owned());
         args.push(~"-l" + libarg);
     }
 
diff --git a/src/librustpkg/installed_packages.rs b/src/librustpkg/installed_packages.rs
@@ -19,7 +19,8 @@ pub fn list_installed_packages(f: &fn(&PkgId) -> bool) -> bool  {
     for p in workspaces.iter() {
         let binfiles = os::list_dir(&p.push("bin"));
         for exec in binfiles.iter() {
-            let exec_path = Path(*exec).filestem();
+            let p = Path(*exec);
+            let exec_path = p.filestem();
             do exec_path.iter().advance |s| {
                 f(&PkgId::new(*s))
             };
@@ -49,8 +50,8 @@ pub fn has_library(p: &Path) -> Option<~str> {
     let files = os::list_dir(p);
     for q in files.iter() {
         let as_path = Path(*q);
-        if as_path.filetype() == Some(os::consts::DLL_SUFFIX.to_owned()) {
-            let stuff : ~str = as_path.filestem().expect("has_library: weird path");
+        if as_path.filetype() == Some(os::consts::DLL_SUFFIX) {
+            let stuff : &str = as_path.filestem().expect("has_library: weird path");
             let mut stuff2 = stuff.split_str_iter(&"-");
             let stuff3: ~[&str] = stuff2.collect();
             // argh
diff --git a/src/librustpkg/package_id.rs b/src/librustpkg/package_id.rs
@@ -68,7 +68,7 @@ impl PkgId {
         if path.components.len() < 1 {
             return cond.raise((path, ~"0-length pkgid"));
         }
-        let short_name = path.clone().filestem().expect(fmt!("Strange path! %s", s));
+        let short_name = path.filestem().expect(fmt!("Strange path! %s", s));
 
         let version = match given_version {
             Some(v) => v,
@@ -83,8 +83,8 @@ impl PkgId {
 
         debug!("path = %s", path.to_str());
         PkgId {
-            path: path,
-            short_name: short_name,
+            path: path.clone(),
+            short_name: short_name.to_owned(),
             version: version
         }
     }
diff --git a/src/librustpkg/package_source.rs b/src/librustpkg/package_source.rs
@@ -119,7 +119,7 @@ impl PkgSrc {
             return Some(local);
         }
 
-        if (self.id.path.clone()).components().len() < 2 {
+        if self.id.path.components().len() < 2 {
             // If a non-URL, don't bother trying to fetch
             return None;
         }
@@ -157,7 +157,7 @@ impl PkgSrc {
 
     /// True if the given path's stem is self's pkg ID's stem
     fn stem_matches(&self, p: &Path) -> bool {
-        p.filestem().map_default(false, |p| { p == &self.id.short_name })
+        p.filestem().map_default(false, |p| { p == &self.id.short_name.as_slice() })
     }
 
     fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
@@ -182,10 +182,10 @@ impl PkgSrc {
         do os::walk_dir(&dir) |pth| {
             let maybe_known_crate_set = match pth.filename() {
                 Some(filename) => match filename {
-                    ~"lib.rs" => Some(&mut self.libs),
-                    ~"main.rs" => Some(&mut self.mains),
-                    ~"test.rs" => Some(&mut self.tests),
-                    ~"bench.rs" => Some(&mut self.benchs),
+                    "lib.rs" => Some(&mut self.libs),
+                    "main.rs" => Some(&mut self.mains),
+                    "test.rs" => Some(&mut self.tests),
+                    "bench.rs" => Some(&mut self.benchs),
                     _ => None
                 },
                 _ => None
diff --git a/src/librustpkg/path_util.rs b/src/librustpkg/path_util.rs
@@ -234,14 +234,14 @@ pub fn library_in_workspace(path: &Path, short_name: &str, where: Target,
                                Some(j) => {
                                    debug!("Maybe %s equals %s", f_name.slice(0, j), lib_prefix);
                                    if f_name.slice(0, j) == lib_prefix {
-                                       result_filename = Some(p_path);
+                                       result_filename = Some(p_path.clone());
                                    }
                                    break;
                                }
                                None => break
                            }
                        }
-                       _ => { f_name = f_name.slice(0, i).to_owned(); }
+                       _ => { f_name = f_name.slice(0, i); }
                  }
                }
                None => break
diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs
@@ -396,7 +396,7 @@ fn touch_source_file(workspace: &Path, pkgid: &PkgId) {
     let pkg_src_dir = workspace.push("src").push(pkgid.to_str());
     let contents = os::list_dir_path(&pkg_src_dir);
     for p in contents.iter() {
-        if p.filetype() == Some(~".rs") {
+        if p.filetype() == Some(".rs") {
             // should be able to do this w/o a process
             if run::process_output("touch", [p.to_str()]).status != 0 {
                 let _ = cond.raise((pkg_src_dir.clone(), ~"Bad path"));
@@ -413,7 +413,7 @@ fn frob_source_file(workspace: &Path, pkgid: &PkgId) {
     let contents = os::list_dir_path(&pkg_src_dir);
     let mut maybe_p = None;
     for p in contents.iter() {
-        if p.filetype() == Some(~".rs") {
+        if p.filetype() == Some(".rs") {
             maybe_p = Some(p);
             break;
         }
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
@@ -28,7 +28,7 @@ use option::{None, Option, Some};
 use str::{OwnedStr, Str, StrSlice, StrVector};
 use to_str::ToStr;
 use ascii::{AsciiCast, AsciiStr};
-use vec::{OwnedVector, ImmutableVector, OwnedCopyableVector};
+use vec::{Vector, OwnedVector, ImmutableVector, OwnedCopyableVector};
 
 #[cfg(windows)]
 pub use Path = self::WindowsPath;
@@ -65,17 +65,17 @@ pub trait GenericPath {
     fn dirname(&self) -> ~str;
     /// Returns the file component of `self`, as a string option.
     /// Returns None if `self` names a directory.
-    fn filename(&self) -> Option<~str>;
+    fn filename<'a>(&'a self) -> Option<&'a str>;
     /// Returns the stem of the file component of `self`, as a string option.
     /// The stem is the slice of a filename starting at 0 and ending just before
     /// the last '.' in the name.
     /// Returns None if `self` names a directory.
-    fn filestem(&self) -> Option<~str>;
+    fn filestem<'a>(&'a self) -> Option<&'a str>;
     /// Returns the type of the file component of `self`, as a string option.
     /// The file type is the slice of a filename starting just after the last
     /// '.' in the name and ending at the last index in the filename.
     /// Returns None if `self` names a directory.
-    fn filetype(&self) -> Option<~str>;
+    fn filetype<'a>(&'a self) -> Option<&'a str>;
 
     /// Returns a new path consisting of `self` with the parent directory component replaced
     /// with the given string.
@@ -163,7 +163,7 @@ pub trait GenericPath {
         result
     }
 
-    fn components(self) -> ~[~str];
+    fn components<'a>(&'a self) -> &'a [~str];
 }
 
 #[cfg(target_os = "linux")]
@@ -600,31 +600,31 @@ impl GenericPath for PosixPath {
         }
     }
 
-    fn filename(&self) -> Option<~str> {
+    fn filename<'a>(&'a self) -> Option<&'a str> {
         match self.components.len() {
             0 => None,
-            n => Some(self.components[n - 1].clone()),
+            n => Some(self.components[n - 1].as_slice()),
         }
     }
 
-    fn filestem(&self) -> Option<~str> {
+    fn filestem<'a>(&'a self) -> Option<&'a str> {
         match self.filename() {
             None => None,
             Some(ref f) => {
                 match f.rfind('.') {
-                    Some(p) => Some(f.slice_to(p).to_owned()),
-                    None => Some((*f).clone()),
+                    Some(p) => Some(f.slice_to(p)),
+                    None => Some((*f)),
                 }
             }
         }
     }
 
-    fn filetype(&self) -> Option<~str> {
+    fn filetype<'a>(&'a self) -> Option<&'a str> {
         match self.filename() {
             None => None,
             Some(ref f) => {
                 match f.rfind('.') {
-                    Some(p) if p < f.len() => Some(f.slice_from(p).to_owned()),
+                    Some(p) if p < f.len() => Some(f.slice_from(p)),
                     _ => None,
                 }
             }
@@ -670,7 +670,7 @@ impl GenericPath for PosixPath {
     fn file_path(&self) -> PosixPath {
         let cs = match self.filename() {
           None => ~[],
-          Some(ref f) => ~[(*f).clone()]
+          Some(ref f) => ~[(*f).to_owned()]
         };
         PosixPath {
             is_absolute: false,
@@ -756,7 +756,7 @@ impl GenericPath for PosixPath {
              self.is_ancestor_of(&other.pop()))
     }
 
-   fn components(self) -> ~[~str] { self.components }
+   fn components<'a>(&'a self) -> &'a [~str] { self.components.as_slice() }
 }
 
 
@@ -842,31 +842,31 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    fn filename(&self) -> Option<~str> {
+    fn filename<'a>(&'a self) -> Option<&'a str> {
         match self.components.len() {
             0 => None,
-            n => Some(self.components[n - 1].clone()),
+            n => Some(self.components[n - 1].as_slice()),
         }
     }
 
-    fn filestem(&self) -> Option<~str> {
+    fn filestem<'a>(&'a self) -> Option<&'a str> {
         match self.filename() {
             None => None,
             Some(ref f) => {
                 match f.rfind('.') {
-                    Some(p) => Some(f.slice_to(p).to_owned()),
-                    None => Some((*f).clone()),
+                    Some(p) => Some(f.slice_to(p)),
+                    None => Some((*f)),
                 }
             }
         }
     }
 
-    fn filetype(&self) -> Option<~str> {
+    fn filetype<'a>(&'a self) -> Option<&'a str> {
         match self.filename() {
           None => None,
           Some(ref f) => {
             match f.rfind('.') {
-                Some(p) if p < f.len() => Some(f.slice_from(p).to_owned()),
+                Some(p) if p < f.len() => Some(f.slice_from(p)),
                 _ => None,
             }
           }
@@ -916,7 +916,7 @@ impl GenericPath for WindowsPath {
             is_absolute: false,
             components: match self.filename() {
                 None => ~[],
-                Some(ref f) => ~[(*f).clone()],
+                Some(ref f) => ~[(*f).to_owned()],
             }
         }
     }
@@ -1049,7 +1049,7 @@ impl GenericPath for WindowsPath {
              self.is_ancestor_of(&other.pop()))
     }
 
-   fn components(self) -> ~[~str] { self.components }
+   fn components<'a>(&'a self) -> &'a [~str] { self.components.as_slice() }
 }
 
 pub fn normalize(components: &[~str]) -> ~[~str] {
@@ -1143,10 +1143,10 @@ mod tests {
     #[test]
     fn test_filetype_foo_bar() {
         let wp = PosixPath("foo.bar");
-        assert_eq!(wp.filetype(), Some(~".bar"));
+        assert_eq!(wp.filetype(), Some(".bar"));
 
         let wp = WindowsPath("foo.bar");
-        assert_eq!(wp.filetype(), Some(~".bar"));
+        assert_eq!(wp.filetype(), Some(".bar"));
     }
 
     #[test]

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ impl PkgId {`
`68`	`68`	`if path.components.len() < 1 {`
`69`	`69`	`return cond.raise((path, ~"0-length pkgid"));`
`70`	`70`	`}`
`71`		`- let short_name = path.clone().filestem().expect(fmt!("Strange path! %s", s));`
	`71`	`+ let short_name = path.filestem().expect(fmt!("Strange path! %s", s));`
`72`	`72`
`73`	`73`	`let version = match given_version {`
`74`	`74`	`Some(v) => v,`
`@@ -83,8 +83,8 @@ impl PkgId {`
`83`	`83`
`84`	`84`	`debug!("path = %s", path.to_str());`
`85`	`85`	`PkgId {`
`86`		`- path: path,`
`87`		`- short_name: short_name,`
	`86`	`+ path: path.clone(),`
	`87`	`+ short_name: short_name.to_owned(),`
`88`	`88`	`version: version`
`89`	`89`	`}`
`90`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -234,14 +234,14 @@ pub fn library_in_workspace(path: &Path, short_name: &str, where: Target,`
`234`	`234`	`Some(j) => {`
`235`	`235`	`debug!("Maybe %s equals %s", f_name.slice(0, j), lib_prefix);`
`236`	`236`	`if f_name.slice(0, j) == lib_prefix {`
`237`		`- result_filename = Some(p_path);`
	`237`	`+ result_filename = Some(p_path.clone());`
`238`	`238`	`}`
`239`	`239`	`break;`
`240`	`240`	`}`
`241`	`241`	`None => break`
`242`	`242`	`}`
`243`	`243`	`}`
`244`		`- _ => { f_name = f_name.slice(0, i).to_owned(); }`
	`244`	`+ _ => { f_name = f_name.slice(0, i); }`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`	`None => break`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ use option::{None, Option, Some};`
`28`	`28`	`use str::{OwnedStr, Str, StrSlice, StrVector};`
`29`	`29`	`use to_str::ToStr;`
`30`	`30`	`use ascii::{AsciiCast, AsciiStr};`
`31`		`-use vec::{OwnedVector, ImmutableVector, OwnedCopyableVector};`
	`31`	`+use vec::{Vector, OwnedVector, ImmutableVector, OwnedCopyableVector};`
`32`	`32`
`33`	`33`	`#[cfg(windows)]`
`34`	`34`	`pub use Path = self::WindowsPath;`
`@@ -65,17 +65,17 @@ pub trait GenericPath {`
`65`	`65`	`fn dirname(&self) -> ~str;`
`66`	`66`	/// Returns the file component of `self`, as a string option.
`67`	`67`	/// Returns None if `self` names a directory.
`68`		`- fn filename(&self) -> Option<~str>;`
	`68`	`+ fn filename<'a>(&'a self) -> Option<&'a str>;`
`69`	`69`	/// Returns the stem of the file component of `self`, as a string option.
`70`	`70`	`/// The stem is the slice of a filename starting at 0 and ending just before`
`71`	`71`	`/// the last '.' in the name.`
`72`	`72`	/// Returns None if `self` names a directory.
`73`		`- fn filestem(&self) -> Option<~str>;`
	`73`	`+ fn filestem<'a>(&'a self) -> Option<&'a str>;`
`74`	`74`	/// Returns the type of the file component of `self`, as a string option.
`75`	`75`	`/// The file type is the slice of a filename starting just after the last`
`76`	`76`	`/// '.' in the name and ending at the last index in the filename.`
`77`	`77`	/// Returns None if `self` names a directory.
`78`		`- fn filetype(&self) -> Option<~str>;`
	`78`	`+ fn filetype<'a>(&'a self) -> Option<&'a str>;`
`79`	`79`
`80`	`80`	/// Returns a new path consisting of `self` with the parent directory component replaced
`81`	`81`	`/// with the given string.`
`@@ -163,7 +163,7 @@ pub trait GenericPath {`
`163`	`163`	`result`
`164`	`164`	`}`
`165`	`165`
`166`		`- fn components(self) -> ~[~str];`
	`166`	`+ fn components<'a>(&'a self) -> &'a [~str];`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`#[cfg(target_os = "linux")]`
`@@ -600,31 +600,31 @@ impl GenericPath for PosixPath {`
`600`	`600`	`}`
`601`	`601`	`}`
`602`	`602`
`603`		`- fn filename(&self) -> Option<~str> {`
	`603`	`+ fn filename<'a>(&'a self) -> Option<&'a str> {`
`604`	`604`	`match self.components.len() {`
`605`	`605`	`0 => None,`
`606`		`- n => Some(self.components[n - 1].clone()),`
	`606`	`+ n => Some(self.components[n - 1].as_slice()),`
`607`	`607`	`}`
`608`	`608`	`}`
`609`	`609`
`610`		`- fn filestem(&self) -> Option<~str> {`
	`610`	`+ fn filestem<'a>(&'a self) -> Option<&'a str> {`
`611`	`611`	`match self.filename() {`
`612`	`612`	`None => None,`
`613`	`613`	`Some(ref f) => {`
`614`	`614`	`match f.rfind('.') {`
`615`		`- Some(p) => Some(f.slice_to(p).to_owned()),`
`616`		`- None => Some((*f).clone()),`
	`615`	`+ Some(p) => Some(f.slice_to(p)),`
	`616`	`+ None => Some((*f)),`
`617`	`617`	`}`
`618`	`618`	`}`
`619`	`619`	`}`
`620`	`620`	`}`
`621`	`621`
`622`		`- fn filetype(&self) -> Option<~str> {`
	`622`	`+ fn filetype<'a>(&'a self) -> Option<&'a str> {`
`623`	`623`	`match self.filename() {`
`624`	`624`	`None => None,`
`625`	`625`	`Some(ref f) => {`
`626`	`626`	`match f.rfind('.') {`
`627`		`- Some(p) if p < f.len() => Some(f.slice_from(p).to_owned()),`
	`627`	`+ Some(p) if p < f.len() => Some(f.slice_from(p)),`
`628`	`628`	`_ => None,`
`629`	`629`	`}`
`630`	`630`	`}`
`@@ -670,7 +670,7 @@ impl GenericPath for PosixPath {`
`670`	`670`	`fn file_path(&self) -> PosixPath {`
`671`	`671`	`let cs = match self.filename() {`
`672`	`672`	`None => ~[],`
`673`		`- Some(ref f) => ~[(*f).clone()]`
	`673`	`+ Some(ref f) => ~[(*f).to_owned()]`
`674`	`674`	`};`
`675`	`675`	`PosixPath {`
`676`	`676`	`is_absolute: false,`
`@@ -756,7 +756,7 @@ impl GenericPath for PosixPath {`
`756`	`756`	`self.is_ancestor_of(&other.pop()))`
`757`	`757`	`}`
`758`	`758`
`759`		`- fn components(self) -> ~[~str] { self.components }`
	`759`	`+ fn components<'a>(&'a self) -> &'a [~str] { self.components.as_slice() }`
`760`	`760`	`}`
`761`	`761`
`762`	`762`
`@@ -842,31 +842,31 @@ impl GenericPath for WindowsPath {`
`842`	`842`	`}`
`843`	`843`	`}`
`844`	`844`
`845`		`- fn filename(&self) -> Option<~str> {`
	`845`	`+ fn filename<'a>(&'a self) -> Option<&'a str> {`
`846`	`846`	`match self.components.len() {`
`847`	`847`	`0 => None,`
`848`		`- n => Some(self.components[n - 1].clone()),`
	`848`	`+ n => Some(self.components[n - 1].as_slice()),`
`849`	`849`	`}`
`850`	`850`	`}`
`851`	`851`
`852`		`- fn filestem(&self) -> Option<~str> {`
	`852`	`+ fn filestem<'a>(&'a self) -> Option<&'a str> {`
`853`	`853`	`match self.filename() {`
`854`	`854`	`None => None,`
`855`	`855`	`Some(ref f) => {`
`856`	`856`	`match f.rfind('.') {`
`857`		`- Some(p) => Some(f.slice_to(p).to_owned()),`
`858`		`- None => Some((*f).clone()),`
	`857`	`+ Some(p) => Some(f.slice_to(p)),`
	`858`	`+ None => Some((*f)),`
`859`	`859`	`}`
`860`	`860`	`}`
`861`	`861`	`}`
`862`	`862`	`}`
`863`	`863`
`864`		`- fn filetype(&self) -> Option<~str> {`
	`864`	`+ fn filetype<'a>(&'a self) -> Option<&'a str> {`
`865`	`865`	`match self.filename() {`
`866`	`866`	`None => None,`
`867`	`867`	`Some(ref f) => {`
`868`	`868`	`match f.rfind('.') {`
`869`		`- Some(p) if p < f.len() => Some(f.slice_from(p).to_owned()),`
	`869`	`+ Some(p) if p < f.len() => Some(f.slice_from(p)),`
`870`	`870`	`_ => None,`
`871`	`871`	`}`
`872`	`872`	`}`
`@@ -916,7 +916,7 @@ impl GenericPath for WindowsPath {`
`916`	`916`	`is_absolute: false,`
`917`	`917`	`components: match self.filename() {`
`918`	`918`	`None => ~[],`
`919`		`- Some(ref f) => ~[(*f).clone()],`
	`919`	`+ Some(ref f) => ~[(*f).to_owned()],`
`920`	`920`	`}`
`921`	`921`	`}`
`922`	`922`	`}`
`@@ -1049,7 +1049,7 @@ impl GenericPath for WindowsPath {`
`1049`	`1049`	`self.is_ancestor_of(&other.pop()))`
`1050`	`1050`	`}`
`1051`	`1051`
`1052`		`- fn components(self) -> ~[~str] { self.components }`
	`1052`	`+ fn components<'a>(&'a self) -> &'a [~str] { self.components.as_slice() }`
`1053`	`1053`	`}`
`1054`	`1054`
`1055`	`1055`	`pub fn normalize(components: &[~str]) -> ~[~str] {`
`@@ -1143,10 +1143,10 @@ mod tests {`
`1143`	`1143`	`#[test]`
`1144`	`1144`	`fn test_filetype_foo_bar() {`
`1145`	`1145`	`let wp = PosixPath("foo.bar");`
`1146`		`- assert_eq!(wp.filetype(), Some(~".bar"));`
	`1146`	`+ assert_eq!(wp.filetype(), Some(".bar"));`
`1147`	`1147`
`1148`	`1148`	`let wp = WindowsPath("foo.bar");`
`1149`		`- assert_eq!(wp.filetype(), Some(~".bar"));`
	`1149`	`+ assert_eq!(wp.filetype(), Some(".bar"));`
`1150`	`1150`	`}`
`1151`	`1151`
`1152`	`1152`	`#[test]`