---

yaml
---
r: 73253
b: refs/heads/dist-snap
c: b1e8056
h: refs/heads/master
i:
  73251: 5196c50
v: v3

Author: steveklabnik

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 9283dfe0b4dfbad176821ed93df6d519ad58423a
+refs/heads/dist-snap: b1e805694b914613ec30619764bec961e78bbbac
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/io.rs

@@ -10,7 +10,37 @@
 
 /*!
 
-Basic input/output
+The `io` module contains basic input and output routines.
+
+A quick summary:
+
+## `Reader` and `Writer` traits
+
+These traits define the simplest amount of methods that anything that can do
+input and output should implement.
+
+## `ReaderUtil` and `WriterUtil` traits
+
+Richer methods that allow you to do more. `Reader` only lets you read a certain
+amount of bytes into a buffer, while `ReaderUtil` allows you to read a whole
+line, for example.
+
+Generally, these richer methods are probably the ones you want to actually
+use in day-to-day Rust.
+
+Furthermore, because there is an implementation of `ReaderUtil` for
+`<T: Reader>`, when your input or output code implements `Reader`, you get
+all of these methods for free.
+
+## `print` and `println`
+
+These very useful functions are defined here. You generally don't need to
+import them, though, as the prelude already does.
+
+## `stdin`, `stdout`, and `stderr`
+
+These functions return references to the classic three file descriptors. They
+implement `Reader` and `Writer`, where appropriate.
 
 */
 
@@ -1010,16 +1040,6 @@ pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
 // top-level functions that take a reader, or a set of default methods on
 // reader (which can then be called reader)
 
-/**
-* Gives a `Reader` that allows you to read values from standard input.
-*
-* # Examples
-* ~~~
-* let stdin = core::io::stdin();
-* let line = stdin.read_line();
-* core::io::print(line);
-* ~~~
-*/
 pub fn stdin() -> @Reader {
     unsafe {
         @rustrt::rust_get_stdin() as @Reader
@@ -1571,57 +1591,13 @@ pub fn buffered_file_writer(path: &Path) -> Result<@Writer, ~str> {
 // FIXME (#2004) it would be great if this could be a const
 // FIXME (#2004) why are these different from the way stdin() is
 // implemented?
-
-
-/**
-* Gives a `Writer` which allows you to write to the standard output.
-*
-* # Examples
-* ~~~
-* let stdout = core::io::stdout();
-* stdout.write_str("hello\n");
-* ~~~
-*/
 pub fn stdout() -> @Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) }
-
-/**
-* Gives a `Writer` which allows you to write to standard error.
-*
-* # Examples
-* ~~~
-* let stderr = core::io::stderr();
-* stderr.write_str("hello\n");
-* ~~~
-*/
 pub fn stderr() -> @Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
 
-/**
-* Prints a string to standard output.
-*
-* This string will not have an implicit newline at the end. If you want
-* an implicit newline, please see `println`.
-*
-* # Examples
-* ~~~
-* // print is imported into the prelude, and so is always available.
-* print("hello");
-* ~~~
-*/
 pub fn print(s: &str) {
     stdout().write_str(s);
 }
 
-/**
-* Prints a string to standard output, followed by a newline.
-*
-* If you do not want an implicit newline, please see `print`.
-*
-* # Examples
-* ~~~
-* // println is imported into the prelude, and so is always available.
-* println("hello");
-* ~~~
-*/
 pub fn println(s: &str) {
     stdout().write_line(s);
 }

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -386,20 +386,8 @@ fn encode_reexported_static_methods(ecx: @EncodeContext,
     match ecx.tcx.trait_methods_cache.find(&exp.def_id) {
         Some(methods) => {
             match ecx.tcx.items.find(&exp.def_id.node) {
-                Some(&ast_map::node_item(item, path)) => {
-                    let original_name = ecx.tcx.sess.str_of(item.ident);
-
-                    //
-                    // We don't need to reexport static methods on traits
-                    // declared in the same module as our `pub use ...` since
-                    // that's done when we encode the trait item.
-                    //
-                    // The only exception is when the reexport *changes* the
-                    // name e.g. `pub use Foo = self::Bar` -- we have
-                    // encoded metadata for static methods relative to Bar,
-                    // but not yet for Foo.
-                    //
-                    if mod_path != *path || *exp.name != *original_name {
+                Some(&ast_map::node_item(_, path)) => {
+                    if mod_path != *path {
                         for methods.each |&m| {
                             if m.explicit_self == ast::sty_static {
                                 encode_reexported_static_method(ecx,

branches/dist-snap/src/test/auxiliary/mod_trait_with_static_methods_lib.rs

@@ -9,15 +9,6 @@
 // except according to those terms.
 
 pub use sub_foo::Foo;
-pub use Baz = self::Bar;
-
-pub trait Bar {
-    pub fn bar() -> Self;
-}
-
-impl Bar for int {
-    pub fn bar() -> int { 84 }
-}
 
 pub mod sub_foo {
     pub trait Foo {
@@ -27,5 +18,4 @@ pub mod sub_foo {
     impl Foo for int {
         pub fn foo() -> int { 42 }
     }
-
 }

branches/dist-snap/src/test/run-pass/trait_with_static_methods_cross_crate.rs

@@ -13,9 +13,7 @@
 extern mod mod_trait_with_static_methods_lib;
 
 use mod_trait_with_static_methods_lib::Foo;
-use mod_trait_with_static_methods_lib::Baz;
 
 pub fn main() {
     assert_eq!(42, Foo::foo());
-    assert_eq!(84, Baz::bar());
 }