---

yaml
---
r: 64175
b: refs/heads/snap-stage3
c: 6d4d2c9
h: refs/heads/master
i:
  64173: 78102b6
  64171: 3860479
  64167: cd81b4b
  64159: 615b4a3
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6f5be9063ddbfe18ce5321817f782abcd2f55110
+refs/heads/snap-stage3: 6d4d2c9a33ea0b92e98c22e84e76d3116dcd7444
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -292,12 +292,13 @@ pub fn malloc_raw_dyn(bcx: block,
 
     if heap == heap_exchange {
         let llty_value = type_of::type_of(ccx, t);
+        let llalign = llalign_of_min(ccx, llty_value);
 
         // Allocate space:
         let r = callee::trans_lang_call(
             bcx,
             bcx.tcx().lang_items.exchange_malloc_fn(),
-            [size],
+            [C_i32(llalign as i32), size],
             None);
         rslt(r.bcx, PointerCast(r.bcx, r.val, llty_value.ptr_to()))
     } else if heap == heap_exchange_vector {

branches/snap-stage3/src/librustc/middle/typeck/mod.rs

@@ -319,19 +319,16 @@ fn check_main_fn_ty(ccx: &CrateCtxt,
                 }
                 _ => ()
             }
-            let se_ty = ty::mk_bare_fn(tcx, ty::BareFnTy {
-                purity: ast::impure_fn,
-                abis: abi::AbiSet::Rust(),
-                sig: ty::FnSig {
-                    bound_lifetime_names: opt_vec::Empty,
-                    inputs: ~[],
-                    output: ty::mk_nil()
-                }
-            });
-
-            require_same_types(tcx, None, false, main_span, main_t, se_ty,
-                || fmt!("main function expects type: `%s`",
-                        ppaux::ty_to_str(ccx.tcx, se_ty)));
+            let mut ok = ty::type_is_nil(fn_ty.sig.output);
+            let num_args = fn_ty.sig.inputs.len();
+            ok &= num_args == 0u;
+            if !ok {
+                tcx.sess.span_err(
+                    main_span,
+                    fmt!("Wrong type in main function: found `%s`, \
+                          expected `fn() -> ()`",
+                         ppaux::ty_to_str(tcx, main_t)));
+            }
         }
         _ => {
             tcx.sess.span_bug(main_span,

branches/snap-stage3/src/libstd/bool.rs

@@ -19,8 +19,6 @@ A quick summary:
 Implementations of the following traits:
 
 * `FromStr`
-* `ToStr`
-* `Not`
 * `Ord`
 * `TotalOrd`
 * `Eq`
@@ -38,8 +36,6 @@ Finally, some inquries into the nature of truth: `is_true` and `is_false`.
 
 #[cfg(not(test))]
 use cmp::{Eq, Ord, TotalOrd, Ordering};
-#[cfg(not(test))]
-use ops::Not;
 use option::{None, Option, Some};
 use from_str::FromStr;
 use to_str::ToStr;
@@ -258,27 +254,6 @@ pub fn all_values(blk: &fn(v: bool)) {
 #[inline]
 pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
-/**
-* The logical complement of a boolean value.
-*
-* # Examples
-*
-* ~~~rust
-* rusti> !true
-* false
-* ~~~
-*
-* ~~~rust
-* rusti> !false
-* true
-* ~~~
-*/
-#[cfg(not(test))]
-impl Not<bool> for bool {
-    #[inline]
-    fn not(&self) -> bool { !*self }
-}
-
 #[cfg(not(test))]
 impl Ord for bool {
     #[inline]

branches/snap-stage3/src/libstd/option.rs

@@ -379,13 +379,6 @@ impl<'self, A> Iterator<&'self A> for OptionIterator<'self, A> {
     fn next(&mut self) -> Option<&'self A> {
         util::replace(&mut self.opt, None)
     }
-
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        match self.opt {
-            Some(_) => (1, Some(1)),
-            None => (0, Some(0)),
-        }
-    }
 }
 
 /// Mutable iterator over an `Option<A>`
@@ -397,13 +390,6 @@ impl<'self, A> Iterator<&'self mut A> for OptionMutIterator<'self, A> {
     fn next(&mut self) -> Option<&'self mut A> {
         util::replace(&mut self.opt, None)
     }
