---

yaml
---
r: 163509
b: refs/heads/snap-stage3
c: 556d971
h: refs/heads/master
i:
  163507: 3f75aa2
v: v3

Author: Jorge Aparicio

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: bdb1146181e4c320255bec4a93af3d645d522d59
+refs/heads/snap-stage3: 556d971f83ea5950444b0a5b5392cd0040f077f6
 refs/heads/try: 20cbbffeefc1f35e2ea63afce7b42fbd79611d42
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/.gitmodules

@@ -11,6 +11,3 @@
 [submodule "src/jemalloc"]
 	path = src/jemalloc
 	url = https://github.com/rust-lang/jemalloc.git
-[submodule "src/rust-installer"]
-	path = src/rust-installer
-	url = https://github.com/rust-lang/rust-installer

branches/snap-stage3/mk/dist.mk

@@ -58,7 +58,6 @@ PKG_FILES := \
       rt                                       \
       rustllvm                                 \
       snapshots.txt                            \
-      rust-installer                           \
       test)                                    \
     $(PKG_GITMODULES)                          \
     $(filter-out config.stamp, \
@@ -210,40 +209,33 @@ distcheck-osx: dist-osx
 # Unix binary installer tarballs
 ######################################################################
 
-NON_INSTALLED_PREFIXES=COPYRIGHT,LICENSE-APACHE,LICENSE-MIT,README.md,doc
-
 define DEF_INSTALLER
 
 $$(eval $$(call DEF_PREPARE,dir-$(1)))
 
 dist-install-dir-$(1): PREPARE_HOST=$(1)
 dist-install-dir-$(1): PREPARE_TARGETS=$(2)
-dist-install-dir-$(1): PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)-image
+dist-install-dir-$(1): PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)
 dist-install-dir-$(1): PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
 dist-install-dir-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 dist-install-dir-$(1): PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
 dist-install-dir-$(1): PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
 dist-install-dir-$(1): PREPARE_CLEAN=true
 dist-install-dir-$(1): prepare-base-dir-$(1) docs compiler-docs
+	$$(Q)(cd $$(PREPARE_DEST_DIR)/ && find . -type f | sed 's/^\.\///') \
+      > tmp/dist/manifest-$(1).in
+	$$(Q)mv tmp/dist/manifest-$(1).in $$(PREPARE_DEST_DIR)/$$(CFG_LIBDIR_RELATIVE)/rustlib/manifest.in
+# Add remaining non-installed files
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)COPYRIGHT $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-APACHE $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-MIT $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)README.md $$(PREPARE_DEST_DIR)
 	$$(Q)cp -r doc $$(PREPARE_DEST_DIR)
+	$$(Q)$$(PREPARE_BIN_CMD) $$(S)src/etc/install.sh $$(PREPARE_DEST_DIR)
 
 dist/$$(PKG_NAME)-$(1).tar.gz: dist-install-dir-$(1)
 	@$(call E, build: $$@)
-	$$(Q)$$(S)src/rust-installer/gen-installer.sh \
-		--product-name=Rust \
-		--verify-bin=rustc \
-		--rel-manifest-dir=rustlib \
-		--success-message=Rust-is-ready-to-roll. \
-		--image-dir=tmp/dist/$$(PKG_NAME)-$(1)-image \
-		--work-dir=tmp/dist \
-		--output-dir=dist \
-		--non-installed-prefixes=$$(NON_INSTALLED_PREFIXES) \
-		--package-name=$$(PKG_NAME)-$(1)
-	$$(Q)rm -R tmp/dist/$$(PKG_NAME)-$(1)-image
+	$$(Q)tar -czf dist/$$(PKG_NAME)-$(1).tar.gz -C tmp/dist $$(PKG_NAME)-$(1)
 
 endef
 

branches/snap-stage3/mk/install.mk

@@ -25,7 +25,7 @@ endif
 # Remove tmp files because it's a decent amount of disk space
 	$(Q)rm -R tmp/dist
 
-prepare_install: dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz | tmp/empty_dir
+prepare_install: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
 
 uninstall:
 ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
@@ -38,7 +38,7 @@ endif
 # Remove tmp files because it's a decent amount of disk space
 	$(Q)rm -R tmp/dist
 
