---

yaml
---
r: 135373
b: refs/heads/snap-stage3
c: 9ac804e
h: refs/heads/master
i:
  135371: 58aff2a
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 74090504219e4e37c1a6d9fdd8600f44b51c7b04
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f96ee10e888bac4435973972f1799db509b3318e
+refs/heads/snap-stage3: 9ac804ecabe3800a16941691bb1eb90293fd2606
 refs/heads/try: 14378ea357c06c23607ca61ade44f60a7a64a1c7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/.travis.yml

@@ -3,6 +3,13 @@
 # downloads a rust/cargo snapshot, which we don't really want for building rust.
 language: c
 
+# Make sure we've got an up-to-date g++ compiler to get past the LLVM configure
+# script.
+install:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+  - sudo apt-get update -qq
+  - sudo apt-get install g++-4.7
+
 # The test suite is in general way too stressful for travis, especially in
 # terms of time limit and reliability. In the past we've tried to scale things
 # back to only build the stage1 compiler and run a subset of tests, but this
@@ -11,13 +18,17 @@ language: c
 # As a result, we're just using travis to run `make tidy` now. It'll help
 # everyone find out about their trailing spaces early on!
 before_script:
-  - ./configure
+  - ./configure --llvm-root=`pwd`/local-llvm
 script:
   - make tidy
 
 notifications:
   email: false
 
+env:
+  global:
+    - LLVM_VERSION=3.4
+
 branches:
   only:
     - master

branches/snap-stage3/mk/ctags.mk

