---

yaml
---
r: 49470
b: refs/heads/master
c: 5f2d410
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e7dbe6cd6f40b5360d6121ce9dba9803f2cf3233
+refs/heads/master: 5f2d4102c5dabde915f1f6cb99c38b9274790cda
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea

trunk/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, ... }`:
 

trunk/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) }

trunk/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;

trunk/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) }

trunk/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};