---

yaml
---
r: 130777
b: refs/heads/master
c: 3ca53d3
h: refs/heads/master
i:
  130775: 6e90217
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6b487ebbc02d7fdf84087add9d139776aac06326
+refs/heads/master: 3ca53d3a100a4466ed91df6d5a696d112db82b68
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6faa4f33a42de32579e02a8d030db920d360e2b5
 refs/heads/try: a2473a89da106f7dd3be86e9d52fe23f43d5bfa5

trunk/Makefile.in

@@ -65,7 +65,6 @@
 #
 #   * `VERBOSE=1` - Print all commands. Use this to see what's going on.
 #   * `RUSTFLAGS=...` - Add compiler flags to all `rustc` invocations
-#   * `JEMALLOC_FLAGS=...` - Pass flags to jemalloc's configure script
 #
 #   * `TESTNAME=...` - Specify the name of tests to run
 #   * `CHECK_IGNORED=1` - Run normally-ignored tests

trunk/configure

@@ -707,7 +707,7 @@ then
             | cut -d ' ' -f 2)
 
         case $CFG_CLANG_VERSION in
-            (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* | 3.6*)
+            (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* )
             step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
             if [ -z "$CC" ]
             then

trunk/mk/main.mk

@@ -90,19 +90,15 @@ endif
 CFG_RUSTC_FLAGS := $(RUSTFLAGS)
 CFG_GCCISH_CFLAGS :=
 CFG_GCCISH_LINK_FLAGS :=
-CFG_JEMALLOC_FLAGS :=
 
 ifdef CFG_DISABLE_OPTIMIZE
   $(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))
   CFG_RUSTC_FLAGS +=
-  CFG_JEMALLOC_FLAGS += --enable-debug
 else
   # The rtopt cfg turns off runtime sanity checks
   CFG_RUSTC_FLAGS += -O --cfg rtopt
 endif
 
-CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
-
 ifdef CFG_DISABLE_DEBUG
   CFG_RUSTC_FLAGS += --cfg ndebug
   CFG_GCCISH_CFLAGS += -DRUST_NDEBUG

trunk/mk/rt.mk

@@ -301,7 +301,7 @@ JEMALLOC_LOCAL_$(1) := $$(JEMALLOC_BUILD_DIR_$(1))/lib/$$(JEMALLOC_REAL_NAME_$(1
 $$(JEMALLOC_LOCAL_$(1)): $$(JEMALLOC_DEPS) $$(MKFILE_DEPS)
 	@$$(call E, make: jemalloc)
 	cd "$$(JEMALLOC_BUILD_DIR_$(1))"; "$(S)src/jemalloc/configure" \
-		$$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ $(CFG_JEMALLOC_FLAGS) \
+		$$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ \
 		--build=$(CFG_BUILD) --host=$(1) \
 		CC="$$(CC_$(1))" \
 		AR="$$(AR_$(1))" \

trunk/src/doc/guide.md

@@ -116,7 +116,7 @@ but also working properly. And printing information to the screen is a pretty
 common thing to do.
 
 The first thing that we need to do is make a file to put our code in. I like
-to make a `projects` directory in my home directory, and keep all my projects
+to make a projects directory in my home directory, and keep all my projects
 there. Rust does not care where your code lives.
 
 This actually leads to one other concern we should address: this tutorial will
@@ -765,7 +765,7 @@ This is a deliberate design decision. While full-program inference is possible,
 languages which have it, like Haskell, often suggest that documenting your
 types explicitly is a best-practice. We agree that forcing functions to declare
 types while allowing for inference inside of function bodies is a wonderful
-sweet spot between full inference and no inference.
+compromise between full inference and no inference.
 
 What about returning a value? Here's a function that adds one to an integer:
 

trunk/src/doc/index.md

@@ -1,55 +1,18 @@
 % Rust Documentation
 
-Welcome to the Rust documentation! You can use the section headings above
-to jump to any particular section.
-
-# Getting Started
-
-If you haven't seen Rust at all yet, the first thing you should read is the [30
-minute intro](intro.html). It will give you an overview of the basic ideas of Rust
-at a high level.
-
-Once you know you really want to learn Rust, the next step is reading [the
-guide](guide.html). It is a lengthy explanation of Rust, its syntax, and its
-concepts. Upon completing the guide, you'll be an intermediate Rust developer,
-and will have a good grasp of the fundamental ideas behind Rust.
-
-# Community & Getting Help
-
-If you need help with something, or just want to talk about Rust with others,
-there's a few places you can do that:
-
-The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/) are the
-fastest way to get help.
-[`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) is
-the general discussion channel, and you'll find people willing to help you with
-any questions you may have.
-
-There are also three specialty channels:
-[`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev)
-and
-[`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev)
-are for game development and operating system development, respectively.
-There's also
-[`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals), which is for discussion of the development of Rust itself.
-
-You can also get help on [Stack
-Overflow](http://stackoverflow.com/questions/tagged/rust). Searching for your
-problem might reveal someone who has asked it before!
-
-There is an active [subreddit](http://reddit.com/r/rust) with lots of
-discussion about Rust.
-
-There is also a [developer forum](http://discuss.rust-lang.org/), where the
-development of Rust itself is discussed.
+<!-- Completely hide the TOC and the section numbers -->
+<style type="text/css">
+#TOC { display: none; }
+.header-section-number { display: none; }
+li {list-style-type: none; }
+</style>
 
+* [A 30-minute Intro to Rust](intro.html)
+* [The Rust tutorial](tutorial.html)  (* [PDF](tutorial.pdf))
+* [The Rust reference manual](rust.html) (* [PDF](rust.pdf))
 
 # Guides
 
-Rust Guides are in-depth looks at a particular topic that's relevant to Rust
-development. If you're trying to figure out how to do something, there may be
-a guide that can help you out:
-
 * [Strings](guide-strings.html)
 * [Pointers](guide-pointers.html)
 * [References and Lifetimes](guide-lifetimes.html)
@@ -61,43 +24,70 @@ a guide that can help you out:
 * [Testing](guide-testing.html)
 * [Rust's Runtime](guide-runtime.html)
 
-# Tools
-
-Rust's still a young language, so there isn't a ton of tooling yet, but the
-tools we have are really nice.
-
-[Cargo](http://crates.io) is Rust's package manager, and its website contains
-lots of good documentation.
-
-[The `rustdoc` manual](rustdoc.html) contains information about Rust's
-documentation tool.
-
 # FAQs
 
-There are questions that are asked quite often, and so we've made FAQs for them:
-
 * [Language Design FAQ](complement-design-faq.html)
 * [Language FAQ](complement-lang-faq.html)
 * [Project FAQ](complement-project-faq.html)
 * [How to submit a bug report](complement-bugreport.html)
 
-# The standard library
-
-You can find function-level documentation for the entire standard library
-[here](std/index.html). There's a list of crates on the left with more specific
-sections, or you can use the search bar at the top to search for something if
-you know its name.
+# Libraries
+
+* [The standard library, `std`](std/index.html)
+
+<!-- force the two lists to be separate -->
+
+* [The `arena` allocation library](arena/index.html)
+* [The `collections` library](collections/index.html)
+* [The `flate` compression library](flate/index.html)
+* [The `fourcc` four-character code library](fourcc/index.html)
+* [The `getopts` argument parsing library](getopts/index.html)
+* [The `glob` file path matching library](glob/index.html)
+* [The `green` M:N runtime library](green/index.html)
+* [The `hexfloat` library for hexadecimal floating-point literals](hexfloat/index.html)
+* [The `libc` bindings](libc/index.html)
+* [The `native` 1:1 threading runtime](native/index.html)
+* [The `num` arbitrary precision numerics library](num/index.html)
+* [The `rand` library for random numbers and distributions](rand/index.html)
+* [The `regex` library for regular expressions](regex/index.html)
+* [The `rustc` compiler](rustc/index.html)
+* [The `rustuv` M:N I/O library](rustuv/index.html)
+* [The `semver` version collation library](semver/index.html)
+* [The `serialize` value encoding/decoding library](serialize/index.html)
+* [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
+* [The `syntax` library, the Rust parser](syntax/index.html)
+* [The `term` terminal-handling library](term/index.html)
+* [The `test` library containing the unit-testing & micro-benchmark framework](test/index.html)
+* [The `time` library](time/index.html)
+* [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
+* [The `url` library](url/index.html)
+* [The `log` library](log/index.html)
+
+# Tooling
+
+* [The `rustdoc` manual](rustdoc.html)
 
 # External documentation
 
-*Note: While these are great resources for learning Rust, they may track a
-particular version of Rust that is likely not exactly the same as that for
-which this documentation was generated.*
+*Note: While these are great resources for learning Rust, they may
+track a particular version of Rust that is likely not exactly the same
+as that for which this documentation was generated.*
 
-* [Rust by Example] - Short examples of common tasks in Rust (tracks the master
-  branch).
-* [Rust for Rubyists] - The first community tutorial for Rust. Tracks the last
-  stable release. Not just for Ruby programmers.
+* [Rust for Rubyists] - An excellent introduction for Rust; not just for Rubyists (tracks the most recent release).
+* [Rust by Example] - Short examples of common tasks in Rust (tracks the master branch).
+* [The Rust wiki](http://github.com/rust-lang/rust/wiki)
 
-[Rust by Example]: http://rustbyexample.com/
 [Rust for Rubyists]: http://www.rustforrubyists.com/
+[Rust by Example]: http://rustbyexample.com/
+
+# Community
+
+* [Reddit](http://reddit.com/r/rust)
+* [Stack Overflow](http://stackoverflow.com/questions/tagged/rust)
+* [Developer Forum](http://discuss.rust-lang.org/)
+* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/):
+    * [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - general discussion
+    * [`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev) - game development
+    * [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals) - compiler and libraries
+    * [`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev) - operating system development
+

trunk/src/doc/rust.md

@@ -3290,19 +3290,17 @@ between `_` and `..` is that the pattern `C(_)` is only type-correct if `C` has
 exactly one argument, while the pattern `C(..)` is type-correct for any enum
 variant `C`, regardless of how many arguments `C` has.
 
-Used inside a vector pattern, `..` stands for any number of elements, when the
-`advanced_slice_patterns` feature gate is turned on. This wildcard can be used
-at most once for a given vector, which implies that it cannot be used to
-specifically match elements that are at an unknown distance from both ends of a
-vector, like `[.., 42, ..]`.  If followed by a variable name, it will bind the
-corresponding slice to the variable.  Example:
+Used inside a vector pattern, `..` stands for any number of elements. This
+wildcard can be used at most once for a given vector, which implies that it
+cannot be used to specifically match elements that are at an unknown distance
+from both ends of a vector, like `[.., 42, ..]`. If followed by a variable name,
+it will bind the corresponding slice to the variable. Example:
 
 ~~~~
-# #![feature(advanced_slice_patterns)]
 fn is_symmetric(list: &[uint]) -> bool {
     match list {
         [] | [_]                   => true,
-        [x, inside.., y] if x == y => is_symmetric(inside),
+        [x, ..inside, y] if x == y => is_symmetric(inside),
         _                          => false
     }
 }
@@ -3566,36 +3564,34 @@ let (a, b) = p;
 assert!(b != "world");
 ~~~~
 
-### Vector, Array, and Slice types
+### Vector types
 
-Rust has three different types for a list of items:
+The vector type constructor represents a homogeneous array of values of a given type.
+A vector has a fixed size.
+(Operations like `vec.push` operate solely on owned vectors.)
+A vector type can be annotated with a _definite_ size, such as `[int, ..10]`.
+Such a definite-sized vector type is a first-class type, since its size is known statically.
+A vector without such a size is said to be of _indefinite_ size,
+and is therefore not a _first-class_ type.
+An indefinite-size vector can only be instantiated through a pointer type,
+such as `&[T]` or `Vec<T>`.
+The kind of a vector type depends on the kind of its element type,
+as with other simple structural types.
 
-* `Vec<T>`, a 'vector'
-* `[T ..N]`, an 'array'
-* `&[T]`, a 'slice'.
+Expressions producing vectors of definite size cannot be evaluated in a
+context expecting a vector of indefinite size; one must copy the
+definite-sized vector contents into a distinct vector of indefinite size.
 
-A vector is a heap-allocated list of `T`. A vector has ownership over the data
-inside of it. It is also able to grow and change in size. It's important to note
-that `Vec<T>` is a library type, it's not actually part of the core language.
+An example of a vector type and its use:
 
-An array has a fixed size, and can be allocated on either the stack or the heap.
-
-A slice is a 'view' into a vector or array. It doesn't own the data it points
-to, it borrows it.
-
-An example of each kind:
-
-```{rust}
-let vec: Vec<int>  = vec![1, 2, 3];
-let arr: [int, ..3] = [1, 2, 3];
-let s: &[int]      = vec.as_slice();
-```
-
-As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The
-`vec!` macro is also part of the standard library, rather than the language.
+~~~~
+let v: &[int] = &[7, 5, 3];
+let i: int = v[2];
+assert!(i == 3);
+~~~~
 
-All in-bounds elements of vectors, arrays, and slices are always initialized,
-and access to a vector, array, or slice is always bounds-checked.
+All in-bounds elements of a vector are always initialized,
+and access to a vector is always bounds-checked.
 
 ### Structure types
 

trunk/src/doc/tutorial.md

@@ -1707,7 +1707,7 @@ let score = match numbers {
     [] => 0,
     [a] => a * 10,
     [a, b] => a * 6 + b * 4,
-    [a, b, c, rest..] => a * 5 + b * 3 + c * 2 + rest.len() as int
+    [a, b, c, ..rest] => a * 5 + b * 3 + c * 2 + rest.len() as int
 };
 ~~~~
 

trunk/src/etc/licenseck.py

@@ -43,15 +43,12 @@
     "libsync/mpmc_bounded_queue.rs", # BSD
     "libsync/mpsc_intrusive.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
-    "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD
     "test/bench/shootout-k-nucleotide.rs", # BSD
     "test/bench/shootout-mandelbrot.rs", # BSD
     "test/bench/shootout-meteor.rs", # BSD
-    "test/bench/shootout-nbody.rs", # BSD
     "test/bench/shootout-pidigits.rs", # BSD
     "test/bench/shootout-regex-dna.rs", # BSD
-    "test/bench/shootout-reverse-complement.rs", # BSD
     "test/bench/shootout-threadring.rs", # BSD
 ]
 

trunk/src/liballoc/heap.rs

@@ -14,7 +14,7 @@
 
 use core::ptr::RawPtr;
 #[cfg(not(test))] use core::raw;
-#[cfg(stage0, not(test))] use util;
+#[cfg(not(test))] use util;
 
 /// Returns a pointer to `size` bytes of memory.
 ///
@@ -119,7 +119,7 @@ unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {
 }
 
 // FIXME: #7496
-#[cfg(stage0, not(test))]
+#[cfg(not(test))]
 #[lang="closure_exchange_malloc"]
 #[inline]
 #[allow(deprecated)]
@@ -134,21 +134,6 @@ unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
     alloc as *mut u8
 }
 
-// FIXME: #7496
-#[cfg(not(stage0), not(test))]
-#[lang="closure_exchange_malloc"]
-#[inline]
-#[allow(deprecated)]
-unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
-                                  align: uint) -> *mut u8 {
-    let p = allocate(size, align);
-
-    let alloc = p as *mut raw::Box<()>;
-    (*alloc).drop_glue = drop_glue;
-
-    alloc as *mut u8
-}
-
 #[cfg(jemalloc)]
 mod imp {
     use core::option::{None, Option};