---

yaml
---
r: 140779
b: refs/heads/try2
c: 8d4d2b0
h: refs/heads/master
i:
  140777: 28ea8f8
  140775: bed1537
v: v3

Author: brendanzab

[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: 5a2f65fb5035627b8fb0b1ce0e927a492d55e3a4
+refs/heads/try2: 8d4d2b00c551301348cc09583498c02fdfbd64d7
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -618,7 +618,7 @@ each of which may have some number of [attributes](#attributes) attached to it.
 
 ~~~~~~~~ {.ebnf .gram}
 item : mod_item | fn_item | type_item | struct_item | enum_item
-     | static_item | trait_item | impl_item | extern_block ;
+     | static_item | trait_item | impl_item | foreign_mod_item ;
 ~~~~~~~~
 
 An _item_ is a component of a crate; some module items can be defined in crate
@@ -752,11 +752,10 @@ link_attr : ident '=' literal ;
 ~~~~~~~~
 
 An _`extern mod` declaration_ specifies a dependency on an external crate.
-The external crate is then bound into the declaring scope
-as the `ident` provided in the `extern_mod_decl`.
+The external crate is then bound into the declaring scope as the `ident` provided in the `extern_mod_decl`.
 
-The external crate is resolved to a specific `soname` at compile time,
-and a runtime linkage requirement to that `soname` is passed to the linker for
+The external crate is resolved to a specific `soname` at compile time, and a
+runtime linkage requirement to that `soname` is passed to the linker for
 loading at runtime. The `soname` is resolved at compile time by scanning the
 compiler's library path and matching the `link_attrs` provided in the
 `use_decl` against any `#link` attributes that were declared on the external
@@ -993,10 +992,10 @@ Thus the return type on `f` only needs to reflect the `if` branch of the conditi
 #### Extern functions
 
 Extern functions are part of Rust's foreign function interface,
-providing the opposite functionality to [external blocks](#external-blocks).
-Whereas external blocks allow Rust code to call foreign code,
-extern functions with bodies defined in Rust code _can be called by foreign
-code_. They are defined in the same way as any other Rust function,
+providing the opposite functionality to [foreign modules](#foreign-modules).
+Whereas foreign modules allow Rust code to call foreign code,
+extern functions with bodies defined in Rust code _can be called by foreign code_.
+They are defined in the same way as any other Rust function,
 except that they have the `extern` modifier.
 
 ~~~
@@ -1012,8 +1011,7 @@ let fptr: *u8 = new_vec;
 ~~~
 
 The primary motivation for extern functions is
-to create callbacks for foreign functions that expect to receive function
-pointers.
+to create callbacks for foreign functions that expect to receive function pointers.
 
 ### Type definitions
 
@@ -1310,61 +1308,64 @@ impl Seq<bool> for u32 {
 }
 ~~~~
 
-### External blocks
+### Foreign modules
 
 ~~~ {.ebnf .gram}
-extern_block_item : "extern" '{' extern_block '} ;
-extern_block : [ foreign_fn ] * ;
+foreign_mod_item : "extern mod" ident '{' foreign_mod '} ;
+foreign_mod : [ foreign_fn ] * ;
 ~~~
 
-External blocks form the basis for Rust's foreign function interface.
-Declarations in an external block describe symbols
-in external, non-Rust libraries.
-
-Functions within external blocks
-are declared in the same way as other Rust functions,
-with the exception that they may not have a body
-and are instead terminated by a semicolon.
+Foreign modules form the basis for Rust's foreign function interface. A
+foreign module describes functions in external, non-Rust
+libraries.
+Functions within foreign modules are declared in the same way as other Rust functions,
+with the exception that they may not have a body and are instead terminated by a semicolon.
 
 ~~~
 # use core::libc::{c_char, FILE};
 # #[nolink]
 
-extern {
+extern mod c {
     fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
 }
 ~~~
 
-Functions within external blocks may be called by Rust code,
-just like functions defined in Rust.
-The Rust compiler automatically translates
-between the Rust ABI and the foreign ABI.
+Functions within foreign modules may be called by Rust code, just like functions defined in Rust.
+The Rust compiler automatically translates between the Rust ABI and the foreign ABI.
+
+The name of the foreign module has special meaning to the Rust compiler in
+that it will treat the module name as the name of a library to link to,
+performing the linking as appropriate for the target platform. The name
+given for the foreign module will be transformed in a platform-specific way
+to determine the name of the library. For example, on Linux the name of the
+foreign module is prefixed with 'lib' and suffixed with '.so', so the
+foreign mod 'rustrt' would be linked to a library named 'librustrt.so'.
 
-A number of [attributes](#attributes) control the behavior of external
-blocks.
+A number of [attributes](#attributes) control the behavior of foreign
+modules.
 
-By default external blocks assume
-that the library they are calling uses the standard C "cdecl" ABI.
-Other ABIs may be specified using the `abi` attribute as in
+By default foreign modules assume that the library they are calling use the
+standard C "cdecl" ABI. Other ABIs may be specified using the `abi`
+attribute as in
 
 ~~~{.xfail-test}
 // Interface to the Windows API
 #[abi = "stdcall"]
-extern { }
+extern mod kernel32 { }
 ~~~
 
-The `link_name` attribute allows the name of the library to be specified.
+The `link_name` attribute allows the default library naming behavior to
+be overridden by explicitly specifying the name of the library.
 
 ~~~{.xfail-test}
 #[link_name = "crypto"]
-extern { }
+extern mod mycrypto { }
 ~~~
 
-The `nolink` attribute tells the Rust compiler
-not to do any linking for the external block.
-This is particularly useful for creating external blocks for libc,
-which tends to not follow standard library naming conventions
-and is linked to all Rust programs anyway.
+The `nolink` attribute tells the Rust compiler not to do any linking for the foreign module.
+This is particularly useful for creating foreign
+modules for libc, which tends to not follow standard library naming
+conventions and is linked to all Rust programs anyway.
 
 ## Attributes
 
@@ -1424,8 +1425,6 @@ names are effectively reserved. Some significant attributes include:
 * The `test` attribute, for marking functions as unit tests.
 * The `allow`, `warn`, `forbid`, and `deny` attributes, for controlling lint checks. Lint checks supported
 by the compiler can be found via `rustc -W help`.
-* The `deriving` attribute, for automatically generating
-  implementations of certain traits.
 
 Other attributes may be added or removed during development of the language.
 
@@ -1527,47 +1526,6 @@ A complete list of the built-in language items follows:
 > **Note:** This list is likely to become out of date. We should auto-generate it
 > from `librustc/middle/lang_items.rs`.
 
-### Deriving
-
-The `deriving` attribute allows certain traits to be automatically
-implemented for data structures. For example, the following will
-create an `impl` for the `Eq` and `Clone` traits for `Foo`, the type
-parameter `T` will be given the `Eq` or `Clone` constraints for the
-appropriate `impl`:
-
-~~~
-#[deriving(Eq, Clone)]
-struct Foo<T> {
-    a: int,
-    b: T
-}
-~~~
-
-The generated `impl` for `Eq` is equivalent to
-
-~~~
-# struct Foo<T> { a: int, b: T }
-impl<T: Eq> Eq for Foo<T> {
-    fn eq(&self, other: &Foo<T>) -> bool {
-        self.a == other.a && self.b == other.b
-    }
-
-    fn ne(&self, other: &Foo<T>) -> bool {
-        self.a != other.a || self.b != other.b
-    }
-}
-~~~
-
-Supported traits for `deriving` are:
-
-* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
-* Serialization: `Encodable`, `Decodable`. These require `std`.
-* `Clone`, to perform deep copies.
-* `IterBytes`, to iterate over the bytes in a data type.
-* `Rand`, to create a random instance of a data type.
-* `ToStr`, to convert to a string. For a type with this instance,
-  `obj.to_str()` has the same output as `fmt!("%?", obj)`.
-
 # Statements and expressions
 
 Rust is _primarily_ an expression language. This means that most forms of

branches/try2/doc/tutorial-ffi.md

@@ -237,8 +237,7 @@ convention to use:
 ~~~~
 #[cfg(target_os = "win32")]
 #[abi = "stdcall"]
-#[link_name = "kernel32"]
-extern {
+extern mod kernel32 {
     fn SetEnvironmentVariableA(n: *u8, v: *u8) -> int;
 }
 ~~~~

branches/try2/doc/tutorial.md

@@ -2290,27 +2290,6 @@ let nonsense = mycircle.radius() * mycircle.area();
 
 > ***Note:*** Trait inheritance does not actually work with objects yet
 
-## Deriving implementations for traits
-
-A small number of traits in `core` and `std` can have implementations
-that can be automatically derived. These instances are specified by
-placing the `deriving` attribute on a data type declaration. For
-example, the following will mean that `Circle` has an implementation
-for `Eq` and can be used with the equality operators, and that a value
-of type `ABC` can be randomly generated and converted to a string:
-
-~~~
-#[deriving(Eq)]
-struct Circle { radius: float }
-
-#[deriving(Rand, ToStr)]
-enum ABC { A, B, C }
-~~~
-
-The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`, `IterBytes`, `Rand` and
-`ToStr`.
-
 # Modules and crates
 
 The Rust namespace is arranged in a hierarchy of modules. Each source

branches/try2/mk/tools.mk

@@ -111,9 +111,6 @@ $$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUST_$(4)):		\
 		$$(TSREQ$(1)_T_$(4)_H_$(3))					\
 		$$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_CORELIB_$(4))	\
 		$$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_STDLIB_$(4))	\
-		$$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTPKG_$(4))	\
-		$$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTI_$(4))		\
-		$$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTDOC_$(4))	\
 		$$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTC_$(4))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@

branches/try2/src/driver/driver.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[no_core];
+extern mod core(vers = "0.7-pre");
+
 #[cfg(rustpkg)]
 extern mod this(name = "rustpkg", vers = "0.7-pre");
 

branches/try2/src/libcore/at_vec.rs

@@ -11,10 +11,8 @@
 //! Managed vectors
 
 use cast::transmute;
-use container::Container;
 use kinds::Copy;
 use old_iter;
-use old_iter::BaseIter;
 use option::Option;
 use sys;
 use uint;

branches/try2/src/libcore/cell.rs

@@ -44,21 +44,21 @@ pub fn empty_cell<T>() -> Cell<T> {
 pub impl<T> Cell<T> {
     /// Yields the value, failing if the cell is empty.
     fn take(&self) -> T {
-        let this = unsafe { transmute_mut(self) };
-        if this.is_empty() {
+        let self = unsafe { transmute_mut(self) };
+        if self.is_empty() {
             fail!(~"attempt to take an empty cell");
         }
 
-        replace(&mut this.value, None).unwrap()
+        replace(&mut self.value, None).unwrap()
     }
 
     /// Returns the value, failing if the cell is full.
     fn put_back(&self, value: T) {
-        let this = unsafe { transmute_mut(self) };
-        if !this.is_empty() {
+        let self = unsafe { transmute_mut(self) };
+        if !self.is_empty() {
             fail!(~"attempt to put a value back into a full cell");
         }
-        this.value = Some(value);
+        self.value = Some(value);
     }
 
     /// Returns true if the cell is empty and false if the cell is full.

branches/try2/src/libcore/comm.rs

@@ -13,15 +13,14 @@ Message passing
 */
 
 use cast::{transmute, transmute_mut};
-use container::Container;
 use either::{Either, Left, Right};
 use kinds::Owned;
 use option::{Option, Some, None};
 use uint;
+use unstable;
 use vec;
-use vec::OwnedVector;
+use unstable::Exclusive;
 use util::replace;
-use unstable::sync::{Exclusive, exclusive};
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
 
@@ -305,7 +304,7 @@ pub struct SharedChan<T> {
 impl<T: Owned> SharedChan<T> {
     /// Converts a `chan` into a `shared_chan`.
     pub fn new(c: Chan<T>) -> SharedChan<T> {
-        SharedChan { ch: exclusive(c) }
+        SharedChan { ch: unstable::exclusive(c) }
     }
 }
 
@@ -578,7 +577,7 @@ impl<T:Owned,
 #[cfg(test)]
 mod test {
     use either::Right;
-    use super::{Chan, Port, oneshot, stream};
+    use super::{Chan, Port, oneshot, recv_one, stream};
 
     #[test]
     fn test_select2() {

branches/try2/src/libcore/core.rc

@@ -68,6 +68,48 @@ they contained the following prologue:
 #[cfg(test)] pub use ops = realcore::ops;
 #[cfg(test)] pub use cmp = realcore::cmp;
 
+/* Reexported core operators */
+
+pub use kinds::{Const, Copy, Owned};
+pub use ops::{Drop};
+pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
+pub use ops::{BitAnd, BitOr, BitXor};
+pub use ops::{Shl, Shr, Index};
+
+
+/* Reexported types and traits */
+
+pub use option::{Option, Some, None};
+pub use result::{Result, Ok, Err};
+
+pub use path::Path;
+pub use path::GenericPath;
+pub use path::WindowsPath;
+pub use path::PosixPath;
+
+pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
+pub use str::{StrSlice};
+pub use container::{Container, Mutable};
+pub use vec::{CopyableVector, ImmutableVector};
+pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
+pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};
+pub use old_iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+pub use old_iter::{CopyableOrderedIter, CopyableNonstrictIter};
+pub use old_iter::{ExtendedMutableIter};
+pub use iter::Times;
+
+pub use num::{Num, NumCast};
+pub use num::{Orderable, Signed, Unsigned, Round};
+pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
+pub use num::{Integer, Fractional, Real, RealExt};
+pub use num::{Bitwise, BitCount, Bounded};
+pub use num::{Primitive, Int, Float};
+
+pub use ptr::Ptr;
+pub use from_str::FromStr;
+pub use to_str::ToStr;
+pub use clone::Clone;
+
 // On Linux, link to the runtime with -lrt.
 #[cfg(target_os = "linux")]
 #[doc(hidden)]
@@ -196,7 +238,6 @@ pub mod util;
 /* Unsupported interfaces */
 
 // Private APIs
-#[path = "unstable/mod.rs"]
 pub mod unstable;
 
 /* For internal use, not exported */