---

yaml
---
r: 51551
b: refs/heads/incoming
c: 5f2d410
h: refs/heads/master
i:
  51549: c04524b
  51547: 21dd54f
  51543: 5a9ad77
  51535: 2d078ce
  51519: af6e0f7
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: e7dbe6cd6f40b5360d6121ce9dba9803f2cf3233
+refs/heads/incoming: 5f2d4102c5dabde915f1f6cb99c38b9274790cda
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/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/incoming/src/libcore/comm.rs

@@ -108,6 +108,9 @@ 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) }
@@ -145,6 +148,9 @@ 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) }
@@ -220,6 +226,9 @@ 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) }
@@ -293,6 +302,9 @@ 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/incoming/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,10 +212,34 @@ 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 */
 
@@ -231,6 +255,15 @@ 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;

branches/incoming/src/libcore/io.rs

@@ -75,6 +75,9 @@ pub trait Reader {
     fn tell(&self) -> uint;
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
 impl Reader for @Reader {
     fn read(&self, bytes: &mut [u8], len: uint) -> uint {
         self.read(bytes, len)
@@ -655,6 +658,9 @@ pub trait Writer {
     fn get_type(&self) -> WriterType;
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
 impl Writer for @Writer {
     fn write(&self, v: &[const u8]) { self.write(v) }
     fn seek(&self, a: int, b: SeekStyle) { self.seek(a, b) }

branches/incoming/src/libcore/prelude.rs

@@ -36,7 +36,7 @@ pub use path::Path;
 pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::Ptr;
-pub use str::{StrSlice, Trimmable, OwnedStr};
+pub use str::{StrSlice, OwnedStr};
 pub use to_bytes::IterBytes;
 pub use to_str::ToStr;
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};