---

yaml
---
r: 139166
b: refs/heads/try2
c: d4fee24
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 5f2d4102c5dabde915f1f6cb99c38b9274790cda
+refs/heads/try2: d4fee24c7c4c8ddb1c2c681a01f666a59881acbb
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial.md

@@ -579,29 +579,20 @@ Structs are quite similar to C structs and are even laid out the same way in
 memory (so you can read from a Rust struct in C, and vice-versa). Use the dot
 operator to access struct fields, as in `mypoint.x`.
 
-~~~~
-struct Point {
-    x: float,
-    y: float
-}
-~~~~
-
 Inherited mutability means that any field of a struct may be mutable, if the
 struct is in a mutable slot (or a field of a struct in a mutable slot, and
 so forth).
 
-With a value (say, `mypoint`) of such a type in a mutable location, you can do
-`mypoint.y += 1.0`. But in an immutable location, such an assignment to a
-struct without inherited mutability would result in a type error.
-
-~~~~ {.xfail-test}
-# struct Point { x: float, y: float }
-let mut mypoint = Point { x: 1.0, y: 1.0 };
-let origin = Point { x: 0.0, y: 0.0 };
-
-mypoint.y += 1.0; // mypoint is mutable, and its fields as well
-origin.y += 1.0; // ERROR: assigning to immutable field
 ~~~~
+struct Stack {
+    content: ~[int],
+    head: uint
+}
+~~~~
+
+With a value (say, `mystack`) of such a type in a mutable location, you can do
+`mystack.head += 1`. But in an immutable location, such an assignment to a
+struct without inherited mutability would result in a type error.
 
 `match` patterns destructure structs. The basic syntax is
 `Name { fieldname: pattern, ... }`:

branches/try2/src/libcore/char.rs

