---

yaml
---
r: 65097
b: refs/heads/master
c: dc57d15
h: refs/heads/master
i:
  65095: e7f2631
v: v3

Author: steveklabnik

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cab9249c62d5f33b3ae625970c05231341d2f95e
+refs/heads/master: dc57d15b69601e8d88e7ee71b578a1624e28f89e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libcore/io.rs

@@ -1010,16 +1010,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 +1561,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);
 }

trunk/src/libcore/rt/stack.rs

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

trunk/src/libcore/rt/uv/mod.rs

@@ -44,9 +44,6 @@ 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;

trunk/src/libcore/rt/uv/uvio.rs

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

trunk/src/libcore/unstable/lang.rs

@@ -16,7 +16,6 @@ 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};

trunk/src/librustc/lib/llvm.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use core::hashmap::HashMap;
-use core::libc::{c_uint, c_ushort};
+use core::libc::c_uint;
 
 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_ushort, c_uint, c_ulonglong};
+    use core::libc::{c_char, c_int, c_longlong, c_uint, c_ulonglong};
 
     #[link_args = "-Lrustllvm -lrustllvm"]
     #[link_name = "rustllvm"]
@@ -451,10 +451,6 @@ 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;
@@ -1918,16 +1914,6 @@ 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 {

trunk/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,

trunk/src/librustc/middle/trans/consts.rs

@@ -9,11 +9,8 @@
 // except according to those terms.
 
 use back::abi;
-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 lib::llvm::{llvm, SetLinkage, PrivateLinkage,
+                ValueRef, TypeRef, Bool, True, False};
 use metadata::csearch;
 use middle::const_eval;
 use middle::trans::adt;
@@ -283,8 +280,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    => llvm::LLVMConstAnd(te1, te2),
-              ast::or     => llvm::LLVMConstOr(te1, te2),
+              ast::and    |
+              ast::or     => cx.sess.span_unimpl(e.span, "binop logic"),
               ast::bitxor => llvm::LLVMConstXor(te1, te2),
               ast::bitand => llvm::LLVMConstAnd(te1, te2),
               ast::bitor  => llvm::LLVMConstOr(te1, te2),
@@ -293,44 +290,14 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                 if signed { llvm::LLVMConstAShr(te1, te2) }
                 else      { llvm::LLVMConstLShr(te1, te2) }
               }
-              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::eq     |
+              ast::lt     |
+              ast::le     |
+              ast::ne     |
+              ast::ge     |
+              ast::gt     => cx.sess.span_unimpl(e.span, "binop comparator")
+            }
+          }
           ast::expr_unary(u, e) => {
             let te = const_expr(cx, e);
             let ty = ty::expr_ty(cx.tcx, e);

trunk/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 }
     }
-
 }