---

yaml
---
r: 77276
b: refs/heads/snap-stage3
c: 8c09865
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: f1132496dddbdd88f321a7919eec3d65136b3f75
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 803f941867d1d68710f211535de69bb30f79f917
+refs/heads/snap-stage3: 8c09865b66f5e2865037e6ce1396ba0a653136e0
 refs/heads/try: ebfe63cd1c0b5d23f7ea60c69b4fde2e30cfd42a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/.gitattributes

@@ -8,6 +8,3 @@ src/rt/msvc/* -whitespace
 src/rt/vg/* -whitespace
 src/rt/linenoise/* -whitespace
 src/rt/jemalloc/**/* -whitespace
-src/rt/jemalloc/include/jemalloc/jemalloc.h.in text eol=lf
-src/rt/jemalloc/include/jemalloc/jemalloc_defs.h.in text eol=lf
-src/rt/jemalloc/include/jemalloc/internal/jemalloc_internal.h.in text eol=lf

branches/snap-stage3/Makefile.in

@@ -96,8 +96,7 @@ ifdef CFG_DISABLE_OPTIMIZE
   $(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))
   CFG_RUSTC_FLAGS +=
 else
-  # The rtopt cfg turns off runtime sanity checks
-  CFG_RUSTC_FLAGS += -O --cfg rtopt
+  CFG_RUSTC_FLAGS += -O
 endif
 
 ifdef CFG_ENABLE_DEBUG

branches/snap-stage3/configure

@@ -739,9 +739,7 @@ do
     make_dir $h/test/doc-tutorial-ffi
     make_dir $h/test/doc-tutorial-macros
     make_dir $h/test/doc-tutorial-borrowed-ptr
-    make_dir $h/test/doc-tutorial-container
     make_dir $h/test/doc-tutorial-tasks
-    make_dir $h/test/doc-tutorial-conditions
     make_dir $h/test/doc-rust
 done
 

branches/snap-stage3/doc/rust.md

@@ -788,7 +788,7 @@ extern mod complicated_mod = "some-file/in/the-rust/path";
 ##### Use declarations
 
 ~~~~~~~~ {.ebnf .gram}
-use_decl : "pub" ? "use" ident [ '=' path
+use_decl : "pub"? "use" ident [ '=' path
                           | "::" path_glob ] ;
 
 path_glob : ident [ "::" path_glob ] ?
@@ -851,38 +851,6 @@ In this example, the module `quux` re-exports all of the public names defined in
 
 Also note that the paths contained in `use` items are relative to the crate root.
 So, in the previous example, the `use` refers to `quux::foo::*`, and not simply to `foo::*`.
-This also means that top-level module declarations should be at the crate root if direct usage
-of the declared modules within `use` items is desired.  It is also possible to use `self` and `super`
-at the beginning of a `use` item to refer to the current and direct parent modules respectively.
-All rules regarding accessing declared modules in `use` declarations applies to both module declarations
-and `extern mod` declarations.
-
-An example of what will and will not work for `use` items:
-~~~~
-# #[allow(unused_imports)];
-use foo::extra;          // good: foo is at the root of the crate
-use foo::baz::foobaz;    // good: foo is at the root of the crate
-
-mod foo {
-    extern mod extra;
-
-    use foo::extra::list;  // good: foo is at crate root
-//  use extra::*;          // bad:  extra is not at the crate root
-    use self::baz::foobaz; // good: self refers to module 'foo'
-    use foo::bar::foobar;  // good: foo is at crate root
-
-    pub mod bar {
-        pub fn foobar() { }
-    }
-
-    pub mod baz {
-        use super::bar::foobar; // good: super refers to module 'foo'
-        pub fn foobaz() { }
-    }
-}
-
-fn main() {}
-~~~~
 
 ### Functions
 
@@ -1038,25 +1006,20 @@ code_. They are defined in the same way as any other Rust function,
 except that they have the `extern` modifier.
 
 ~~~
-// Declares an extern fn, the ABI defaults to "C" 
 extern fn new_vec() -> ~[int] { ~[] }
-
-// Declares an extern fn with "stdcall" ABI
-extern "stdcall" fn new_vec_stdcall() -> ~[int] { ~[] }
 ~~~
 
-Unlike normal functions, extern fns have an `extern "ABI" fn()`.
-This is the same type as the functions declared in an extern
-block.
+Extern functions may not be called from Rust code,
+but Rust code may take their value as a raw `u8` pointer.
 
 ~~~
 # extern fn new_vec() -> ~[int] { ~[] }
-let fptr: extern "C" fn() -> ~[int] = new_vec;
+let fptr: *u8 = new_vec;
 ~~~
 
-Extern functions may be called from Rust code, but
-caution must be taken with respect to the size of the stack
-segment, just as when calling an extern function normally.
+The primary motivation for extern functions is
+to create callbacks for foreign functions that expect to receive function
+pointers.
 
 ### Type definitions
 
@@ -1421,13 +1384,14 @@ between the Rust ABI and the foreign ABI.
 A number of [attributes](#attributes) control the behavior of external
 blocks.
 
-By default external blocks assume that the library they are calling
-uses the standard C "cdecl" ABI.  Other ABIs may be specified using
-an `abi` string, as shown here:
+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
 
 ~~~{.xfail-test}
 // Interface to the Windows API
-extern "stdcall" { }
+#[abi = "stdcall"]
+extern { }
 ~~~
 
 The `link_name` attribute allows the name of the library to be specified.
@@ -1443,12 +1407,6 @@ 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 type of a function
-declared in an extern block
-is `extern "abi" fn(A1, ..., An) -> R`,
-where `A1...An` are the declared types of its arguments
-and `R` is the decalred return type.
-
 ## Attributes
 
 ~~~~~~~~{.ebnf .gram}
@@ -1962,7 +1920,7 @@ it is automatically dereferenced to make the field access possible.
 ### Vector expressions
 
 ~~~~~~~~{.ebnf .gram}
-vec_expr : '[' "mut" ? vec_elems? ']'
+vec_expr : '[' "mut"? vec_elems? ']'
 
 vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 ~~~~~~~~
@@ -2906,16 +2864,17 @@ the vtable pointer for the `T` implementation of `R`, and the pointer value of `
 An example of an object type:
 
 ~~~~~~~~
+# use std::int;
 trait Printable {
-  fn to_string(&self) -> ~str;
+  fn to_str(&self) -> ~str;
 }
 
 impl Printable for int {
-  fn to_string(&self) -> ~str { self.to_str() }
+  fn to_str(&self) -> ~str { int::to_str(*self) }
 }
 
 fn print(a: @Printable) {
-   println(a.to_string());
+   println(a.to_str());
 }
 
 fn main() {