---

yaml
---
r: 139195
b: refs/heads/try2
c: b6f9aa1
h: refs/heads/master
i:
  139193: 9a04047
  139191: 2859dff
v: v3

Author: bors

[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: 94327d00c6a5329e510ae364850fa34cd758b83c
+refs/heads/try2: b6f9aa1fd75f0e9468b3bb9ee10a95d18c40b567
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial.md

@@ -579,21 +579,30 @@ 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`.
 
-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).
-
 ~~~~
-struct Stack {
-    content: ~[int],
-    head: uint
+struct Point {
+    x: float,
+    y: float
 }
 ~~~~
 
-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
+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
+~~~~
+
 `match` patterns destructure structs. The basic syntax is
 `Name { fieldname: pattern, ... }`:
 

branches/try2/mk/install.mk

@@ -113,11 +113,6 @@ install-host: $(CSREQ$(ISTAGE)_T_$(CFG_BUILD_TRIPLE)_H_$(CFG_BUILD_TRIPLE))
 	$(Q)$(call INSTALL,$(HB2),$(PHB),rustdoc$(X_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL,$(HB2),$(PHB),rusti$(X_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL,$(HB2),$(PHB),rust$(X_$(CFG_BUILD_TRIPLE)))
-	$(Q)$(call INSTALL,$(HL),$(PHL),$(CFG_LIBRUSTC_$(CFG_BUILD_TRIPLE)))
-	$(Q)$(call INSTALL,$(HL),$(PHL),$(CFG_LIBRUSTPKG_$(CFG_BUILD_TRIPLE)))
-	$(Q)$(call INSTALL,$(HL),$(PHL),$(CFG_LIBRUSTDOC_$(CFG_BUILD_TRIPLE)))
-	$(Q)$(call INSTALL,$(HL),$(PHL),$(CFG_LIBRUSTI_$(CFG_BUILD_TRIPLE)))
-	$(Q)$(call INSTALL,$(HL),$(PHL),$(CFG_LIBRUST_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL_LIB,$(HL),$(PHL),$(CORELIB_GLOB_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL_LIB,$(HL),$(PHL),$(STDLIB_GLOB_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL_LIB,$(HL),$(PHL),$(LIBRUSTC_GLOB_$(CFG_BUILD_TRIPLE)))
@@ -142,11 +137,6 @@ uninstall:
 	$(Q)rm -f $(PHB)/rust$(X_$(CFG_BUILD_TRIPLE))
 	$(Q)rm -f $(PHB)/rustdoc$(X_$(CFG_BUILD_TRIPLE))
 	$(Q)rm -f $(PHL)/$(CFG_RUSTLLVM_$(CFG_BUILD_TRIPLE))
-	$(Q)rm -f $(PHL)/$(CFG_LIBRUSTPKG_$(CFG_BUILD_TRIPLE))
-	$(Q)rm -f $(PHL)/$(CFG_LIBRUSTC_$(CFG_BUILD_TRIPLE))
-	$(Q)rm -f $(PHL)/$(CFG_LIBRUSTDOC_$(CFG_BUILD_TRIPLE))
-	$(Q)rm -f $(PHL)/$(CFG_LIBRUSTI_$(CFG_BUILD_TRIPLE))
-	$(Q)rm -f $(PHL)/$(CFG_LIBRUST_$(CFG_BUILD_TRIPLE))
 	$(Q)rm -f $(PHL)/$(CFG_RUNTIME_$(CFG_BUILD_TRIPLE))
 	$(Q)for i in \
           $(call HOST_LIB_FROM_HL_GLOB,$(CORELIB_GLOB_$(CFG_BUILD_TRIPLE))) \

branches/try2/src/compiletest/common.rs

@@ -10,7 +10,7 @@
 
 use core::prelude::*;
 
-#[deriving_eq]
+#[deriving(Eq)]
 pub enum mode {
     mode_compile_fail,
     mode_run_fail,

branches/try2/src/compiletest/runtest.rs

@@ -267,7 +267,7 @@ fn run_debuginfo_test(config: config, props: TestProps, testfile: &Path) {
         // check if each line in props.check_lines appears in the
         // output (in order)
         let mut i = 0u;
-        for str::lines(ProcRes.stdout).each |line| {
+        for str::lines_each(ProcRes.stdout) |line| {
             if props.check_lines[i].trim() == line.trim() {
                 i += 1u;
             }
@@ -297,8 +297,8 @@ fn check_error_patterns(props: TestProps,
     let mut next_err_idx = 0u;
     let mut next_err_pat = props.error_patterns[next_err_idx];
     let mut done = false;
-    for str::split_char(ProcRes.stderr, '\n').each |line| {
-        if str::contains(*line, next_err_pat) {
+    for str::lines_each(ProcRes.stderr) |line| {
+        if str::contains(line, next_err_pat) {
             debug!("found error pattern %s", next_err_pat);
             next_err_idx += 1u;
             if next_err_idx == vec::len(props.error_patterns) {
@@ -347,15 +347,15 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
     //    filename:line1:col1: line2:col2: *warning:* msg
     // where line1:col1: is the starting point, line2:col2:
     // is the ending point, and * represents ANSI color codes.
-    for str::split_char(ProcRes.stderr, '\n').each |line| {
+    for str::lines_each(ProcRes.stderr) |line| {
         let mut was_expected = false;
         for vec::eachi(expected_errors) |i, ee| {
             if !found_flags[i] {
                 debug!("prefix=%s ee.kind=%s ee.msg=%s line=%s",
-                       prefixes[i], ee.kind, ee.msg, *line);
-                if (str::starts_with(*line, prefixes[i]) &&
-                    str::contains(*line, ee.kind) &&
-                    str::contains(*line, ee.msg)) {
+                       prefixes[i], ee.kind, ee.msg, line);
+                if (str::starts_with(line, prefixes[i]) &&
+                    str::contains(line, ee.kind) &&
+                    str::contains(line, ee.msg)) {
                     found_flags[i] = true;
                     was_expected = true;
                     break;
@@ -364,13 +364,13 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         }
 
         // ignore this msg which gets printed at the end
-        if str::contains(*line, ~"aborting due to") {
+        if str::contains(line, ~"aborting due to") {
             was_expected = true;
         }
 
-        if !was_expected && is_compiler_error_or_warning(*line) {
+        if !was_expected && is_compiler_error_or_warning(str::from_slice(line)) {
             fatal_ProcRes(fmt!("unexpected compiler error or warning: '%s'",
-                               *line),
+                               line),
                           ProcRes);
         }
     }

branches/try2/src/libcore/char.rs

@@ -288,16 +288,16 @@ fn test_is_whitespace() {
 
 #[test]
 fn test_to_digit() {
-    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));
+    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(' ', 10u).is_none());
     fail_unless!(to_digit('$', 36u).is_none());
@@ -321,28 +321,28 @@ fn test_is_digit() {
 
 #[test]
 fn test_escape_default() {
-    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");
+    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");
 }
 
 
 #[test]
 fn test_escape_unicode() {
-    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");
+    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");
 }

branches/try2/src/libcore/cmp.rs

@@ -37,7 +37,7 @@ pub trait Eq {
     pure fn ne(&self, other: &Self) -> bool;
 }
 
-#[deriving_eq]
+#[deriving(Eq)]
 pub enum Ordering { Less, Equal, Greater }
 
 /// Trait for types that form a total order
@@ -172,10 +172,10 @@ pub pure fn max<T:Ord>(v1: T, v2: T) -> T {
 mod test {
     #[test]
     fn test_int() {
-        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);
+        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);
     }
 }

branches/try2/src/libcore/comm.rs

@@ -108,9 +108,6 @@ pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
 
 // Add an inherent method so that imports of GenericChan are not
 // required.
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
 pub impl<T: Owned> Chan<T> {
     fn send(&self, x: T) { chan_send(self, x) }
     fn try_send(&self, x: T) -> bool { chan_try_send(self, x) }
@@ -148,9 +145,6 @@ fn chan_try_send<T:Owned>(self: &Chan<T>, x: T) -> bool {
 }
 
 // Use an inherent impl so that imports are not required:
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
 pub impl<T: Owned> Port<T> {
     fn recv(&self) -> T { port_recv(self) }
     fn try_recv(&self) -> Option<T> { port_try_recv(self) }
@@ -226,9 +220,6 @@ pub fn PortSet<T: Owned>() -> PortSet<T>{
 }
 
 // Use an inherent impl so that imports are not required:
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
 pub impl<T:Owned> PortSet<T> {
     fn recv(&self) -> T { port_set_recv(self) }
     fn try_recv(&self) -> Option<T> { port_set_try_recv(self) }
@@ -302,9 +293,6 @@ pure fn port_set_peek<T:Owned>(self: &PortSet<T>) -> bool {
 /// A channel that can be shared between many senders.
 pub type SharedChan<T> = unstable::Exclusive<Chan<T>>;
 
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
 pub impl<T: Owned> SharedChan<T> {
     fn send(&self, x: T) { shared_chan_send(self, x) }
     fn try_send(&self, x: T) -> bool { shared_chan_try_send(self, x) }

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, Trimmable};
+pub use str::{StrSlice};
 pub use container::{Container, Mutable};
 pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
@@ -212,34 +212,10 @@ pub use to_str::ToStr;
 pub use clone::Clone;
 
 
-/*
- * Export the log levels as global constants. Higher levels mean
- * more-verbosity. Error is the bottom level, default logging level is
- * warn-and-below.
- */
-/// The error log level
-#[cfg(stage0)]
-pub const error : u32 = 1_u32;
-/// The warning log level
-#[cfg(stage0)]
-pub const warn : u32 = 2_u32;
-/// The info log level
-#[cfg(stage0)]
-pub const info : u32 = 3_u32;
-/// The debug log level
-#[cfg(stage0)]
-pub const debug : u32 = 4_u32;
-
-
 /* Unsupported interfaces */
 
 // Private APIs
 pub mod unstable;
-// NOTE: Remove after snapshot
-#[cfg(stage0)]
-pub mod private {
-    pub use super::unstable::extfmt;
-}
 
 /* For internal use, not exported */
 
@@ -255,15 +231,6 @@ pub mod rt;
 // can be resolved within libcore.
 #[doc(hidden)]
 pub mod core {
-    #[cfg(stage0)]
-    pub const error : u32 = 1_u32;
-    #[cfg(stage0)]
-    pub const warn : u32 = 2_u32;
-    #[cfg(stage0)]
-    pub const info : u32 = 3_u32;
-    #[cfg(stage0)]
-    pub const debug : u32 = 4_u32;
-
     pub use cmp;
     pub use condition;
     pub use option;