@@ -288,16 +288,16 @@ fn test_is_whitespace() {
 
 #[test]
 fn test_to_digit() {
-    assert_eq!(to_digit('0', 10u), Some(0u));
-    assert_eq!(to_digit('1', 2u), Some(1u));
-    assert_eq!(to_digit('2', 3u), Some(2u));
-    assert_eq!(to_digit('9', 10u), Some(9u));
-    assert_eq!(to_digit('a', 16u), Some(10u));
-    assert_eq!(to_digit('A', 16u), Some(10u));
-    assert_eq!(to_digit('b', 16u), Some(11u));
-    assert_eq!(to_digit('B', 16u), Some(11u));
-    assert_eq!(to_digit('z', 36u), Some(35u));
-    assert_eq!(to_digit('Z', 36u), Some(35u));
+    fail_unless!(to_digit('0', 10u) == Some(0u));
+    fail_unless!(to_digit('1', 2u) == Some(1u));
+    fail_unless!(to_digit('2', 3u) == Some(2u));
+    fail_unless!(to_digit('9', 10u) == Some(9u));
+    fail_unless!(to_digit('a', 16u) == Some(10u));
+    fail_unless!(to_digit('A', 16u) == Some(10u));
+    fail_unless!(to_digit('b', 16u) == Some(11u));
+    fail_unless!(to_digit('B', 16u) == Some(11u));
+    fail_unless!(to_digit('z', 36u) == Some(35u));
+    fail_unless!(to_digit('Z', 36u) == Some(35u));
 
     fail_unless!(to_digit(' ', 10u).is_none());
     fail_unless!(to_digit('$', 36u).is_none());
@@ -321,28 +321,28 @@ fn test_is_digit() {
 
 #[test]
 fn test_escape_default() {
-    assert_eq!(escape_default('\n'), ~"\\n");
-    assert_eq!(escape_default('\r'), ~"\\r");
-    assert_eq!(escape_default('\''), ~"\\'");
-    assert_eq!(escape_default('"'), ~"\\\"");
-    assert_eq!(escape_default(' '), ~" ");
-    assert_eq!(escape_default('a'), ~"a");
-    assert_eq!(escape_default('~'), ~"~");
-    assert_eq!(escape_default('\x00'), ~"\\x00");
-    assert_eq!(escape_default('\x1f'), ~"\\x1f");
-    assert_eq!(escape_default('\x7f'), ~"\\x7f");
-    assert_eq!(escape_default('\xff'), ~"\\xff");
-    assert_eq!(escape_default('\u011b'), ~"\\u011b");
-    assert_eq!(escape_default('\U0001d4b6'), ~"\\U0001d4b6");
+    fail_unless!(escape_default('\n') == ~"\\n");
+    fail_unless!(escape_default('\r') == ~"\\r");
+    fail_unless!(escape_default('\'') == ~"\\'");
+    fail_unless!(escape_default('"') == ~"\\\"");
+    fail_unless!(escape_default(' ') == ~" ");
+    fail_unless!(escape_default('a') == ~"a");
+    fail_unless!(escape_default('~') == ~"~");
+    fail_unless!(escape_default('\x00') == ~"\\x00");
+    fail_unless!(escape_default('\x1f') == ~"\\x1f");
+    fail_unless!(escape_default('\x7f') == ~"\\x7f");
+    fail_unless!(escape_default('\xff') == ~"\\xff");
+    fail_unless!(escape_default('\u011b') == ~"\\u011b");
+    fail_unless!(escape_default('\U0001d4b6') == ~"\\U0001d4b6");
 }
 
 
 #[test]
 fn test_escape_unicode() {
-    assert_eq!(escape_unicode('\x00'), ~"\\x00");
-    assert_eq!(escape_unicode('\n'), ~"\\x0a");
-    assert_eq!(escape_unicode(' '), ~"\\x20");
-    assert_eq!(escape_unicode('a'), ~"\\x61");
-    assert_eq!(escape_unicode('\u011b'), ~"\\u011b");
-    assert_eq!(escape_unicode('\U0001d4b6'), ~"\\U0001d4b6");
+    fail_unless!(escape_unicode('\x00') == ~"\\x00");
+    fail_unless!(escape_unicode('\n') == ~"\\x0a");
+    fail_unless!(escape_unicode(' ') == ~"\\x20");
+    fail_unless!(escape_unicode('a') == ~"\\x61");
+    fail_unless!(escape_unicode('\u011b') == ~"\\u011b");
+    fail_unless!(escape_unicode('\U0001d4b6') == ~"\\U0001d4b6");
 }

branches/try2/src/libcore/cmp.rs

@@ -172,10 +172,10 @@ pub pure fn max<T:Ord>(v1: T, v2: T) -> T {
 mod test {
     #[test]
     fn test_int() {
-        assert_eq!(5.cmp(&10), Less);
-        assert_eq!(10.cmp(&5), Greater);
-        assert_eq!(5.cmp(&5), Equal);
-        assert_eq!((-5).cmp(&12), Less);
-        assert_eq!(12.cmp(-5), Greater);
+        fail_unless!(5.cmp(&10) == Less);
+        fail_unless!(10.cmp(&5) == Greater);
+        fail_unless!(5.cmp(&5) == Equal);
+        fail_unless!((-5).cmp(&12) == Less);
+        fail_unless!(12.cmp(-5) == Greater);
     }
 }

branches/try2/src/libcore/condition.rs

@@ -84,6 +84,7 @@ struct Guard<T, U> {
     cond: &'self Condition/&self<T, U>
 }
 
+#[unsafe_destructor]
 impl<T, U> Drop for Guard/&self<T, U> {
     fn finalize(&self) {
         unsafe {

branches/try2/src/libcore/core.rc

@@ -198,7 +198,7 @@ pub use path::WindowsPath;
 pub use path::PosixPath;
 
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
-pub use str::{StrSlice};
+pub use str::{StrSlice, Trimmable};
 pub use container::{Container, Mutable};
 pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};