---

yaml
---
r: 71935
b: refs/heads/dist-snap
c: 8158dd7
h: refs/heads/master
i:
  71933: 574f468
  71931: 47f8b6a
  71927: 1a1d008
  71919: d80959c
  71903: ca43ca0
  71871: f75782e
  71807: cac9a21
  71679: 4addab6
v: v3

Author: catamorphism

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

branches/dist-snap/.gitmodules

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

branches/dist-snap/configure

@@ -533,7 +533,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-	(3.3|3.3svn|3.2|3.2svn)
+	(3.2svn|3.2|3.1svn|3.1|3.0svn|3.0)
 	    msg "found ok version of LLVM: $LLVM_VERSION"
 	    ;;
 	(*)
@@ -859,7 +859,7 @@ do
         LDFLAGS=$LLVM_LDFLAGS
 
         LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
-                        $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
+                        $LLVM_HOST $LLVM_TARGET"
 
         msg "configuring LLVM with:"
         msg "$LLVM_FLAGS"

branches/dist-snap/doc/rust.md

@@ -1653,12 +1653,11 @@ Path expressions are [lvalues](#lvalues-rvalues-and-temporaries).
 
 ### Tuple expressions
 
-Tuples are written by enclosing one or more comma-separated
+Tuples are written by enclosing two 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);
 ~~~~~~~~
@@ -2579,7 +2578,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.
+list. Single-element tuples are not legal; all tuples have two or more values.
 
 The members of a tuple are laid out in memory contiguously, like a record, in
 order specified by the tuple type.

branches/dist-snap/doc/tutorial.md

@@ -495,11 +495,7 @@ omitted.
 
 A powerful application of pattern matching is *destructuring*:
 matching in order to bind names to the contents of data