@@ -28,7 +28,7 @@ CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/llvm,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/sundown,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/vg,, \
 				$(wildcard ${CFG_SRC_DIR}src/*) $(wildcard ${CFG_SRC_DIR}src/rt/*) \
-				)))))))))
+				)))))))))))
 CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=-javascript --recurse ${CTAGS_LOCATIONS}
 # We could use `--languages=Rust`, but there is value in producing tags for the
 # C++ parts of the code base too (at the time of writing, those are .h and .cpp

branches/snap-stage3/mk/rt.mk

@@ -35,7 +35,7 @@
 # that's per-target so you're allowed to conditionally add files based on the
 # target.
 ################################################################################
-NATIVE_LIBS := rust_builtin hoedown morestack miniz context_switch \
+NATIVE_LIBS := rust_builtin hoedown uv_support morestack miniz context_switch \
 		rustrt_native rust_test_helpers
 
 # $(1) is the target triple
@@ -50,6 +50,7 @@ NATIVE_DEPS_hoedown_$(1) := hoedown/src/autolink.c \
 			hoedown/src/html_smartypants.c \
 			hoedown/src/stack.c \
 			hoedown/src/version.c
+NATIVE_DEPS_uv_support_$(1) := rust_uv.c
 NATIVE_DEPS_miniz_$(1) = miniz.c
 NATIVE_DEPS_rust_builtin_$(1) := rust_builtin.c \
 			rust_android_dummy.c

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![feature(phase)]
+#![feature(phase, slicing_syntax)]
 
 #![deny(warnings)]
 

branches/snap-stage3/src/compiletest/runtest.rs

@@ -874,7 +874,7 @@ fn check_error_patterns(props: &TestProps,
     if done { return; }
 
     let missing_patterns =
-        props.error_patterns.slice(next_err_idx, props.error_patterns.len());
+        props.error_patterns[next_err_idx..];
     if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]).as_slice(),

branches/snap-stage3/src/doc/guide-lifetimes.md

@@ -305,17 +305,21 @@ copying.
 #     Circle(Point, f64),   // origin, radius
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
+# static tau: f64 = 6.28;
 fn compute_area(shape: &Shape) -> f64 {
     match *shape {
-        Circle(_, radius) => std::f64::consts::PI * radius * radius,
+        Circle(_, radius) => 0.5 * tau * radius * radius,
         Rectangle(_, ref size) => size.w * size.h
     }
 }
 ~~~
 
 The first case matches against circles. Here, the pattern extracts the
 radius from the shape variant and the action uses it to compute the
-area of the circle.
+area of the circle. (Like any up-to-date engineer, we use the [tau
+circle constant][tau] and not that dreadfully outdated notion of pi).
+
+[tau]: http://www.math.utah.edu/~palais/pi.html
 
 The second match is more interesting. Here we match against a
 rectangle and extract its size: but rather than copy the `size`

branches/snap-stage3/src/doc/guide-pointers.md

@@ -632,6 +632,19 @@ This part is coming soon.
 
 This part is coming soon.
 
+# Gc
+
+The `Gc<T>` type exists for historical reasons, and is [still used
+internally](https://github.com/rust-lang/rust/issues/7929) by the compiler.
+It is not even a 'real' garbage collected type at the moment.
+
+In the future, Rust may have a real garbage collected type, and so it
+has not yet been removed for that reason.
+
+## Best practices
+
+There is currently no legitimate use case for the `Gc<T>` type.
+
 # Raw Pointers
 
 This part is coming soon.

branches/snap-stage3/src/doc/guide-runtime.md

@@ -31,6 +31,7 @@ list):
 * Task synchronization
 * Task-local storage
 * Logging
+* Local heaps (GC heaps)
 * Task unwinding
 
 ## What is the runtime accomplishing?

branches/snap-stage3/src/doc/guide-unsafe.md

@@ -208,7 +208,9 @@ pub struct Unique<T> {
 // Implement methods for creating and using the values in the box.
 
 // NB: For simplicity and correctness, we require that T has kind Send
-// (owned boxes relax this restriction).
+// (owned boxes relax this restriction, and can contain managed (GC) boxes).
+// This is because, as implemented, the garbage collector would not know
+// about any shared boxes stored in the malloc'd region of memory.
 impl<T: Send> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         unsafe {

branches/snap-stage3/src/doc/guide.md

@@ -195,11 +195,9 @@ The second point is the `println!()` part. This is calling a Rust **macro**,
 which is how metaprogramming is done in Rust. If it were a function instead, it
 would look like this: `println()`. For our purposes, we don't need to worry
 about this difference. Just know that sometimes, you'll see a `!`, and that
-means that you're calling a macro instead of a normal function. Rust implements
-`println!` as a macro rather than a function for good reasons, but that's a
-very advanced topic. You'll learn more when we talk about macros later. One
-last thing to mention: Rust's macros are significantly different than C macros,
-if you've used those. Don't be scared of using macros. We'll get to the details
+means that you're calling a macro instead of a normal function. One last thing
+to mention: Rust's macros are significantly different than C macros, if you've
+used those. Don't be scared of using macros. We'll get to the details
 eventually, you'll just have to trust us for now.
 
 Next, `"Hello, world!"` is a **string**. Strings are a surprisingly complicated
@@ -661,12 +659,14 @@ error: mismatched types: expected `int` but found `()` (expected int but found (
 ```
 
 We expected an integer, but we got `()`. `()` is pronounced 'unit', and is a
-special type in Rust's type system. In Rust, `()` is _not_ a valid value for a
-variable of type `int`. It's only a valid value for variables of the type `()`,
-which aren't very useful. Remember how we said statements don't return a value?
-Well, that's the purpose of unit in this case. The semicolon turns any
-expression into a statement by throwing away its value and returning unit
-instead.
+special type in Rust's type system. `()` is different than `null` in other
+languages, because `()` is distinct from other types. For example, in C, `null`
+is a valid value for a variable of type `int`. In Rust, `()` is _not_ a valid
+value for a variable of type `int`. It's only a valid value for variables of
+the type `()`, which aren't very useful. Remember how we said statements don't
+return a value? Well, that's the purpose of unit in this case. The semicolon
+turns any expression into a statement by throwing away its value and returning
+unit instead.
 
 There's one more time in which you won't see a semicolon at the end of a line
 of Rust code. For that, we'll need our next concept: functions.
@@ -1680,11 +1680,11 @@ just `int`s.
 
 Rust provides a method on these `IoResult<T>`s called `ok()`, which does the
 same thing as our `match` statement, but assuming that we have a valid value.
-We then call `expect()` on the result, which will terminate our program if we
-don't have a valid value. In this case, if we can't get input, our program
-doesn't work, so we're okay with that. In most cases, we would want to handle
-the error case explicitly. `expect()` allows us to give an error message if
-this crash happens.
+If we don't, it will terminate our program. In this case, if we can't get
+input, our program doesn't work, so we're okay with that. In most cases, we
+would want to handle the error case explicitly. The result of `ok()` has a
+method, `expect()`, which allows us to give an error message if this crash
+happens.
 
 We will cover the exact details of how all of this works later in the Guide.
 For now, this gives you enough of a basic understanding to work with.
@@ -2030,7 +2030,7 @@ fn main() {
     match cmp(input, secret_number) {
         Less    => println!("Too small!"),
         Greater => println!("Too big!"),
-        Equal   => println!("You win!"),
+        Equal   => { println!("You win!"); },
     }
 }
 
@@ -2727,8 +2727,7 @@ mod hello {
 }
 ```
 
-Usage of the `pub` keyword is sometimes called 'exporting', because
-we're making the function available for other modules. This will work:
+This will work:
 
 ```{notrust,ignore}
 $ cargo run
@@ -3292,7 +3291,8 @@ use super::times_four;
 
 Because we've made a nested module, we can import functions from the parent
 module by using `super`. Sub-modules are allowed to 'see' private functions in
-the parent.
+the parent. We sometimes call this usage of `use` a 're-export,' because we're
+exporting the name again, somewhere else.
 
 We've now covered the basics of testing. Rust's tools are primitive, but they
 work well in the simple cases. There are some Rustaceans working on building

branches/snap-stage3/src/doc/reference.md

@@ -3381,7 +3381,7 @@ fn main() {
 
 ```
 
-Patterns can also dereference pointers by using the `&`, `box` symbols,
+Patterns can also dereference pointers by using the `&`, `box` or `@` symbols,
 as appropriate. For example, these two matches on `x: &int` are equivalent:
 
 ```
@@ -3828,7 +3828,7 @@ type signature of `print`, and the cast expression in `main`.
 Within the body of an item that has type parameter declarations, the names of
 its type parameters are types:
 
-```
+```ignore
 fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
     if xs.len() == 0 {
        return vec![];

branches/snap-stage3/src/etc/x86.supp

@@ -373,6 +373,14 @@
    fun:_ZN4llvm4UsernwEjj
 }
 
+{
+   libuv-0-byte-realloc
+   Memcheck:Leak
+   fun:malloc
+   ...
+   fun:*uv_loop_delete*
+}
+
 {
    race-or-something-ask-pcwalton-0
    Memcheck:Value4
@@ -494,3 +502,15 @@
    fun:*
    ...
 }
+
+{
+   libuv-mac-no-thread-join
+   Memcheck:Leak
+   fun:malloc_zone_malloc
+   fun:_CFRuntimeCreateInstance
+   fun:CFRunLoopSourceCreate
+   fun:uv__platform_loop_init
+   fun:uv__loop_init
+   fun:uv_loop_new
+   ...
+}

branches/snap-stage3/src/liballoc/heap.rs

@@ -182,15 +182,9 @@ mod imp {
 
     #[inline]
     pub unsafe fn reallocate_inplace(ptr: *mut u8, size: uint, align: uint,
-                                     old_size: uint) -> bool {
+                                     _old_size: uint) -> bool {
         let flags = align_to_flags(align);
-        let new_size = je_xallocx(ptr as *mut c_void, size as size_t, 0, flags) as uint;
-        // checking for failure to shrink is tricky
-        if size < old_size {
-            usable_size(size, align) == new_size as uint
-        } else {
-            new_size >= size
-        }
+        je_xallocx(ptr as *mut c_void, size as size_t, 0, flags) == size as size_t
     }
 
     #[inline]
@@ -256,9 +250,9 @@ mod imp {
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(_ptr: *mut u8, size: uint, _align: uint,
-                                     old_size: uint) -> bool {
-        size == old_size
+    pub unsafe fn reallocate_inplace(_ptr: *mut u8, _size: uint, _align: uint,
+                                     _old_size: uint) -> bool {
+        false
     }
 
     #[inline]
@@ -318,9 +312,9 @@ mod imp {
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(_ptr: *mut u8, size: uint, _align: uint,
-                                     old_size: uint) -> bool {
-        size == old_size
+    pub unsafe fn reallocate_inplace(_ptr: *mut u8, _size: uint, _align: uint,
+                                     _old_size: uint) -> bool {
+        false
     }
 
     #[inline]
@@ -341,21 +335,9 @@ mod imp {
 }
 
 #[cfg(test)]
-mod test {
+mod bench {
     extern crate test;
     use self::test::Bencher;
-    use heap;
-
-    #[test]
-    fn basic_reallocate_inplace_noop() {
-        unsafe {
-            let size = 4000;
-            let ptr = heap::allocate(size, 8);
-            let ret = heap::reallocate_inplace(ptr, size, 8, size);
-            heap::deallocate(ptr, size, 8);
-            assert!(ret);
-        }
-    }
 
     #[bench]
     fn alloc_owned_small(b: &mut Bencher) {

branches/snap-stage3/src/liballoc/lib.rs

@@ -92,6 +92,7 @@ pub use boxed as owned;
 
 pub mod heap;
 pub mod libc_heap;
+pub mod util;
 
 // Primitive types using the heaps above
 

branches/snap-stage3/src/liballoc/rc.rs

@@ -541,6 +541,14 @@ mod tests {
         assert!(y.upgrade().is_none());
     }
 
+    #[test]
+    fn gc_inside() {
+        // see issue #11532
+        use std::gc::GC;
+        let a = Rc::new(RefCell::new(box(GC) 1i));
+        assert!(a.try_borrow_mut().is_some());
+    }
+
     #[test]
     fn weak_self_cyclic() {
         struct Cycle {