---

yaml
---
r: 138641
b: refs/heads/try2
c: dcd2f73
h: refs/heads/master
i:
  138639: 3276834
v: v3

Author: sp0

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

branches/try2/CONTRIBUTING.md

@@ -11,7 +11,7 @@ You're not off the hook even if you just stick to documentation; code examples i
 Pull requests will be treated as "review requests",
 and we will give feedback we expect to see corrected on [style](https://github.com/mozilla/rust/wiki/Note-style-guide) and substance before pulling.
 Changes contributed via pull request should focus on a single issue at a time, like any other.
-We will not accept pull-requests that try to "sneak" unrelated changes in.
+We will not look accept pull-requests that try to "sneak" unrelated changes in.
 
 Normally, all pull requests must include regression tests (see [Note-testsuite](https://github.com/mozilla/rust/wiki/Note-testsuite)) that test your change.
 Occasionally, a change will be very difficult to test for.

branches/try2/doc/rust.md

@@ -908,11 +908,6 @@ function defined above on `[1, 2]` will instantiate type parameter `T`
 with `int`, and require the closure parameter to have type
 `fn(int)`.
 
-The type parameters can also be explicitly supplied in a trailing
-[path](#paths) component after the function name. This might be necessary
-if there is not sufficient context to determine the type parameters. For
-example, `sys::size_of::<u32>() == 4`.
-
 Since a parameter type is opaque to the generic function, the set of
 operations that can be performed on it is limited. Values of parameter
 type can always be moved, but they can only be copied when the
@@ -1090,15 +1085,6 @@ let p = Point(10, 11);
 let px: int = match p { Point(x, _) => x };
 ~~~~
 
-A _unit-like struct_ is a structure without any fields, defined by leaving off the fields list entirely.
-Such types will have a single value, just like the [unit value `()`](#unit-and-boolean-literals) of the unit type.
-For example:
-
-~~~~
-struct Cookie;
-let c = [Cookie, Cookie, Cookie, Cookie];
-~~~~
-
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated type](#enumerated-types) as well as a set of *constructors*,
@@ -1604,8 +1590,7 @@ struct_expr : expr_path '{' ident ':' expr
                       [ ',' ident ':' expr ] *
                       [ ".." expr ] '}' |
               expr_path '(' expr
-                      [ ',' expr ] * ')' |
-              expr_path
+                      [ ',' expr ] * ')'
 ~~~~~~~~
 
 There are several forms of structure expressions.
@@ -1615,28 +1600,23 @@ providing the field values of a new instance of the structure.
 A field name can be any identifier, and is separated from its value expression by a colon.
 To indicate that a field is mutable, the `mut` keyword is written before its name.
 
-A _tuple structure expression_ consists of the [path](#paths) of a [structure item](#structures),
+A _tuple structure expression_ constists of the [path](#paths) of a [structure item](#structures),
 followed by a parenthesized list of one or more comma-separated expressions
 (in other words, the path of a structured item followed by a tuple expression).
 The structure item must be a tuple structure item.
 
-A _unit-like structure expression_ consists only of the [path](#paths) of a [structure item](#structures).
-
 The following are examples of structure expressions:
 
 ~~~~
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
 # mod game { pub struct User { name: &str, age: uint, score: uint } }
-# struct Cookie; fn some_fn<T>(t: T) {}
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
 let u = game::User {name: "Joe", age: 35u, score: 100_000};
-some_fn::<Cookie>(Cookie);
 ~~~~
 
 A structure expression forms a new value of the named structure type.
-Note that for a given *unit-like* structure type, this will always be the same value.
 
 A structure expression can terminate with the syntax `..` followed by an expression to denote a functional update.
 The expression following `..` (the base) must be of the same structure type as the new structure type being formed.
@@ -2060,14 +2040,12 @@ an optional reference slot to serve as the function's output, bound to the
 `lval` on the right hand side of the call. If the function eventually returns,
 then the expression completes.
 
-Some examples of call expressions:
+An example of a call expression:
 
 ~~~~
 # fn add(x: int, y: int) -> int { 0 }
-# use core::from_str::FromStr::from_str;
 
 let x: int = add(1, 2);
-let pi = from_str::<f32>("3.14");
 ~~~~
 
 ### Lambda expressions
@@ -2665,10 +2643,7 @@ the resulting `struct` value will always be laid out in memory in the order spec
 The fields of a `struct` may be qualified by [visibility modifiers](#visibility-modifiers),
 to restrict access to implementation-private data in a structure.
 
-A _tuple struct_ type is just like a structure type, except that the fields are anonymous.
-
-A _unit-like struct_ type is like a structure type, except that it has no fields.
-The one value constructed by the associated [structure expression](#structure-expression) is the only value that inhabits such a type.
+A `tuple struct` type is just like a structure type, except that the fields are anonymous.
 
 ### Enumerated types
 

branches/try2/src/libcore/at_vec.rs

@@ -183,7 +183,7 @@ pub mod raw {
     use at_vec::{capacity, rustrt};
     use cast::transmute;
     use libc;
-    use unstable::intrinsics::{move_val_init};
+    use private::intrinsics::{move_val_init};
     use ptr::addr_of;
     use ptr;
     use sys;

branches/try2/src/libcore/cleanup.rs

@@ -154,7 +154,7 @@ fn debug_mem() -> bool {
 #[cfg(notest)]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
-    use unstable::lang::local_free;
+    use rt::local_free;
     use io::WriterUtil;
     use io;
     use libc;

branches/try2/src/libcore/comm.rs

@@ -12,7 +12,7 @@ use either::{Either, Left, Right};
 use kinds::Owned;
 use option;
 use option::{Option, Some, None, unwrap};
-use unstable;
+use private;
 use vec;
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
@@ -242,7 +242,7 @@ impl<T: Owned> Peekable<T> for PortSet<T> {
 }
 
 /// A channel that can be shared between many senders.
-pub type SharedChan<T> = unstable::Exclusive<Chan<T>>;
+pub type SharedChan<T> = private::Exclusive<Chan<T>>;
 
 impl<T: Owned> GenericChan<T> for SharedChan<T> {
     fn send(x: T) {
@@ -268,7 +268,7 @@ impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
 
 /// Converts a `chan` into a `shared_chan`.
 pub fn SharedChan<T:Owned>(c: Chan<T>) -> SharedChan<T> {
-    unstable::exclusive(c)
+    private::exclusive(c)
 }
 
 /// Receive a message from one of two endpoints.

branches/try2/src/libcore/core.rc

@@ -225,13 +225,11 @@ pub const debug : u32 = 4_u32;
 
 /* Unsupported interfaces */
 
+// The runtime interface used by the compiler
+#[cfg(notest)] pub mod rt;
 // Private APIs
-pub mod unstable;
-// NOTE: Remove after snapshot
-#[cfg(stage0)]
-pub mod private {
-    pub use super::unstable::extfmt;
-}
+pub mod private;
+
 
 /* For internal use, not exported */
 

branches/try2/src/libcore/num/f32.rs

@@ -18,7 +18,7 @@ use num::strconv;
 use num;
 use ops;
 use option::Option;
-use unstable::intrinsics::floorf32;
+use private::intrinsics::floorf32;
 use from_str;
 use to_str;
 

branches/try2/src/libcore/num/f64.rs

@@ -19,7 +19,7 @@ use num::strconv;
 use num;
 use ops;
 use option::Option;
-use unstable::intrinsics::floorf64;
+use private::intrinsics::floorf64;
 use to_str;
 use from_str;
 

branches/try2/src/libcore/os.rs

@@ -35,6 +35,7 @@ use libc::{mode_t, pid_t, FILE};
 use option;
 use option::{Some, None};
 use prelude::*;
+use private;
 use ptr;
 use str;
 use task;
@@ -144,8 +145,8 @@ This uses a per-runtime lock to serialize access.
 FIXME #4726: It would probably be appropriate to make this a real global
 */
 fn with_env_lock<T>(f: &fn() -> T) -> T {
-    use unstable::global::global_data_clone_create;
-    use unstable::{Exclusive, exclusive};
+    use private::global::global_data_clone_create;
+    use private::{Exclusive, exclusive};
 
     struct SharedValue(());
     type ValueMutex = Exclusive<SharedValue>;

branches/try2/src/libcore/pipes.rs

@@ -91,9 +91,9 @@ use libc;
 use option;
 use option::{None, Option, Some, unwrap};
 use pipes;
-use unstable::intrinsics;
+use private::intrinsics;
 use ptr;
-use unstable;
+use private;
 use task;
 use vec;
 

branches/try2/src/libcore/prelude.rs

@@ -69,7 +69,7 @@ pub use option;
 pub use os;
 pub use path;
 pub use comm;
-pub use unstable;
+pub use private;
 pub use ptr;
 pub use rand;
 pub use result;

branches/try2/src/libcore/unstable.rs renamed to branches/try2/src/libcore/private.rs

@@ -22,23 +22,20 @@ use task;
 use task::{TaskBuilder, atomically};
 use uint;
 
-#[path = "unstable/at_exit.rs"]
+#[path = "private/at_exit.rs"]
 pub mod at_exit;
-#[path = "unstable/global.rs"]
+#[path = "private/global.rs"]
 pub mod global;
-#[path = "unstable/finally.rs"]
+#[path = "private/finally.rs"]
 pub mod finally;
-#[path = "unstable/weak_task.rs"]
+#[path = "private/weak_task.rs"]
 pub mod weak_task;
-#[path = "unstable/exchange_alloc.rs"]
+#[path = "private/exchange_alloc.rs"]
 pub mod exchange_alloc;
-#[path = "unstable/intrinsics.rs"]
+#[path = "private/intrinsics.rs"]
 pub mod intrinsics;
-#[path = "unstable/extfmt.rs"]
+#[path = "private/extfmt.rs"]
 pub mod extfmt;
-#[path = "unstable/lang.rs"]
-#[cfg(notest)]
-pub mod lang;
 
 extern mod rustrt {
     pub unsafe fn rust_create_little_lock() -> rust_little_lock;
@@ -315,7 +312,7 @@ pub mod tests {
     use cell::Cell;
     use comm;
     use option;
-    use super::exclusive;
+    use private::exclusive;
     use result;
     use task;
     use uint;

branches/try2/src/libcore/unstable/at_exit.rs renamed to branches/try2/src/libcore/private/at_exit.rs

@@ -14,7 +14,7 @@ use c_malloc = libc::malloc;
 use c_free = libc::free;
 use managed::raw::{BoxHeaderRepr, BoxRepr};
 use cast::transmute;
-use unstable::intrinsics::{atomic_xadd,atomic_xsub};
+use private::intrinsics::{atomic_xadd,atomic_xsub};
 use ptr::null;
 use intrinsic::TyDesc;
 

branches/try2/src/libcore/unstable/exchange_alloc.rs renamed to branches/try2/src/libcore/private/exchange_alloc.rs

@@ -32,11 +32,11 @@ use libc::{c_void, uintptr_t};
 use option::{Option, Some, None};
 use ops::Drop;
 use pipes;
-use unstable::{Exclusive, exclusive};
-use unstable::{SharedMutableState, shared_mutable_state};
-use unstable::{get_shared_immutable_state};
-use unstable::at_exit::at_exit;
-use unstable::intrinsics::atomic_cxchg;
+use private::{Exclusive, exclusive};
+use private::{SharedMutableState, shared_mutable_state};
+use private::{get_shared_immutable_state};
+use private::at_exit::at_exit;
+use private::intrinsics::atomic_cxchg;
 use hashmap::linear::LinearMap;
 use sys::Closure;
 use task::spawn;

branches/try2/src/libcore/unstable/extfmt.rs renamed to branches/try2/src/libcore/private/extfmt.rs

@@ -24,9 +24,9 @@ use comm::{Port, Chan, SharedChan, GenericChan, GenericPort};
 use hashmap::linear::LinearMap;
 use ops::Drop;
 use option::{Some, None, swap_unwrap};
-use unstable::at_exit::at_exit;
-use unstable::finally::Finally;
-use unstable::global::global_data_clone_create;
+use private::at_exit::at_exit;
+use private::finally::Finally;
+use private::global::global_data_clone_create;
 use task::rt::{task_id, get_task_id};
 use task::{Task, task, spawn};
 

branches/try2/src/libcore/unstable/finally.rs renamed to branches/try2/src/libcore/private/finally.rs

@@ -14,7 +14,7 @@ use cast;
 use cmp::{Eq, Ord};
 use libc;
 use libc::{c_void, size_t};
-use unstable::intrinsics::{memmove32,memmove64};
+use private::intrinsics::{memmove32,memmove64};
 use ptr;
 use str;
 use sys;

branches/try2/src/libcore/unstable/global.rs renamed to branches/try2/src/libcore/private/global.rs

@@ -15,11 +15,14 @@ use libc::{c_char, c_uchar, c_void, size_t, uintptr_t, c_int};
 use managed::raw::BoxRepr;
 use str;
 use sys;
-use unstable::exchange_alloc;
+use private::exchange_alloc;
 use cast::transmute;
 
 use gc::{cleanup_stack_for_failure, gc, Word};
 
+#[allow(non_camel_case_types)]
+pub type rust_task = c_void;
+
 #[cfg(target_word_size = "32")]
 pub const FROZEN_BIT: uint = 0x80000000;
 #[cfg(target_word_size = "64")]

branches/try2/src/libcore/unstable/intrinsics.rs renamed to branches/try2/src/libcore/private/intrinsics.rs

@@ -19,7 +19,11 @@ use prelude::*;
 use task::rt;
 use task::local_data::LocalDataKey;
 
-use super::rt::rust_task;
+#[cfg(notest)]
+use rt::rust_task;
+#[cfg(test)]
+#[allow(non_camel_case_types)]
+type rust_task = libc::c_void;
 
 pub trait LocalData { }
 impl<T:Durable> LocalData for @T { }