auto merge of #17163 : pcwalton/rust/impls-next-to-struct, r=alexcrichton

type they provide an implementation for.

This breaks code like:

    mod foo {
        struct Foo { ... }
    }

    impl foo::Foo {
        ...
    }

Change this code to:

    mod foo {
        struct Foo { ... }

        impl Foo {
            ...
        }
    }

Closes #17059.

RFC #155.

[breaking-change]

r? @brson

Author: bors

src/compiletest/runtest.rs

@@ -20,6 +20,7 @@ use util::logv;
 use util;
 
 use std::io::File;
+use std::io::fs::PathExtensions;
 use std::io::fs;
 use std::io::net::tcp;
 use std::io::process::ProcessExit;

src/libglob/lib.rs

@@ -37,6 +37,7 @@
 
 use std::cell::Cell;
 use std::{cmp, os, path};
+use std::io::fs::PathExtensions;
 use std::io::fs;
 use std::path::is_sep;
 use std::string::String;

src/libnative/io/process.rs

@@ -21,6 +21,7 @@ use std::rt::rtio;
 use super::file;
 use super::util;
 
+#[cfg(windows)] use std::io::fs::PathExtensions;
 #[cfg(windows)] use std::string::String;
 #[cfg(unix)] use super::c;
 #[cfg(unix)] use super::retry;

src/librustc/back/link.rs

@@ -28,6 +28,7 @@ use util::ppaux;
 use util::sha2::{Digest, Sha256};
 
 use std::char;
+use std::io::fs::PathExtensions;
 use std::io::{fs, TempDir, Command};
 use std::io;
 use std::mem;

src/librustc/metadata/filesearch.rs

@@ -11,9 +11,10 @@
 #![allow(non_camel_case_types)]
 
 use std::cell::RefCell;
-use std::os;
-use std::io::fs;
 use std::collections::HashSet;
+use std::io::fs::PathExtensions;
+use std::io::fs;
+use std::os;
 
 use util::fs as myfs;
 

src/librustc/metadata/loader.rs

@@ -229,6 +229,7 @@ use util::fs;
 
 use std::c_str::ToCStr;
 use std::cmp;
+use std::io::fs::PathExtensions;
 use std::io;
 use std::mem;
 use std::ptr;

src/librustc/middle/resolve.rs

@@ -1313,10 +1313,6 @@ impl<'a> Resolver<'a> {
                 // If this implements an anonymous trait, then add all the
                 // methods within to a new module, if the type was defined
                 // within this module.
-                //
-                // FIXME (#3785): This is quite unsatisfactory. Perhaps we
-                // should modify anonymous traits to only be implementable in
-                // the same module that declared the type.
 
                 // Create the module and add all methods.
                 match ty.node {
@@ -1400,7 +1396,13 @@ impl<'a> Resolver<'a> {
                             }
                         }
                     }
-                    _ => {}
+                    _ => {
+                        self.resolve_error(ty.span,
+                                           "inherent implementations may \
+                                            only be implemented in the same \
+                                            module as the type they are \
+                                            implemented for")
+                    }
                 }
 
                 parent

src/librustc_back/archive.rs

@@ -10,6 +10,7 @@
 
 //! A helper class for dealing with static archives
 
+use std::io::fs::PathExtensions;
 use std::io::process::{Command, ProcessOutput};
 use std::io::{fs, TempDir};
 use std::io;

src/librustdoc/html/render.rs

@@ -35,6 +35,7 @@
 
 use std::collections::{HashMap, HashSet};
 use std::fmt;
+use std::io::fs::PathExtensions;
 use std::io::{fs, File, BufferedWriter, MemWriter, BufferedReader};
 use std::io;
 use std::str;

src/libstd/io/fs.rs

@@ -31,6 +31,7 @@ particular bits of it, etc.
 
 ```rust
 # #![allow(unused_must_use)]
+use std::io::fs::PathExtensions;
 use std::io::{File, fs};
 
 let path = Path::new("foo.txt");
@@ -622,8 +623,9 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
 /// # Example
 ///
 /// ```rust
-/// use std::io;
+/// use std::io::fs::PathExtensions;
 /// use std::io::fs;
+/// use std::io;
 ///
 /// // one possible implementation of fs::walk_dir only visiting files
 /// fn visit_dirs(dir: &Path, cb: |&Path|) -> io::IoResult<()> {
@@ -868,45 +870,54 @@ impl Seek for File {
     }
 }
 
-impl path::Path {
+/// Utility methods for paths.
+pub trait PathExtensions {
     /// Get information on the file, directory, etc at this path.
     ///
     /// Consult the `fs::stat` documentation for more info.
     ///
     /// This call preserves identical runtime/error semantics with `file::stat`.
-    pub fn stat(&self) -> IoResult<FileStat> { stat(self) }
+    fn stat(&self) -> IoResult<FileStat>;
 
     /// Get information on the file, directory, etc at this path, not following
     /// symlinks.
     ///
     /// Consult the `fs::lstat` documentation for more info.
     ///
     /// This call preserves identical runtime/error semantics with `file::lstat`.
-    pub fn lstat(&self) -> IoResult<FileStat> { lstat(self) }
+    fn lstat(&self) -> IoResult<FileStat>;
 
     /// Boolean value indicator whether the underlying file exists on the local
     /// filesystem. Returns false in exactly the cases where `fs::stat` fails.
-    pub fn exists(&self) -> bool {
-        self.stat().is_ok()
-    }
+    fn exists(&self) -> bool;
 
     /// Whether the underlying implementation (be it a file path, or something
     /// else) points at a "regular file" on the FS. Will return false for paths
     /// to non-existent locations or directories or other non-regular files
     /// (named pipes, etc). Follows links when making this determination.
-    pub fn is_file(&self) -> bool {
-        match self.stat() {
-            Ok(s) => s.kind == io::TypeFile,
-            Err(..) => false
-        }
-    }
+    fn is_file(&self) -> bool;
 
     /// Whether the underlying implementation (be it a file path, or something
     /// else) is pointing at a directory in the underlying FS. Will return
     /// false for paths to non-existent locations or if the item is not a
     /// directory (eg files, named pipes, etc). Follows links when making this
     /// determination.
-    pub fn is_dir(&self) -> bool {
+    fn is_dir(&self) -> bool;
+}
+
+impl PathExtensions for path::Path {
+    fn stat(&self) -> IoResult<FileStat> { stat(self) }
+    fn lstat(&self) -> IoResult<FileStat> { lstat(self) }
+    fn exists(&self) -> bool {
+        self.stat().is_ok()
+    }
+    fn is_file(&self) -> bool {
+        match self.stat() {
+            Ok(s) => s.kind == io::TypeFile,
+            Err(..) => false
+        }
+    }
+    fn is_dir(&self) -> bool {
         match self.stat() {
             Ok(s) => s.kind == io::TypeDirectory,
             Err(..) => false