-types.
-
-> ***Note:*** The following code makes use of tuples (`(float, float)`) which
-> are explained in section 5.3. For now you can think of tuples as a list of
-> items.
+types. Assuming that `(float, float)` is a tuple of two floats:
 
 ~~~~
 fn angle(vector: (float, float)) -> float {
@@ -751,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 (though you may consider
+Tuples can have any arity except for 0 or 1 (though you may consider
 unit, `()`, as the empty tuple if you like).
 
 ~~~~
@@ -1071,28 +1067,6 @@ let mut d = @mut 5; // mutable variable, mutable box
 d = @mut 15;
 ~~~~
 
-A mutable variable and an immutable variable can refer to the same box, given 
-that their types are compatible. Mutability of a box is a property of its type, 
-however, so for example a mutable handle to an immutable box cannot be 
-assigned a reference to a mutable box.
-
-~~~~
-let a = @1;     // immutable box
-let b = @mut 2; // mutable box
-
-let mut c : @int;       // declare a variable with type managed immutable int
-let mut d : @mut int;   // and one of type managed mutable int
-
-c = a;          // box type is the same, okay
-d = b;          // box type is the same, okay
-~~~~
-
-~~~~ {.xfail-test}
-// but b cannot be assigned to c, or a to d
-c = b;          // error
-~~~~
-
-
 # Move semantics
 
 Rust uses a shallow copy for parameter passing, assignment and returning values
@@ -1107,16 +1081,6 @@ let y = x.clone(); // y is a newly allocated box
 let z = x; // no new memory allocated, x can no longer be used
 ~~~~
 
-Since in owned boxes mutability is a property of the owner, not the 
-box, mutable boxes may become immutable when they are moved, and vice-versa.
-
-~~~~
-let r = ~13;
-let mut s = r; // box becomes mutable
-*s += 1;
-let t = s; // box becomes immutable
-~~~~
-
 # Borrowed pointers
 
 Rust's borrowed pointers are a general purpose reference type. In contrast with
@@ -2324,7 +2288,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 `radius` field), but you get the idea.
+(since we could just return the `circle` 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/dist-snap/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 dual-licensed under Apache 2.0 and MIT terms.  See \fBCOPYRIGHT\fR
-file in the rust source distribution.
+This work is licensed under MIT-like terms.  See \fBLICENSE.txt\fR
+in the rust source distribution.

branches/dist-snap/mk/dist.mk

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

branches/dist-snap/src/compiletest/compiletest.rc

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

branches/dist-snap/src/driver/driver.rs

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

branches/dist-snap/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.7-pre" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.6" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -110,11 +110,8 @@ 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    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 region    rustComment     start="/\*" end="\*/" contains=rustComment,rustTodo
+syn region    rustComment     start="//" skip="\\$" end="$" contains=rustTodo keepend
 
 syn keyword rustTodo contained TODO FIXME XXX NB
 
@@ -137,7 +134,6 @@ 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/dist-snap/src/libcore/bool.rs

@@ -8,13 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 //! Boolean logic
 
-#[cfg(notest)]
-use cmp::{Eq, Ord, TotalOrd, Ordering};
 use option::{None, Option, Some};
 use from_str::FromStr;
 
+#[cfg(notest)] use cmp;
+
 /// Negation / inverse
 pub fn not(v: bool) -> bool { !v }
 
@@ -72,86 +73,40 @@ pub fn all_values(blk: &fn(v: bool)) {
 }
 
 /// converts truth value to an 8 bit byte
-#[inline(always)]
 pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 #[cfg(notest)]
-impl Ord for bool {
-    #[inline(always)]
-    fn lt(&self, other: &bool) -> bool { to_bit(*self) < to_bit(*other) }
-    #[inline(always)]
-    fn le(&self, other: &bool) -> bool { to_bit(*self) <= to_bit(*other) }
-    #[inline(always)]
-    fn gt(&self, other: &bool) -> bool { to_bit(*self) > to_bit(*other) }
-    #[inline(always)]
-    fn ge(&self, other: &bool) -> bool { to_bit(*self) >= to_bit(*other) }
-}
-
-#[cfg(notest)]
-impl TotalOrd for bool {
-    #[inline(always)]
-    fn cmp(&self, other: &bool) -> Ordering { to_bit(*self).cmp(&to_bit(*other)) }
-}
-
-#[cfg(notest)]
-impl Eq for bool {
-    #[inline(always)]
+impl cmp::Eq for bool {
     fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
-    #[inline(always)]
     fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use prelude::*;
+#[test]
+pub fn test_bool_from_str() {
+    use from_str::FromStr;
 
-    #[test]
-    fn test_bool_from_str() {
-        use from_str::FromStr;
-
-        do all_values |v| {
-            assert!(Some(v) == FromStr::from_str(to_str(v)))
-        }
+    do all_values |v| {
+        assert!(Some(v) == FromStr::from_str(to_str(v)))
     }
+}
 
-    #[test]
-    fn test_bool_to_str() {
-        assert!(to_str(false) == ~"false");
-        assert!(to_str(true) == ~"true");
-    }
-
-    #[test]
-    fn test_bool_to_bit() {
-        do all_values |v| {
-            assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
-        }
-    }
-
-    #[test]
-    fn test_bool_ord() {
-        assert!(true > false);
-        assert!(!(false > true));
-
-        assert!(false < true);
-        assert!(!(true < false));
-
-        assert!(false <= false);
-        assert!(false >= false);
-        assert!(true <= true);
-        assert!(true >= true);
-
-        assert!(false <= true);
-        assert!(!(false >= true));
-        assert!(true >= false);
-        assert!(!(true <= false));
-    }
+#[test]
+pub fn test_bool_to_str() {
+    assert!(to_str(false) == ~"false");
+    assert!(to_str(true) == ~"true");
+}
 
-    #[test]
-    fn test_bool_totalord() {
-        assert_eq!(true.cmp(&true), Equal);
-        assert_eq!(false.cmp(&false), Equal);
-        assert_eq!(true.cmp(&false), Greater);
-        assert_eq!(false.cmp(&true), Less);
+#[test]
+pub fn test_bool_to_bit() {
+    do all_values |v| {
+        assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
     }
 }
+
+// Local Variables:
+// mode: rust;
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// End:

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

@@ -202,10 +202,12 @@ pub fn escape_unicode(c: char) -> ~str {
                     else { ('U', 8u) });
     assert!(str::len(s) <= pad);
     let mut out = ~"\\";
-    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);
+    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);
+    }
     out
 }