-
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        match self.opt {
-            Some(_) => (1, Some(1)),
-            None => (0, Some(0)),
-        }
-    }
 }
 
 #[test]
@@ -501,39 +487,3 @@ fn test_filtered() {
     assert_eq!(some_stuff.get(), 42);
     assert!(modified_stuff.is_none());
 }
-
-#[test]
-fn test_iter() {
-    let val = 5;
-
-    let x = Some(val);
-    let mut it = x.iter();
-
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next(), Some(&val));
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert!(it.next().is_none());
-}
-
-#[test]
-fn test_mut_iter() {
-    let val = 5;
-    let new_val = 11;
-
-    let mut x = Some(val);
-    let mut it = x.mut_iter();
-
-    assert_eq!(it.size_hint(), (1, Some(1)));
-
-    match it.next() {
-        Some(interior) => {
-            assert_eq!(*interior, val);
-            *interior = new_val;
-            assert_eq!(x, Some(new_val));
-        }
-        None => assert!(false),
-    }
-
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert!(it.next().is_none());
-}

branches/snap-stage3/src/libstd/ptr.rs

@@ -14,7 +14,6 @@ use cast;
 use option::{Option, Some, None};
 use sys;
 use unstable::intrinsics;
-use util::swap;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 use uint;
@@ -178,9 +177,9 @@ pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
     let t: *mut T = &mut tmp;
 
     // Perform the swap
-    copy_nonoverlapping_memory(t, x, 1);
-    copy_memory(x, y, 1); // `x` and `y` may overlap
-    copy_nonoverlapping_memory(y, t, 1);
+    copy_memory(t, x, 1);
+    copy_memory(x, y, 1);
+    copy_memory(y, t, 1);
 
     // y and t now point to the same thing, but we need to completely forget `tmp`
     // because it's no longer relevant.
@@ -193,7 +192,7 @@ pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
  */
 #[inline]
 pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
-    swap(cast::transmute(dest), &mut src); // cannot overlap
+    swap_ptr(dest, &mut src);
     src
 }
 
@@ -203,7 +202,8 @@ pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
 #[inline(always)]
 pub unsafe fn read_ptr<T>(src: *mut T) -> T {
     let mut tmp: T = intrinsics::uninit();
-    copy_nonoverlapping_memory(&mut tmp, src, 1);
+    let t: *mut T = &mut tmp;
+    copy_memory(t, src, 1);
     tmp
 }
 

branches/snap-stage3/src/libstd/repr.rs