-prepare_uninstall: dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz | tmp/empty_dir
+prepare_uninstall: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
 
 .PHONY: install prepare_install uninstall prepare_uninstall
 

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -394,7 +394,7 @@ fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
 
             match re.captures(full_version_line) {
                 Some(captures) => {
-                    Some(captures.at(2).unwrap_or("").to_string())
+                    Some(captures.at(2).to_string())
                 }
                 None => {
                     println!("Could not extract GDB version from line '{}'",
@@ -428,7 +428,7 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
 
             match re.captures(full_version_line) {
                 Some(captures) => {
-                    Some(captures.at(1).unwrap_or("").to_string())
+                    Some(captures.at(1).to_string())
                 }
                 None => {
                     println!("Could not extract LLDB version from line '{}'",

branches/snap-stage3/src/compiletest/errors.rs

@@ -66,10 +66,10 @@ fn parse_expected(last_nonfollow_error: Option<uint>,
                   line: &str,
                   re: &Regex) -> Option<(WhichLine, ExpectedError)> {
     re.captures(line).and_then(|caps| {
-        let adjusts = caps.name("adjusts").unwrap_or("").len();
-        let kind = caps.name("kind").unwrap_or("").to_ascii_lower();
-        let msg = caps.name("msg").unwrap_or("").trim().to_string();
-        let follow = caps.name("follow").unwrap_or("").len() > 0;
+        let adjusts = caps.name("adjusts").len();
+        let kind = caps.name("kind").to_ascii_lower();
+        let msg = caps.name("msg").trim().to_string();
+        let follow = caps.name("follow").len() > 0;
 
         let (which, line) = if follow {
             assert!(adjusts == 0, "use either //~| or //~^, not both.");

branches/snap-stage3/src/doc/guide.md

@@ -30,10 +30,9 @@ $ curl -s https://static.rust-lang.org/rustup.sh | sudo sh
 below.)
 
 If you're on Windows, please download either the [32-bit
-installer](https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.exe)
-
+installer](https://static.rust-lang.org/dist/rust-nightly-i686-w64-mingw32.exe)
 or the [64-bit
-installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.exe)
+installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-w64-mingw32.exe)
 and run it.
 
 If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay.
@@ -418,19 +417,6 @@ let x: int = 5;
 If I asked you to read this out loud to the rest of the class, you'd say "`x`
 is a binding with the type `int` and the value `five`."
 
-In future examples, we may annotate the type in a comment. The examples will
-look like this:
-
-```{rust}
-fn main() {
-    let x = 5i; // x: int
-}
-```
-
-Note the similarities between this annotation and the syntax you use with `let`.
-Including these kinds of comments is not idiomatic Rust, but we'll occasionally
-include them to help you understand what the types that Rust infers are.
-
 By default, bindings are **immutable**. This code will not compile:
 
 ```{ignore}
@@ -449,7 +435,7 @@ error: re-assignment of immutable variable `x`
 If you want a binding to be mutable, you can use `mut`:
 
 ```{rust}
-let mut x = 5i; // mut x: int
+let mut x = 5i;
 x = 10i;
 ```
 
@@ -597,15 +583,15 @@ let y = if x == 5i {
     10i
 } else {
     15i
-}; // y: int
+};
 ```
 
 Which we can (and probably should) write like this:
 
 ```{rust}
 let x = 5i;
 
-let y = if x == 5i { 10i } else { 15i }; // y: int
+let y = if x == 5i { 10i } else { 15i };
 ```
 
 This reveals two interesting things about Rust: it is an expression-based
@@ -941,8 +927,8 @@ destructuring. You can assign one tuple into another, if they have the same
 arity and contained types.
 
 ```rust
-let mut x = (1i, 2i); // x: (int, int)
-let y = (2i, 3i);     // y: (int, int)
+let mut x = (1i, 2i);
+let y = (2i, 3i);
 
 x = y;
 ```
@@ -994,7 +980,7 @@ struct Point {
 }
 
 fn main() {
-    let origin = Point { x: 0i, y: 0i }; // origin: Point
+    let origin = Point { x: 0i, y: 0i };
 
     println!("The origin is at ({}, {})", origin.x, origin.y);
 }
@@ -1114,7 +1100,7 @@ fn main() {
     let x = 5i;
     let y = 10i;
 
-    let ordering = cmp(x, y); // ordering: Ordering
+    let ordering = cmp(x, y);
 
     if ordering == Less {
         println!("less");
@@ -1401,7 +1387,7 @@ Instead, it looks like this:
 
 ```{rust}
 for x in range(0i, 10i) {
-    println!("{}", x); // x: int
+    println!("{}", x);
 }
 ```
 
@@ -1436,8 +1422,8 @@ The other kind of looping construct in Rust is the `while` loop. It looks like
 this:
 
 ```{rust}
-let mut x = 5u;       // mut x: uint
-let mut done = false; // mut done: bool
+let mut x = 5u;
+let mut done = false;
 
 while !done {
     x += x - 3;
@@ -1533,7 +1519,7 @@ The first kind is a `&str`. This is pronounced a 'string slice.' String literals
 are of the type `&str`:
 
 ```{rust}
-let string = "Hello there."; // string: &str
+let string = "Hello there.";
 ```
 
 This string is statically allocated, meaning that it's saved inside our
@@ -1545,7 +1531,7 @@ A `String`, on the other hand, is an in-memory string.  This string is
 growable, and is also guaranteed to be UTF-8.
 
 ```{rust}
-let mut s = "Hello".to_string(); // mut s: String
+let mut s = "Hello".to_string();
 println!("{}", s);
 
 s.push_str(", world.");
@@ -1601,19 +1587,16 @@ things. The most basic is the **array**, a fixed-size list of elements of the
 same type. By default, arrays are immutable.
 
 ```{rust}
-let a = [1i, 2i, 3i];     // a: [int, ..3]
-let mut m = [1i, 2i, 3i]; // mut m: [int, ..3]
+let a = [1i, 2i, 3i];
+let mut m = [1i, 2i, 3i];
 ```
 
 You can create an array with a given number of elements, all initialized to the
 same value, with `[val, ..N]` syntax. The compiler ensures that arrays are
 always initialized.
 
-There's a shorthand for initializing each element of an array to the same
-value. In this example, each element of `a` will be initialized to `0i`:
-
 ```{rust}
-let a = [0i, ..20]; // a: [int, ..20]
+let a = [0i, ..20];  // Shorthand for array of 20 elements all initialized to 0
 ```
 
 Arrays have type `[T,..N]`. We'll talk about this `T` notation later, when we
@@ -1624,7 +1607,7 @@ You can get the number of elements in an array `a` with `a.len()`, and use
 number in order:
 
 ```{rust}
-let a = [1i, 2, 3]; // Only the first item needs a type suffix
+let a = [1i, 2, 3];     // Only the first item needs a type suffix
 
 println!("a has {} elements", a.len());
 for e in a.iter() {
@@ -1635,7 +1618,7 @@ for e in a.iter() {
 You can access a particular element of an array with **subscript notation**:
 
 ```{rust}
-let names = ["Graydon", "Brian", "Niko"]; // names: [&str, 3]
+let names = ["Graydon", "Brian", "Niko"];
 
 println!("The second name is: {}", names[1]);
 ```
@@ -1653,7 +1636,7 @@ later). Vectors are to arrays what `String` is to `&str`. You can create them
 with the `vec!` macro:
 
 ```{rust}
-let v = vec![1i, 2, 3]; // v: Vec<int>
+let v = vec![1i, 2, 3];
 ```
 
 (Notice that unlike the `println!` macro we've used in the past, we use square
@@ -1664,10 +1647,8 @@ You can get the length of, iterate over, and subscript vectors just like
 arrays. In addition, (mutable) vectors can grow automatically:
 
 ```{rust}
-let mut nums = vec![1i, 2, 3]; // mut nums: Vec<int>
-
+let mut nums = vec![1i, 2, 3];
 nums.push(4);
-
 println!("The length of nums is now {}", nums.len());   // Prints 4
 ```
 
@@ -1841,12 +1822,10 @@ use std::io;
 fn main() {
     println!("Type something!");
 
-                                                  // here, we'll show the types at each step
-
-    let input = io::stdin()                       // std::io::stdio::StdinReader
-                  .read_line()                    // IoResult<String>
-                  .ok()                           // Option<String>
-                  .expect("Failed to read line"); // String
+    let input = io::stdin()
+                  .read_line()
+                  .ok()
+                  .expect("Failed to read line");
 
     println!("{}", input);
 }
@@ -1989,7 +1968,7 @@ use std::rand;
 fn main() {
     println!("Guess the number!");
 
-    let secret_number = (rand::random() % 100i) + 1i; // secret_number: int
+    let secret_number = (rand::random() % 100i) + 1i;
 
     println!("The secret number is: {}", secret_number);
 
@@ -2282,8 +2261,8 @@ In this case, we say `x` is a `uint` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = from_str::<uint>("5");       // input_num: Option<uint>
-let input_num: Option<uint> = from_str("5"); // input_num: Option<uint>
+let input_num = from_str::<uint>("5");
+let input_num: Option<uint> = from_str("5");
 ```
 
 Anyway, with us now converting our input to a number, our code looks like this: