Rolling up PRs in the queue

.gitmodules

@@ -11,3 +11,6 @@
 [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

mk/ctags.mk

@@ -27,7 +27,7 @@ CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/llvm,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/msvc,, \
 				$(patsubst ${CFG_SRC_DIR}src/rt/vg,, \
 				$(wildcard ${CFG_SRC_DIR}src/*) $(wildcard ${CFG_SRC_DIR}src/rt/*) \
-				)))))))))
+				))))))))
 CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=-javascript --recurse ${CTAGS_LOCATIONS}
 # We could use `--languages=Rust`, but there is value in producing tags for the
 # C++ parts of the code base too (at the time of writing, those are .h and .cpp

mk/dist.mk

@@ -58,6 +58,7 @@ PKG_FILES := \
       rt                                       \
       rustllvm                                 \
       snapshots.txt                            \
+      rust-installer                           \
       test)                                    \
     $(PKG_GITMODULES)                          \
     $(filter-out config.stamp, \
@@ -209,33 +210,40 @@ 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)
+dist-install-dir-$(1): PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)-image
 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)tar -czf dist/$$(PKG_NAME)-$(1).tar.gz -C tmp/dist $$(PKG_NAME)-$(1)
+	$$(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
 
 endef
 

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-install-dir-$(CFG_BUILD) | tmp/empty_dir
+prepare_install: dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz | 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-install-dir-$(CFG_BUILD) | tmp/empty_dir
+prepare_uninstall: dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz | tmp/empty_dir
 
 .PHONY: install prepare_install uninstall prepare_uninstall
 

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).to_string())
+                    Some(captures.at(2).unwrap_or("").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).to_string())
+                    Some(captures.at(1).unwrap_or("").to_string())
                 }
                 None => {
                     println!("Could not extract LLDB version from line '{}'",

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").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 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 (which, line) = if follow {
             assert!(adjusts == 0, "use either //~| or //~^, not both.");

src/doc/complement-lang-faq.md

@@ -24,7 +24,7 @@ Some examples that demonstrate different aspects of the language:
 [HashMap]: https://github.com/rust-lang/rust/blob/master/src/libcollections/hashmap.rs
 [json]: https://github.com/rust-lang/rust/blob/master/src/libserialize/json.rs
 
-You may also be interested in browsing [GitHub's Rust][github-rust] page.
+You may also be interested in browsing [trending Rust repositories][github-rust] on GitHub.
 
 [github-rust]: https://github.com/trending?l=rust
 
@@ -42,7 +42,7 @@ Let the fact that this is an easily countable number be a warning.
 
 ## Does it run on Windows?
 
-Yes. All development happens in lock-step on all 3 target platforms. Using MinGW, not Cygwin. Note that the windows implementation currently has some limitations: in particular 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depend on libgcc DLL at runtime][libgcc].
+Yes. All development happens in lockstep on all 3 target platforms (using MinGW, not Cygwin). Note that the Windows implementation currently has some limitations; in particular, the 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depend on libgcc DLL at runtime][libgcc].
 
 [win64]: https://github.com/rust-lang/rust/issues/1237
 [libgcc]: https://github.com/rust-lang/rust/issues/11782
@@ -104,7 +104,7 @@ Similar to the reasoning about default-sync: it wires fewer assumptions into the
 
 ## Why are strings UTF-8 by default? Why not UCS2 or UCS4?
 
-The `str` type is UTF-8 because we observe more text in the wild in this encoding -- particularly in network transmissions, which are endian-agnostic -- and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction.
+The `str` type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction.
 
 This does mean that indexed access to a Unicode codepoint inside a `str` value is an O(n) operation. On the one hand, this is clearly undesirable; on the other hand, this problem is full of trade-offs and we'd like to point a few important qualifications:
 
@@ -145,23 +145,27 @@ For simplicity, we do not plan to do so. Implementing automatic semicolon insert
 
 ## How do I get my program to display the output of logging macros?
 
-**Short answer** set the RUST_LOG environment variable to the name of your source file, sans extension.
+**Short Answer**: Set the `RUST_LOG` environment variable to the name of your source file, sans extension.
 
 ```sh
 rustc hello.rs
 export RUST_LOG=hello
 ./hello
 ```
 
-**Long answer** RUST_LOG takes a 'logging spec' that consists of a
+**Long Answer**: `RUST_LOG` takes a 'logging spec' that consists of a
 comma-separated list of paths, where a path consists of the crate name and
-sequence of module names, each separated by double-colons. For standalone .rs
-files the crate is implicitly named after the source file, so in the above
-example we were setting RUST_LOG to the name of the hello crate. Multiple paths
+sequence of module names, each separated by double-colons. For standalone `.rs`
+files, the crate is implicitly named after the source file, so in the above
+example we were setting `RUST_LOG` to the name of the hello crate. Multiple paths
 can be combined to control the exact logging you want to see. For example, when
-debugging linking in the compiler you might set
-`RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
-For a full description see [the logging crate][1].
+debugging linking in the compiler, you might set the following:
+
+```sh
+RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath
+```
+
+For a full description, see [the logging crate][1].
 
 ## How fast is Rust?
 
@@ -172,6 +176,6 @@ performance.
 That said, it is an explicit goal of Rust to be as fast as C++ for most things.
 Language decisions are made with performance in mind, and we want Rust to be as
 fast as possible. Given that Rust is built on top of LLVM, any performance
-improvements in it also help us be faster.
+improvements in it also help Rust become faster.
 
 [1]:log/index.html

src/doc/guide-macros.md

@@ -195,7 +195,7 @@ early_return!(input_2, [T::SpecialB]);
 As the above example demonstrates, `$(...)*` is also valid on the right-hand
 side of a macro definition. The behavior of `*` in transcription,
 especially in cases where multiple `*`s are nested, and multiple different
-names are involved, can seem somewhat magical and intuitive at first. The
+names are involved, can seem somewhat magical and unintuitive at first. The
 system that interprets them is called "Macro By Example". The two rules to
 keep in mind are (1) the behavior of `$(...)*` is to walk through one "layer"
 of repetitions for all of the `$name`s it contains in lockstep, and (2) each

src/doc/guide-ownership.md

@@ -341,7 +341,7 @@ fn main() {
     {                         //  |
         let y = &5i;          // ---+ y goes into scope
         let f = Foo { x: y }; // ---+ f goes into scope
-	x = &f.x;	      //  | | error here
+        x = &f.x;             //  | | error here
     }                         // ---+ f & y go out of scope
                               //  |
     println!("{}", x);        //  |
@@ -416,7 +416,7 @@ note: `car` moved here because it has type `Car`, which is non-copyable
 ```
 
 We need our `Car` to be pointed to by multiple `Wheel`s. We can't do that with
-`Box<T>`, because it has a single owner. We can do t with `Rc<T>` instead:
+`Box<T>`, because it has a single owner. We can do it with `Rc<T>` instead:
 
 ```rust
 use std::rc::Rc;

src/doc/guide-testing.md

@@ -357,7 +357,7 @@ Let's finally check out that third section: documentation tests.
 
 Nothing is better than documentation with examples. Nothing is worse than
 examples that don't actually work, because the code has changed since the
-documentation has been written. To this end, Rust supports automaticaly
+documentation has been written. To this end, Rust supports automatically
 running examples in your documentation. Here's a fleshed-out `src/lib.rs`
 with examples: