---

yaml
---
r: 55995
b: refs/heads/auto
c: 23251b2
h: refs/heads/master
i:
  55993: 9226c76
  55991: 085407e
v: v3

Author: brson

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 3e67085d7a590ef360e7c85cc6c3931bae6df6a5
+refs/heads/auto: 23251b24389c68dd01ac26dbaa30125aa8f64c35
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/.gitmodules

@@ -1,6 +1,6 @@
 [submodule "src/llvm"]
 	path = src/llvm
-	url = git://github.com/brson/llvm.git
+	url = https://github.com/brson/llvm.git
 [submodule "src/libuv"]
 	path = src/libuv
-	url = git://github.com/brson/libuv.git
+	url = https://github.com/brson/libuv.git

branches/auto/doc/rust.md

@@ -1653,11 +1653,12 @@ Path expressions are [lvalues](#lvalues-rvalues-and-temporaries).
 
 ### Tuple expressions
 
-Tuples are written by enclosing two or more comma-separated
+Tuples are written by enclosing one or more comma-separated
 expressions in parentheses. They are used to create [tuple-typed](#tuple-types)
 values.
 
 ~~~~~~~~ {.tuple}
+(0,);
 (0f, 4.5f);
 ("a", 4u, true);
 ~~~~~~~~
@@ -2578,7 +2579,7 @@ to the record type-constructor. The differences are as follows:
 
 Tuple types and values are denoted by listing the types or values of their
 elements, respectively, in a parenthesized, comma-separated
-list. Single-element tuples are not legal; all tuples have two or more values.
+list.
 
 The members of a tuple are laid out in memory contiguously, like a record, in
 order specified by the tuple type.

branches/auto/doc/tutorial.md

@@ -747,7 +747,7 @@ fn area(sh: Shape) -> float {
 
 Tuples in Rust behave exactly like structs, except that their fields
 do not have names. Thus, you cannot access their fields with dot notation.
-Tuples can have any arity except for 0 or 1 (though you may consider
+Tuples can have any arity except for 0 (though you may consider
 unit, `()`, as the empty tuple if you like).
 
 ~~~~
@@ -2320,7 +2320,7 @@ impl Shape for CircleStruct {
 Notice that methods of `Circle` can call methods on `Shape`, as our
 `radius` implementation calls the `area` method.
 This is a silly way to compute the radius of a circle
-(since we could just return the `circle` field), but you get the idea.
+(since we could just return the `radius` field), but you get the idea.
 
 In type-parameterized functions,
 methods of the supertrait may be called on values of subtrait-bound type parameters.

branches/auto/man/rustc.1

@@ -170,5 +170,5 @@ See \fBAUTHORS.txt\fR in the rust source distribution. Graydon Hoare
 <\fI[email protected]\fR> is the project leader.
 
 .SH "COPYRIGHT"
-This work is licensed under MIT-like terms.  See \fBLICENSE.txt\fR
-in the rust source distribution.
+This work is dual-licensed under Apache 2.0 and MIT terms.  See \fBCOPYRIGHT\fR
+file in the rust source distribution.

branches/auto/mk/dist.mk

@@ -18,6 +18,7 @@ PKG_FILES := \
     $(S)COPYRIGHT                              \
     $(S)LICENSE-APACHE                         \
     $(S)LICENSE-MIT                            \
+    $(S)AUTHORS.txt                            \
     $(S)README.md                              \
     $(S)configure $(S)Makefile.in              \
     $(S)man                                    \

branches/auto/src/compiletest/compiletest.rc

@@ -17,8 +17,8 @@
 #[allow(deprecated_mode)];
 #[allow(deprecated_pattern)];
 
-extern mod core(vers = "0.6");
-extern mod std(vers = "0.6");
+extern mod core(vers = "0.7-rc");
+extern mod std(vers = "0.7-rc");
 
 use core::*;
 

branches/auto/src/driver/driver.rs

@@ -9,24 +9,24 @@
 // except according to those terms.
 
 #[no_core];
-extern mod core(vers = "0.6");
+extern mod core(vers = "0.7-rc");
 
 #[cfg(rustpkg)]
-extern mod this(name = "rustpkg", vers = "0.6");
+extern mod this(name = "rustpkg", vers = "0.7-rc");
 
 #[cfg(fuzzer)]
-extern mod this(name = "fuzzer", vers = "0.6");
+extern mod this(name = "fuzzer", vers = "0.7-rc");
 
 #[cfg(rustdoc)]
-extern mod this(name = "rustdoc", vers = "0.6");
+extern mod this(name = "rustdoc", vers = "0.7-rc");
 
 #[cfg(rusti)]
-extern mod this(name = "rusti", vers = "0.6");
+extern mod this(name = "rusti", vers = "0.7-rc");
 
 #[cfg(rust)]
-extern mod this(name = "rust", vers = "0.6");
+extern mod this(name = "rust", vers = "0.7-rc");
 
 #[cfg(rustc)]
-extern mod this(name = "rustc", vers = "0.6");
+extern mod this(name = "rustc", vers = "0.7-rc");
 
 fn main() { this::main() }

branches/auto/src/etc/kate/rust.xml

@@ -7,7 +7,7 @@
 	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
 	<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
 ]>
-<language name="Rust" version="0.6" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.7-rc" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>

branches/auto/src/etc/vim/syntax/rust.vim

@@ -110,8 +110,11 @@ syn match     rustFloat       display "\<[0-9][0-9_]*\.[0-9_]\+\%([eE][+-]\=[0-9
 syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
 syn match   rustCharacter   "'\([^'\\]\|\\\(['nrt\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'"
 
-syn region    rustComment     start="/\*" end="\*/" contains=rustComment,rustTodo
-syn region    rustComment     start="//" skip="\\$" end="$" contains=rustTodo keepend
+syn region    rustCommentDoc  start="/\*\*" end="\*/"
+syn region    rustCommentDoc  start="///" skip="\\$" end="$" keepend
+syn match     rustComment     "/\*\*/"
+syn region    rustComment     start="/\*\([^\*]\|$\)" end="\*/" contains=rustTodo
+syn region    rustComment     start="//\([^/]\|$\)" skip="\\$" end="$" contains=rustTodo keepend
 
 syn keyword rustTodo contained TODO FIXME XXX NB
 
@@ -134,6 +137,7 @@ hi def link rustConditional   Conditional
 hi def link rustIdentifier    Identifier
 hi def link rustModPath       Include
 hi def link rustFuncName      Function
+hi def link rustCommentDoc    SpecialComment
 hi def link rustComment       Comment
 hi def link rustMacro         Macro
 hi def link rustType          Type

branches/auto/src/libcore/char.rs

@@ -202,12 +202,10 @@ pub fn escape_unicode(c: char) -> ~str {
                     else { ('U', 8u) });
     assert!(str::len(s) <= pad);
     let mut out = ~"\\";
-    unsafe {
-        str::push_str(&mut out, str::from_char(c));
-        for uint::range(str::len(s), pad) |_i|
-            { str::push_str(&mut out, ~"0"); }
-        str::push_str(&mut out, s);
-    }
+    str::push_str(&mut out, str::from_char(c));
+    for uint::range(str::len(s), pad) |_i|
+        { str::push_str(&mut out, ~"0"); }
+    str::push_str(&mut out, s);
     out
 }
 

branches/auto/src/libcore/clone.rs

@@ -14,7 +14,7 @@ In Rust, some simple types are "implicitly copyable" and when you
 assign them or pass them as arguments, the receiver will get a copy,
 leaving the original value in place. These types do not require
 allocation to copy and do not have finalizers (i.e. they do not
-contain owned pointers or implement `Drop`), so the compiler considers
+contain owned boxes or implement `Drop`), so the compiler considers
 them cheap and safe to copy and automatically implements the `Copy`
 trait for them. For other types copies must be made explicitly,
 by convention implementing the `Clone` trait and calling the
@@ -23,32 +23,38 @@ by convention implementing the `Clone` trait and calling the
 */
 
 pub trait Clone {
+    /// Return a deep copy of the owned object tree. Managed boxes are cloned with a shallow copy.
     fn clone(&self) -> Self;
 }
 
 impl Clone for () {
+    /// Return a copy of the value.
     #[inline(always)]
     fn clone(&self) -> () { () }
 }
 
 impl<T:Clone> Clone for ~T {
+    /// Return a deep copy of the owned box.
     #[inline(always)]
     fn clone(&self) -> ~T { ~(**self).clone() }
 }
 
-impl<T:Clone> Clone for @T {
+impl<T> Clone for @T {
+    /// Return a shallow copy of the managed box.
     #[inline(always)]
-    fn clone(&self) -> @T { @(**self).clone() }
+    fn clone(&self) -> @T { *self }
 }
 
-impl<T:Clone> Clone for @mut T {
+impl<T> Clone for @mut T {
+    /// Return a shallow copy of the managed box.
     #[inline(always)]
-    fn clone(&self) -> @mut T { @mut (**self).clone() }
+    fn clone(&self) -> @mut T { *self }
 }
 
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {
+            /// Return a copy of the value.
             #[inline(always)]
             fn clone(&self) -> $t { *self }
         }
@@ -76,21 +82,23 @@ clone_impl!(char)
 
 #[test]
 fn test_owned_clone() {
-    let a : ~int = ~5i;
-    let b : ~int = a.clone();
+    let a: ~int = ~5i;
+    let b: ~int = a.clone();
     assert!(a == b);
 }
 
 #[test]
 fn test_managed_clone() {
-    let a : @int = @5i;
-    let b : @int = a.clone();
+    let a: @int = @5i;
+    let b: @int = a.clone();
     assert!(a == b);
 }
 
 #[test]
 fn test_managed_mut_clone() {
-    let a : @int = @5i;
-    let b : @int = a.clone();
+    let a: @mut int = @mut 5i;
+    let b: @mut int = a.clone();
+    assert!(a == b);
+    *b = 10;
     assert!(a == b);
 }

branches/auto/src/libcore/core.rc

@@ -48,7 +48,7 @@ they contained the following prologue:
 
 
 #[link(name = "core",
-       vers = "0.6",
+       vers = "0.7-rc",
        uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
        url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
 
@@ -66,7 +66,7 @@ they contained the following prologue:
 #[allow(deprecated_drop)];
 
 // Make core testable by not duplicating lang items. See #2912
-#[cfg(test)] extern mod realcore(name = "core", vers = "0.6");
+#[cfg(test)] extern mod realcore(name = "core", vers = "0.7-rc");
 #[cfg(test)] pub use kinds = realcore::kinds;
 #[cfg(test)] pub use ops = realcore::ops;
 #[cfg(test)] pub use cmp = realcore::cmp;

branches/auto/src/libcore/hash.rs

@@ -76,51 +76,43 @@ pub trait Streaming {
 impl<A:IterBytes> Hash for A {
     #[inline(always)]
     fn hash_keyed(&self, k0: u64, k1: u64) -> u64 {
-        unsafe {
-            let s = &State(k0, k1);
-            for self.iter_bytes(true) |bytes| {
-                s.input(bytes);
-            }
-            s.result_u64()
+        let s = &State(k0, k1);
+        for self.iter_bytes(true) |bytes| {
+            s.input(bytes);
         }
+        s.result_u64()
     }
 }
 
 fn hash_keyed_2<A: IterBytes,
                 B: IterBytes>(a: &A, b: &B, k0: u64, k1: u64) -> u64 {
-    unsafe {
-        let s = &State(k0, k1);
-        for a.iter_bytes(true) |bytes| { s.input(bytes); }
-        for b.iter_bytes(true) |bytes| { s.input(bytes); }
-        s.result_u64()
-    }
+    let s = &State(k0, k1);
+    for a.iter_bytes(true) |bytes| { s.input(bytes); }
+    for b.iter_bytes(true) |bytes| { s.input(bytes); }
+    s.result_u64()
 }
 
 fn hash_keyed_3<A: IterBytes,
                 B: IterBytes,
                 C: IterBytes>(a: &A, b: &B, c: &C, k0: u64, k1: u64) -> u64 {
-    unsafe {
-        let s = &State(k0, k1);
-        for a.iter_bytes(true) |bytes| { s.input(bytes); }
-        for b.iter_bytes(true) |bytes| { s.input(bytes); }
-        for c.iter_bytes(true) |bytes| { s.input(bytes); }
-        s.result_u64()
-    }
+    let s = &State(k0, k1);
+    for a.iter_bytes(true) |bytes| { s.input(bytes); }
+    for b.iter_bytes(true) |bytes| { s.input(bytes); }
+    for c.iter_bytes(true) |bytes| { s.input(bytes); }
+    s.result_u64()
 }
 
 fn hash_keyed_4<A: IterBytes,
                 B: IterBytes,
                 C: IterBytes,
                 D: IterBytes>(a: &A, b: &B, c: &C, d: &D, k0: u64, k1: u64)
                            -> u64 {
-    unsafe {
-        let s = &State(k0, k1);
-        for a.iter_bytes(true) |bytes| { s.input(bytes); }
-        for b.iter_bytes(true) |bytes| { s.input(bytes); }
-        for c.iter_bytes(true) |bytes| { s.input(bytes); }
-        for d.iter_bytes(true) |bytes| { s.input(bytes); }
-        s.result_u64()
-    }
+    let s = &State(k0, k1);
+    for a.iter_bytes(true) |bytes| { s.input(bytes); }
+    for b.iter_bytes(true) |bytes| { s.input(bytes); }
+    for c.iter_bytes(true) |bytes| { s.input(bytes); }
+    for d.iter_bytes(true) |bytes| { s.input(bytes); }
+    s.result_u64()
 }
 
 fn hash_keyed_5<A: IterBytes,
@@ -129,15 +121,13 @@ fn hash_keyed_5<A: IterBytes,
                 D: IterBytes,
                 E: IterBytes>(a: &A, b: &B, c: &C, d: &D, e: &E,
                               k0: u64, k1: u64) -> u64 {
-    unsafe {
-        let s = &State(k0, k1);
-        for a.iter_bytes(true) |bytes| { s.input(bytes); }
-        for b.iter_bytes(true) |bytes| { s.input(bytes); }
-        for c.iter_bytes(true) |bytes| { s.input(bytes); }
-        for d.iter_bytes(true) |bytes| { s.input(bytes); }
-        for e.iter_bytes(true) |bytes| { s.input(bytes); }
-        s.result_u64()
-    }
+    let s = &State(k0, k1);
+    for a.iter_bytes(true) |bytes| { s.input(bytes); }
+    for b.iter_bytes(true) |bytes| { s.input(bytes); }
+    for c.iter_bytes(true) |bytes| { s.input(bytes); }
+    for d.iter_bytes(true) |bytes| { s.input(bytes); }
+    for e.iter_bytes(true) |bytes| { s.input(bytes); }
+    s.result_u64()
 }
 
 // Implement State as SipState

branches/auto/src/libcore/num/f32.rs

@@ -507,7 +507,7 @@ impl num::ToStrRadix for f32 {
 #[inline(always)]
 pub fn from_str(num: &str) -> Option<f32> {
     strconv::from_str_common(num, 10u, true, true, true,
-                             strconv::ExpDec, false)
+                             strconv::ExpDec, false, false)
 }
 
 /**
@@ -540,7 +540,7 @@ pub fn from_str(num: &str) -> Option<f32> {
 #[inline(always)]
 pub fn from_str_hex(num: &str) -> Option<f32> {
     strconv::from_str_common(num, 16u, true, true, true,
-                             strconv::ExpBin, false)
+                             strconv::ExpBin, false, false)
 }
 
 /**
@@ -565,7 +565,7 @@ pub fn from_str_hex(num: &str) -> Option<f32> {
 #[inline(always)]
 pub fn from_str_radix(num: &str, rdx: uint) -> Option<f32> {
     strconv::from_str_common(num, rdx, true, true, false,
-                             strconv::ExpNone, false)
+                             strconv::ExpNone, false, false)
 }
 
 impl from_str::FromStr for f32 {