@@ -206,11 +206,13 @@ impl ReprVisitor {
                            inner: *TyDesc)
                            -> bool {
         let mut p = ptr;
-        let end = ptr::offset(p, len);
         let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
         self.writer.write_char('[');
         let mut first = true;
-        while (p as uint) < (end as uint) {
+        let mut left = len;
+        // unit structs have 0 size, and don't loop forever.
+        let dec = if sz == 0 {1} else {sz};
+        while left > 0 {
             if first {
                 first = false;
             } else {
@@ -219,6 +221,7 @@ impl ReprVisitor {
             self.write_mut_qualifier(mtbl);
             self.visit_ptr_inner(p as *c_void, inner);
             p = align(ptr::offset(p, sz) as uint, al) as *u8;
+            left -= dec;
         }
         self.writer.write_char(']');
         true
@@ -635,4 +638,7 @@ fn test_repr() {
                "(10, ~\"hello\")");
     exact_test(&(10_u64, ~"hello"),
                "(10, ~\"hello\")");
+
+    struct Foo;
+    exact_test(&(~[Foo, Foo, Foo]), "~[{}, {}, {}]");
 }

branches/snap-stage3/src/libstd/rt/global_heap.rs

@@ -76,11 +76,11 @@ pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     box as *c_char
 }
 
-/// The allocator for unique pointers without contained managed pointers.
+// FIXME #4942: Make these signatures agree with exchange_alloc's signatures
 #[cfg(not(stage0), not(test))]
 #[lang="exchange_malloc"]
 #[inline]
-pub unsafe fn exchange_malloc(size: uintptr_t) -> *c_char {
+pub unsafe fn exchange_malloc(_align: u32, size: uintptr_t) -> *c_char {
     malloc_raw(size as uint) as *c_char
 }
 

branches/snap-stage3/src/libstd/vec.rs

@@ -27,7 +27,7 @@ use option::{None, Option, Some};
 use ptr::to_unsafe_ptr;
 use ptr;
 use ptr::RawPtr;
-use rt::global_heap::{malloc_raw, realloc_raw};
+use rt::global_heap::realloc_raw;
 use sys;
 use sys::size_of;
 use uint;
@@ -101,31 +101,12 @@ pub fn to_owned<T:Copy>(t: &[T]) -> ~[T] {
 }
 
 /// Creates a new vector with a capacity of `capacity`
-#[cfg(stage0)]
 pub fn with_capacity<T>(capacity: uint) -> ~[T] {
     let mut vec = ~[];
     vec.reserve(capacity);
     vec
 }
 
-/// Creates a new vector with a capacity of `capacity`
-#[cfg(not(stage0))]
-pub fn with_capacity<T>(capacity: uint) -> ~[T] {
-    unsafe {
-        if contains_managed::<T>() {
-            let mut vec = ~[];
-            vec.reserve(capacity);
-            vec
-        } else {
-            let alloc = capacity * sys::nonzero_size_of::<T>();
-            let ptr = malloc_raw(alloc + size_of::<raw::VecRepr>()) as *mut raw::VecRepr;
-            (*ptr).unboxed.alloc = alloc;
-            (*ptr).unboxed.fill = 0;
-            cast::transmute(ptr)
-        }
-    }
-}
-
 /**
  * Builds a vector by calling a provided function with an argument
  * function that pushes an element to the back of a vector.
@@ -1790,7 +1771,7 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
 
 }
 
-/// Trait for &[T] where T is Cloneable
+/// Trait for ~[T] where T is Cloneable
 pub trait MutableCloneableVector<T> {
     /// Copies as many elements from `src` as it can into `self`
     /// (the shorter of self.len() and src.len()). Returns the number of elements copied.

branches/snap-stage3/src/libsyntax/diagnostic.rs

@@ -213,7 +213,7 @@ fn print_diagnostic(topic: &str, lvl: level, msg: &str) {
     }
 
     print_maybe_colored(fmt!("%s: ", diagnosticstr(lvl)), diagnosticcolor(lvl));
-    print_maybe_colored(fmt!("%s\n", msg), term::color::BRIGHT_WHITE);
+    stderr.write_str(fmt!("%s\n", msg));
 }
 
 pub fn collect(messages: @mut ~[~str])

branches/snap-stage3/src/test/compile-fail/bad-main.rs

@@ -8,4 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main(x: int) { } //~ ERROR: main function expects type
+// error-pattern:expected `fn()
+
+fn main(x: int) { }

branches/snap-stage3/src/test/compile-fail/extern-main-fn.rs renamed to branches/snap-stage3/src/test/compile-fail/binop-add-ptr.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,4 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-extern fn main() {} //~ ERROR: main function expects type
+// error-pattern:binary operation + cannot be applied to type `*int`
+
+fn die() -> *int { (0 as *int) + (0 as *int) }
+fn main() { }

branches/snap-stage3/src/test/compile-fail/main-wrong-type-2.rs

@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() -> char {
-//~^ ERROR: main function expects type
+//~^ ERROR Wrong type in main function: found `extern "Rust" fn() -> char`
 }

branches/snap-stage3/src/test/compile-fail/main-wrong-type.rs

@@ -14,5 +14,5 @@ struct S {
 }
 
 fn main(foo: S) {
-//~^ ERROR: main function expects type
+//~^ ERROR Wrong type in main function: found `extern "Rust" fn(S)`
 }