---

yaml
---
r: 73254
b: refs/heads/dist-snap
c: e42fcb9
h: refs/heads/master
v: v3

Author: emberian

[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: b1e805694b914613ec30619764bec961e78bbbac
+refs/heads/dist-snap: e42fcb958cd89d11dbe8f493cfac0a1fca4b1bb1
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -10,37 +10,7 @@
 
 /*!
 
-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.
+Basic input/output
 
 */
 
@@ -1040,6 +1010,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

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

@@ -220,6 +220,7 @@ pub mod llvm {
     use super::{ObjectFileRef, Opcode, PassManagerRef, PassManagerBuilderRef};
     use super::{SectionIteratorRef, TargetDataRef, TypeKind, TypeRef, UseRef};
     use super::{ValueRef};
+    use super::{IntPredicate, RealPredicate};
 
     use core::libc::{c_char, c_int, c_longlong, c_uint, c_ulonglong};
 
@@ -451,6 +452,10 @@ pub mod llvm {
         /* all zeroes */
         #[fast_ffi]
         pub unsafe fn LLVMConstAllOnes(Ty: TypeRef) -> ValueRef;
+        #[fast_ffi]
+        pub unsafe fn LLVMConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef;
+        #[fast_ffi]
+        pub unsafe fn LLVMConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef;
         /* only for int/vector */
         #[fast_ffi]
         pub unsafe fn LLVMGetUndef(Ty: TypeRef) -> ValueRef;

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,10 @@
 // except according to those terms.
 
 use back::abi;
-use lib::llvm::{llvm, SetLinkage, PrivateLinkage,
-                ValueRef, TypeRef, Bool, True, False};
+use lib::llvm::{llvm, 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 +282,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 +292,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 { llvm::LLVMConstFCmp(RealOEQ, te1, te2) }
+                  else        { llvm::LLVMConstICmp(IntEQ, te1, te2)   }
+              },
+              ast::lt     => {
+                  if is_float { llvm::LLVMConstFCmp(RealOLT, te1, te2) }
+                  else        {
+                      if signed { llvm::LLVMConstICmp(IntSLT, te1, te2) }
+                      else      { llvm::LLVMConstICmp(IntULT, te1, te2) }
+                  }
+              },
+              ast::le     => {
+                  if is_float { llvm::LLVMConstFCmp(RealOLE, te1, te2) }
+                  else        {
+                      if signed { llvm::LLVMConstICmp(IntSLE, te1, te2) }
+                      else      { llvm::LLVMConstICmp(IntULE, te1, te2) }
+                  }
+              },
+              ast::ne     => {
+                  if is_float { llvm::LLVMConstFCmp(RealONE, te1, te2) }
+                  else        { llvm::LLVMConstICmp(IntNE, te1, te2) }
+              },
+              ast::ge     => {
+                  if is_float { llvm::LLVMConstFCmp(RealOGE, te1, te2) }
+                  else        {
+                      if signed { llvm::LLVMConstICmp(IntSGE, te1, te2) }
+                      else      { llvm::LLVMConstICmp(IntUGE, te1, te2) }
+                  }
+              },
+              ast::gt     => {
+                  if is_float { llvm::LLVMConstFCmp(RealOGT, te1, te2) }
+                  else        {
+                      if signed { llvm::LLVMConstICmp(IntSGT, te1, te2) }
+                      else      { llvm::LLVMConstICmp(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 }
     }
+
 }

branches/dist-snap/src/test/run-pass/const-binops.rs

@@ -0,0 +1,116 @@
+static a: int = -4 + 3;
+static a2: uint = 3 + 3;
+static b: float = 3.0 + 2.7;
+
+static c: int = 3 - 4;
+static d: uint = 3 - 3;
+static e: float = 3.0 - 2.7;
+
+static e2: int = -3 * 3;
+static f: uint = 3 * 3;
+static g: float = 3.3 * 3.3;
+
+static h: int = 3 / -1;
+static i: uint = 3 / 3;
+static j: float = 3.3 / 3.3;
+
+static n: bool = true && false;
+
+static o: bool = true || false;
+
+static p: int = 3 & 1;
+static q: uint = 1 & 3;
+
+static r: int = 3 | 1;
+static s: uint = 1 | 3;
+
+static t: int = 3 ^ 1;
+static u: uint = 1 ^ 3;
+
+static v: int = 1 << 3;
+
+// NOTE: better shr coverage
+static w: int = 1024 >> 4;
+static x: uint = 1024 >> 4;
+
+static y: bool = 1 == 1;
+static z: bool = 1.0 == 1.0;
+
+static aa: bool = 1 <= 2;
+static ab: bool = -1 <= 2;
+static ac: bool = 1.0 <= 2;
+
+static ad: bool = 1 < 2;
+static ae: bool = -1 < 2;
+static af: bool = 1.0 < 2;
+
+static ag: bool = 1 != 2;
+static ah: bool = -1 != 2;
+static ai: bool = 1.0 != 2;
+
+static aj: bool = 2 >= 1;
+static ak: bool = 2 >= -2;
+static al: bool = 1.0 >= -2;
+
+static am: bool = 2 > 1;
+static an: bool = 2 > -2;
+static ao: bool = 1.0 > -2;
+
+fn main() {
+    assert_eq!(a, -1);
+    assert_eq!(a2, 6);
+    assert_approx_eq!(b, 5.7);
+
+    assert_eq!(c, -1);
+    assert_eq!(d, 0);
+    assert_approx_eq!(e, -0.3);
+
+    assert_eq!(e2, -9);
+    assert_eq!(f, 9);
+    assert_approx_eq!(g, 10.89);
+
+    assert_eq!(h, -3);
+    assert_eq!(i, 1);
+    assert_approx_eq!(j, 1.0);
+
+    assert_eq!(n, false);
+
+    assert_eq!(o, true);
+
+    assert_eq!(p, 1);
+    assert_eq!(q, 1);
+
+    assert_eq!(r, 3);
+    assert_eq!(s, 3);
+
+    assert_eq!(t, 2);
+    assert_eq!(u, 2);
+
+    assert_eq!(v, 8);
+
+    assert_eq!(w, 64);
+    assert_eq!(x, 64);
+
+    assert_eq!(y, true);
+    assert_eq!(z, true);
+
+    assert_eq!(aa, true);
+    assert_eq!(ab, true);
+    assert_eq!(ac, true);
+
+    assert_eq!(ad, true);
+    assert_eq!(ae, true);
+    assert_eq!(af, true);
+
+    assert_eq!(ag, true);
+    assert_eq!(ah, true);
+    assert_eq!(ai, true);
+
+    assert_eq!(aj, true);
+    assert_eq!(ak, true);
+    assert_eq!(al, true);
+
+    assert_eq!(am, true);
+    assert_eq!(an, true);
+    assert_eq!(ao, true);
+}

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

@@ -13,7 +13,9 @@
 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());
 }