---

yaml
---
r: 73261
b: refs/heads/dist-snap
c: 0b39bc2
h: refs/heads/master
i:
  73259: 644399d
v: v3

Author: bors

[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: dc57d15b69601e8d88e7ee71b578a1624e28f89e
+refs/heads/dist-snap: 0b39bc275e8f573238ad23fc8f86c87cec5e103d
 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 minimal set 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
+number 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,6 +1040,16 @@ 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
@@ -1561,13 +1601,57 @@ 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/libcore/rt/stack.rs

@@ -39,7 +39,9 @@ pub impl StackSegment {
 
     /// Point to the low end of the allocated stack
     fn start(&self) -> *uint {
-      vec::raw::to_ptr(self.buf) as *uint
+        unsafe {
+            vec::raw::to_ptr(self.buf) as *uint
+        }
     }
 
     /// Point one word beyond the high end of the allocated stack

branches/dist-snap/src/libcore/rt/uv/mod.rs

@@ -44,6 +44,9 @@ use vec;
 use ptr;
 use cast;
 use str;
+use option::*;
+use str::raw::from_c_str;
+use to_str::ToStr;
 use libc::{c_void, c_int, size_t, malloc, free};
 use cast::transmute;
 use ptr::null;

branches/dist-snap/src/libcore/rt/uv/uvio.rs

@@ -11,6 +11,7 @@
 use option::*;
 use result::*;
 use ops::Drop;
+use old_iter::CopyableIter;
 use cell::{Cell, empty_cell};
 use cast::transmute;
 use clone::Clone;

branches/dist-snap/src/libcore/unstable/lang.rs

@@ -16,6 +16,7 @@ use libc::{c_char, c_uchar, c_void, size_t, uintptr_t, c_int, STDERR_FILENO};
 use managed::raw::BoxRepr;
 use str;
 use sys;
+use cast::transmute;
 use rt::{context, OldTaskContext};
 use rt::local_services::borrow_local_services;
 use option::{Option, Some, None};

branches/dist-snap/src/librustc/lib/llvm.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use core::hashmap::HashMap;
-use core::libc::c_uint;
+use core::libc::{c_uint, c_ushort};
 
 pub type Opcode = u32;
 pub type Bool = c_uint;
@@ -221,7 +221,7 @@ pub mod llvm {
     use super::{SectionIteratorRef, TargetDataRef, TypeKind, TypeRef, UseRef};
     use super::{ValueRef};
 
-    use core::libc::{c_char, c_int, c_longlong, c_uint, c_ulonglong};
+    use core::libc::{c_char, c_int, c_longlong, c_ushort, c_uint, c_ulonglong};
 
     #[link_args = "-Lrustllvm -lrustllvm"]
     #[link_name = "rustllvm"]
@@ -451,6 +451,10 @@ pub mod llvm {
         /* all zeroes */
         #[fast_ffi]
         pub unsafe fn LLVMConstAllOnes(Ty: TypeRef) -> ValueRef;
+        #[fast_ffi]
+        pub unsafe fn LLVMConstICmp(Pred: c_ushort, V1: ValueRef, V2: ValueRef) -> ValueRef;
+        #[fast_ffi]
+        pub unsafe fn LLVMConstFCmp(Pred: c_ushort, V1: ValueRef, V2: ValueRef) -> ValueRef;
         /* only for int/vector */
         #[fast_ffi]
         pub unsafe fn LLVMGetUndef(Ty: TypeRef) -> ValueRef;
@@ -1914,6 +1918,16 @@ pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
     }
 }
 
+pub fn ConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
+    unsafe {
+        llvm::LLVMConstICmp(Pred as c_ushort, V1, V2)
+    }
+}
+pub fn ConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
+    unsafe {
+        llvm::LLVMConstFCmp(Pred as c_ushort, V1, V2)
+    }
+}
 /* Memory-managed object interface to type handles. */
 
 pub struct TypeNames {

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

@@ -386,8 +386,20 @@ 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(_, path)) => {
-                    if mod_path != *path {
+                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 {
                         for methods.each |&m| {
                             if m.explicit_self == ast::sty_static {
                                 encode_reexported_static_method(ecx,

branches/dist-snap/src/librustc/middle/trans/consts.rs

@@ -9,8 +9,11 @@
 // except according to those terms.
 
 use back::abi;
-use lib::llvm::{llvm, SetLinkage, PrivateLinkage,
-                ValueRef, TypeRef, Bool, True, False};
+use lib::llvm::{llvm, ConstFCmp, ConstICmp, SetLinkage, PrivateLinkage, ValueRef, TypeRef, Bool,
+    True, False};
+use lib::llvm::{IntEQ, IntNE, IntUGT, IntUGE, IntULT, IntULE, IntSGT, IntSGE, IntSLT, IntSLE,
+    RealOEQ, RealOGT, RealOGE, RealOLT, RealOLE, RealONE};
+
 use metadata::csearch;
 use middle::const_eval;
 use middle::trans::adt;
@@ -280,8 +283,8 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                 else if signed { llvm::LLVMConstSRem(te1, te2) }
                 else           { llvm::LLVMConstURem(te1, te2) }
               }
-              ast::and    |
-              ast::or     => cx.sess.span_unimpl(e.span, "binop logic"),
+              ast::and    => llvm::LLVMConstAnd(te1, te2),
+              ast::or     => llvm::LLVMConstOr(te1, te2),
               ast::bitxor => llvm::LLVMConstXor(te1, te2),
               ast::bitand => llvm::LLVMConstAnd(te1, te2),
               ast::bitor  => llvm::LLVMConstOr(te1, te2),
@@ -290,14 +293,44 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                 if signed { llvm::LLVMConstAShr(te1, te2) }
                 else      { llvm::LLVMConstLShr(te1, te2) }
               }
-              ast::eq     |
-              ast::lt     |
-              ast::le     |
-              ast::ne     |
-              ast::ge     |
-              ast::gt     => cx.sess.span_unimpl(e.span, "binop comparator")
-            }
-          }
+              ast::eq     => {
+                  if is_float { ConstFCmp(RealOEQ, te1, te2) }
+                  else        { ConstICmp(IntEQ, te1, te2)   }
+              },
+              ast::lt     => {
+                  if is_float { ConstFCmp(RealOLT, te1, te2) }
+                  else        {
+                      if signed { ConstICmp(IntSLT, te1, te2) }
+                      else      { ConstICmp(IntULT, te1, te2) }
+                  }
+              },
+              ast::le     => {
+                  if is_float { ConstFCmp(RealOLE, te1, te2) }
+                  else        {
+                      if signed { ConstICmp(IntSLE, te1, te2) }
+                      else      { ConstICmp(IntULE, te1, te2) }
+                  }
+              },
+              ast::ne     => {
+                  if is_float { ConstFCmp(RealONE, te1, te2) }
+                  else        { ConstICmp(IntNE, te1, te2) }
+              },
+              ast::ge     => {
+                  if is_float { ConstFCmp(RealOGE, te1, te2) }
+                  else        {
+                      if signed { ConstICmp(IntSGE, te1, te2) }
+                      else      { ConstICmp(IntUGE, te1, te2) }
+                  }
+              },
+              ast::gt     => {
+                  if is_float { ConstFCmp(RealOGT, te1, te2) }
+                  else        {
+                      if signed { ConstICmp(IntSGT, te1, te2) }
+                      else      { ConstICmp(IntUGT, te1, te2) }
+                  }
+              },
+            };
+          },
           ast::expr_unary(u, e) => {
             let te = const_expr(cx, e);
             let ty = ty::expr_ty(cx.tcx, e);

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

@@ -9,6 +9,15 @@
 // 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 {
@@ -18,4 +27,5 @@ pub mod sub_foo {
     impl Foo for int {
         pub fn foo() -> int { 42 }
     }
+
 }