---

yaml
---
r: 130803
b: refs/heads/master
c: ba43f7b
h: refs/heads/master
i:
  130801: 01c09c1
  130799: 61ee907
v: v3

Author: spernsteiner

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4049a4da794197e802f680d3c3a0b9ae4a69ccf5
+refs/heads/master: ba43f7bc8c81e595182abdf1698f0a19187c11b5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6faa4f33a42de32579e02a8d030db920d360e2b5
 refs/heads/try: a2473a89da106f7dd3be86e9d52fe23f43d5bfa5

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/dist.mk

@@ -123,7 +123,7 @@ PKG_EXE = dist/$(PKG_NAME)-install.exe
 $(PKG_EXE): rust.iss modpath.iss upgrade.iss LICENSE.txt rust-logo.ico \
             $(CSREQ3_T_$(CFG_BUILD)_H_$(CFG_BUILD)) \
             dist-prepare-win
-	$(CFG_PYTHON) $(S)src/etc/copy-runtime-deps.py tmp/dist/win/bin $(CFG_BUILD)
+	$(CFG_PYTHON) $(S)src/etc/copy-runtime-deps.py tmp/dist/win/bin
 	@$(call E, ISCC: $@)
 	$(Q)"$(CFG_ISCC)" $<
 

trunk/mk/reconfig.mk

@@ -15,7 +15,11 @@ rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) \
 
 ifndef CFG_DISABLE_MANAGE_SUBMODULES
 # This is a pretty expensive operation but I don't see any way to avoid it
-NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && "$(CFG_GIT)" submodule status | grep -c '^\(+\|-\)')
+# NB: This only looks for '+' status (wrong commit checked out), not '-' status
+# (nothing checked out at all).  `./configure --{llvm,jemalloc,libuv}-root`
+# will explicitly deinitialize the corresponding submodules, and we don't
+# want to force constant rebuilds in that case.
+NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && "$(CFG_GIT)" submodule status | grep -c '^+')
 else
 NEED_GIT_RECONFIG=0
 endif

trunk/src/doc/guide-strings.md

@@ -92,33 +92,9 @@ fn foo(s: String) {
 ```
 
 If you have good reason. It's not polite to hold on to ownership you don't
-need, and it can make your lifetimes more complex.
-
-## Generic functions
-
-To write a function that's generic over types of strings, use [the `Str`
-trait](http://doc.rust-lang.org/std/str/trait.Str.html):
-
-```{rust}
-fn some_string_length<T: Str>(x: T) -> uint {
-        x.as_slice().len()
-}
-
-fn main() {
-    let s = "Hello, world";
-
-    println!("{}", some_string_length(s));
-
-    let s = "Hello, world".to_string();
-
-    println!("{}", some_string_length(s));
-}
-```
-
-Both of these lines will print `12`. 
-
-The only method that the `Str` trait has is `as_slice()`, which gives you
-access to a `&str` value from the underlying string.
+need, and it can make your lifetimes more complex. Furthermore, you can pass
+either kind of string into `foo` by using `.as_slice()` on any `String` you
+need to pass in, so the `&str` version is more flexible.
 
 ## Comparisons
 
@@ -145,65 +121,6 @@ fn compare(string: String) {
 Converting a `String` to a `&str` is cheap, but converting the `&str` to a
 `String` involves an allocation.
 
-## Indexing strings
-
-You may be tempted to try to access a certain character of a `String`, like
-this:
-
-```{rust,ignore}
-let s = "hello".to_string();
-
-println!("{}", s[0]);
-```
-
-This does not compile. This is on purpose. In the world of UTF-8, direct
-indexing is basically never what you want to do. The reason is that each
-character can be a variable number of bytes. This means that you have to iterate
-through the characters anyway, which is a O(n) operation. 
-
-To iterate over a string, use the `graphemes()` method on `&str`:
-
-```{rust}
-let s = "αἰθήρ";
-
-for l in s.graphemes(true) {
-    println!("{}", l);
-}
-```
-
-Note that `l` has the type `&str` here, since a single grapheme can consist of
-multiple codepoints, so a `char` wouldn't be appropriate.
-
-This will print out each character in turn, as you'd expect: first "α", then
-"ἰ", etc. You can see that this is different than just the individual bytes.
-Here's a version that prints out each byte:
-
-```{rust}
-let s = "αἰθήρ";
-
-for l in s.bytes() {
-    println!("{}", l);
-}
-```
-
-This will print:
-
-```{notrust,ignore}
-206
-177
-225
-188
-176
-206
-184
-206
-174
-207
-129
-```
-
-Many more bytes than graphemes!
-
 # Other Documentation
 
 * [the `&str` API documentation](/std/str/index.html)

trunk/src/doc/guide.md

@@ -150,7 +150,7 @@ in your file name, use an underscore. `hello_world.rs` versus `goodbye.rs`.
 
 Now that you've got your file open, type this in:
 
-```{rust}
+```
 fn main() {
     println!("Hello, world!");
 }
@@ -166,7 +166,7 @@ Hello, world!
 
 Success! Let's go over what just happened in detail.
 
-```{rust}
+```
 fn main() {
 
 }
@@ -186,7 +186,7 @@ declaration, with one space in between.
 
 Next up is this line:
 
-```{rust}
+```
     println!("Hello, world!");
 ```
 
@@ -520,8 +520,10 @@ error: aborting due to previous error
 Could not compile `hello_world`.
 ```
 
-Rust will not let us use a value that has not been initialized. Next, let's
-talk about this stuff we've added to `println!`.
+Rust will not let us use a value that has not been initialized. So why let us
+declare a binding without initializing it? You'd think our first example would
+have errored. Well, Rust is smarter than that. Before we get to that, let's talk
+about this stuff we've added to `println!`.
 
 If you include two curly braces (`{}`, some call them moustaches...) in your
 string to print, Rust will interpret this as a request to interpolate some sort
@@ -536,6 +538,12 @@ format in a more detailed manner, there are a [wide number of options
 available](std/fmt/index.html). For now, we'll just stick to the default:
 integers aren't very complicated to print.
 
+So, we've cleared up all of the confusion around bindings, with one exception:
+why does Rust let us declare a variable binding without an initial value if we
+must initialize the binding before we use it? And how does it know that we have
+or have not initialized the binding? For that, we need to learn our next
+concept: `if`.
+
 # If
 
 Rust's take on `if` is not particularly complex, but it's much more like the
@@ -562,7 +570,7 @@ the block is executed. If it's `false`, then it is not.
 
 If you want something to happen in the `false` case, use an `else`:
 
-```{rust}
+```
 let x = 5i;
 
 if x == 5i {
@@ -575,7 +583,7 @@ if x == 5i {
 This is all pretty standard. However, you can also do this:
 
 
-```{rust}
+```
 let x = 5i;
 
 let y = if x == 5i {
@@ -587,7 +595,7 @@ let y = if x == 5i {
 
 Which we can (and probably should) write like this:
 
-```{rust}
+```
 let x = 5i;
 
 let y = if x == 5i { 10i } else { 15i };
@@ -644,7 +652,7 @@ every line of Rust code you see.
 What is this exception that makes us say 'almost?' You saw it already, in this
 code:
 
-```{rust}
+```
 let x = 5i;
 
 let y: int = if x == 5i { 10i } else { 15i };
@@ -990,7 +998,7 @@ notation: `origin.x`.
 The values in structs are immutable, like other bindings in Rust. However, you
 can use `mut` to make them mutable:
 
-```{rust}
+```rust
 struct Point {
     x: int,
     y: int,
@@ -1014,7 +1022,7 @@ called a **tuple struct**. Tuple structs do have a name, but their fields
 don't:
 
 
-```{rust}
+```
 struct Color(int, int, int);
 struct Point(int, int, int);
 ```
@@ -1029,7 +1037,7 @@ let origin = Point(0, 0, 0);
 It is almost always better to use a struct than a tuple struct. We would write
 `Color` and `Point` like this instead:
 
-```{rust}
+```rust
 struct Color {
     red: int,
     blue: int,
@@ -1050,7 +1058,7 @@ There _is_ one case when a tuple struct is very useful, though, and that's a
 tuple struct with only one element. We call this a 'newtype,' because it lets
 you create a new type that's a synonym for another one:
 
-```{rust}
+```
 struct Inches(int);
 
 let length = Inches(10);
@@ -1167,7 +1175,7 @@ what's the solution?
 Rust has a keyword, `match`, that allows you to replace complicated `if`/`else`
 groupings with something more powerful. Check it out:
 
-```{rust}
+```rust
 let x = 5i;
 
 match x {
@@ -1408,7 +1416,7 @@ We now loop forever with `loop`, and use `break` to break out early.
 `continue` is similar, but instead of ending the loop, goes to the next
 iteration: This will only print the odd numbers:
 
-```{rust}
+```
 for x in range(0i, 10i) {
     if x % 2 == 0 { continue; }
 
@@ -4123,7 +4131,7 @@ the ability to use this **method call syntax** via the `impl` keyword.
 
 Here's how it works:
 
-```{rust}
+```
 struct Circle {
     x: f64,
     y: f64,
@@ -4162,7 +4170,7 @@ multiplications later, and we have our area.
 You can also define methods that do not take a `self` parameter. Here's a
 pattern that's very common in Rust code:
 
-```{rust}
+```
 struct Circle {
     x: f64,
     y: f64,

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
     }
 }

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/copy-runtime-deps.py

@@ -12,13 +12,13 @@
 
 import snapshot, sys, os, shutil
 
-def copy_runtime_deps(dest_dir, triple):
-    for path in snapshot.get_winnt_runtime_deps(snapshot.get_platform(triple)):
+def copy_runtime_deps(dest_dir):
+    for path in snapshot.get_winnt_runtime_deps():
         shutil.copy(path, dest_dir)
 
     lic_dest = os.path.join(dest_dir, "third-party")
     if os.path.exists(lic_dest):
         shutil.rmtree(lic_dest) # copytree() won't overwrite existing files
     shutil.copytree(os.path.join(os.path.dirname(__file__), "third-party"), lic_dest)
 
-copy_runtime_deps(sys.argv[1], sys.argv[2])
+copy_runtime_deps(sys.argv[1])

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
 ]