---

yaml
---
r: 277406
b: refs/heads/try
c: 2f1dfe6
h: refs/heads/master

Author: LeoTestard

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: cda7c1cf2463443aee4a2f51a5141bc7ce4a4f97
+refs/heads/try: 2f1dfe615d479f19fa1b989e014eb8d4d516a23a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/configure

@@ -609,7 +609,6 @@ opt llvm-version-check 1 "check if the LLVM version is supported, build anyway"
 opt rustbuild 0 "use the rust and cargo based build system"
 opt orbit 0 "get MIR where it belongs - everywhere; most importantly, in orbit"
 opt codegen-tests 1 "run the src/test/codegen tests"
-opt option-checking 1 "complain about unrecognized options in this configure script"
 
 # Optimization and debugging options. These may be overridden by the release channel, etc.
 opt_nosave optimize 1 "build optimized rust code"
@@ -675,11 +674,8 @@ then
 fi
 
 # Validate Options
-if [ -z "$CFG_DISABLE_OPTION_CHECKING" ]
-then
-    step_msg "validating $CFG_SELF args"
-    validate_opt
-fi
+step_msg "validating $CFG_SELF args"
+validate_opt
 
 # Validate the release channel, and configure options
 case "$CFG_RELEASE_CHANNEL" in
@@ -823,19 +819,6 @@ then
     fi
 fi
 
-# LLDB tests on OSX require /usr/bin/python, not something like Homebrew's
-# /usr/local/bin/python. We're loading a compiled module for LLDB tests which is
-# only compatible with the system.
-case $CFG_BUILD in
-    *-apple-darwin)
-        CFG_LLDB_PYTHON=/usr/bin/python
-        ;;
-    *)
-        CFG_LLDB_PYTHON=$CFG_PYTHON
-        ;;
-esac
-putvar CFG_LLDB_PYTHON
-
 step_msg "looking for target specific programs"
 
 probe CFG_ADB        adb

branches/try/mk/crates.mk

@@ -128,7 +128,7 @@ DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint rustc_const_eval
 
 
-TOOL_DEPS_compiletest := test getopts log serialize
+TOOL_DEPS_compiletest := test getopts log
 TOOL_DEPS_rustdoc := rustdoc
 TOOL_DEPS_rustc := rustc_driver
 TOOL_DEPS_rustbook := std rustdoc

branches/try/mk/tests.mk

@@ -619,11 +619,10 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
         --stage-id stage$(1)-$(2) \
         --target $(2) \
         --host $(3) \
-	--docck-python $$(CFG_PYTHON) \
-	--lldb-python $$(CFG_LLDB_PYTHON) \
+	--python $$(CFG_PYTHON) \
         --gdb-version="$(CFG_GDB_VERSION)" \
         --lldb-version="$(CFG_LLDB_VERSION)" \
-        --android-cross-path=$(CFG_ARM_LINUX_ANDROIDEABI_NDK) \
+        --android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
         --adb-path=$(CFG_ADB) \
         --adb-test-dir=$(CFG_ADB_TEST_DIR) \
         --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \

branches/try/src/bootstrap/build/check.rs

@@ -9,8 +9,7 @@
 // except according to those terms.
 
 use std::fs;
-use std::path::{PathBuf, Path};
-use std::process::Command;
+use std::path::PathBuf;
 
 use build::{Build, Compiler};
 
@@ -82,19 +81,8 @@ pub fn compiletest(build: &Build,
 
     // FIXME: needs android support
     cmd.arg("--android-cross-path").arg("");
-
     // FIXME: CFG_PYTHON should probably be detected more robustly elsewhere
-    let python_default = "python";
-    cmd.arg("--docck-python").arg(python_default);
-
-    if build.config.build.ends_with("apple-darwin") {
-        // Force /usr/bin/python on OSX for LLDB tests because we're loading the
-        // LLDB plugin's compiled module which only works with the system python
-        // (namely not Homebrew-installed python)
-        cmd.arg("--lldb-python").arg("/usr/bin/python");
-    } else {
-        cmd.arg("--lldb-python").arg(python_default);
-    }
+    cmd.arg("--python").arg("python");
 
     if let Some(ref vers) = build.gdb_version {
         cmd.arg("--gdb-version").arg(vers);
@@ -114,42 +102,3 @@ pub fn compiletest(build: &Build,
 
     build.run(&mut cmd);
 }
-
-pub fn docs(build: &Build, compiler: &Compiler) {
-    let mut stack = vec![build.src.join("src/doc")];
-
-    while let Some(p) = stack.pop() {
-        if p.is_dir() {
-            stack.extend(t!(p.read_dir()).map(|p| t!(p).path()));
-            continue
-        }
-
-        if p.extension().and_then(|s| s.to_str()) != Some("md") {
-            continue
-        }
-
-        println!("doc tests for: {}", p.display());
-        markdown_test(build, compiler, &p);
-    }
-}
-
-pub fn error_index(build: &Build, compiler: &Compiler) {
-    println!("Testing error-index stage{}", compiler.stage);
-
-    let output = testdir(build, compiler.host).join("error-index.md");
-    build.run(build.tool_cmd(compiler, "error_index_generator")
-                   .arg("markdown")
-                   .arg(&output)
-                   .env("CFG_BUILD", &build.config.build));
-
-    markdown_test(build, compiler, &output);
-}
-
-fn markdown_test(build: &Build, compiler: &Compiler, markdown: &Path) {
-    let mut cmd = Command::new(build.rustdoc(compiler));
-    build.add_rustc_lib_path(compiler, &mut cmd);
-    cmd.arg("--test");
-    cmd.arg(markdown);
-    cmd.arg("--test-args").arg(build.flags.args.join(" "));
-    build.run(&mut cmd);
-}

branches/try/src/bootstrap/build/mod.rs

@@ -308,12 +308,6 @@ impl Build {
                     check::compiletest(self, &compiler, target.target,
                                        "compile-fail", "compile-fail-fulldeps")
                 }
-                CheckDocs { compiler } => {
-                    check::docs(self, &compiler);
-                }
-                CheckErrorIndex { compiler } => {
-                    check::error_index(self, &compiler);
-                }
 
                 DistDocs { stage } => dist::docs(self, stage, target.target),
                 DistMingw { _dummy } => dist::mingw(self, target.target),

branches/try/src/bootstrap/build/step.rs

@@ -96,8 +96,6 @@ macro_rules! targets {
             (check_rpass_valgrind, CheckRPassValgrind { compiler: Compiler<'a> }),
             (check_rpass_full, CheckRPassFull { compiler: Compiler<'a> }),
             (check_cfail_full, CheckCFailFull { compiler: Compiler<'a> }),
-            (check_docs, CheckDocs { compiler: Compiler<'a> }),
-            (check_error_index, CheckErrorIndex { compiler: Compiler<'a> }),
 
             // Distribution targets, creating tarballs
             (dist, Dist { stage: u32 }),
@@ -343,10 +341,7 @@ impl<'a> Step<'a> {
                     self.check_rpass_valgrind(compiler),
                     self.check_rpass_full(compiler),
                     self.check_cfail_full(compiler),
-                    self.check_error_index(compiler),
-                    self.check_docs(compiler),
                     self.check_linkcheck(stage),
-                    self.check_tidy(stage),
                     self.dist(stage),
                 ]
             }
@@ -388,12 +383,6 @@ impl<'a> Step<'a> {
                 vec![self.librustc(compiler),
                      self.tool_compiletest(compiler.stage)]
             }
-            Source::CheckDocs { compiler } => {
-                vec![self.libstd(compiler)]
-            }
-            Source::CheckErrorIndex { compiler } => {
-                vec![self.libstd(compiler), self.tool_error_index(compiler.stage)]
-            }
 
             Source::ToolLinkchecker { stage } |
             Source::ToolTidy { stage } => {

branches/try/src/doc/README.md

@@ -9,7 +9,7 @@ libraries.
 
 To generate HTML documentation from one source file/crate, do something like:
 
-~~~~text
+~~~~
 rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
@@ -20,7 +20,7 @@ rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
 To generate an HTML version of a doc from Markdown manually, you can do
 something like:
 
-~~~~text
+~~~~
 rustdoc reference.md
 ~~~~
 

branches/try/src/doc/book/const-and-static.md

@@ -79,5 +79,5 @@ the result of a function call or anything similarly complex or at runtime.
 
 Almost always, if you can choose between the two, choose `const`. It’s pretty
 rare that you actually want a memory location associated with your constant,
-and using a `const` allows for optimizations like constant propagation not only
+and using a const allows for optimizations like constant propagation not only
 in your crate but downstream crates.

branches/try/src/doc/nomicon/subtyping.md

@@ -53,7 +53,7 @@ inferred variance, so `Fn(T)` is invariant in `T`).
 Some important variances:
 
 * `&'a T` is variant over `'a` and `T` (as is `*const T` by metaphor)
-* `&'a mut T` is variant over `'a` but invariant over `T`
+* `&'a mut T` is variant with over `'a` but invariant over `T`
 * `Fn(T) -> U` is invariant over `T`, but variant over `U`
 * `Box`, `Vec`, and all other collections are variant over the types of
   their contents

branches/try/src/doc/style/errors/ergonomics.md

@@ -9,7 +9,7 @@ pattern.
 
 Prefer
 
-```rust,ignore
+```rust
 use std::io::{File, Open, Write, IoError};
 
 struct Info {
@@ -31,7 +31,7 @@ fn write_info(info: &Info) -> Result<(), IoError> {
 
 over
 
-```rust,ignore
+```rust
 use std::io::{File, Open, Write, IoError};
 
 struct Info {

branches/try/src/doc/style/features/functions-and-methods/README.md

@@ -4,15 +4,15 @@
 
 Prefer
 
-```rust,ignore
+```rust
 impl Foo {
     pub fn frob(&self, w: widget) { ... }
 }
 ```
 
 over
 
-```rust,ignore
+```rust
 pub fn frob(foo: &Foo, w: widget) { ... }
 ```
 

branches/try/src/doc/style/features/functions-and-methods/input.md

@@ -6,15 +6,15 @@
 
 Prefer
 
-```rust,ignore
+```rust
 fn foo(b: Bar) {
    // use b as owned, directly
 }
 ```
 
 over
 
-```rust,ignore
+```rust
 fn foo(b: &Bar) {
     let b = b.clone();
     // use b as owned after cloning
@@ -33,13 +33,13 @@ needed, not as a way of signaling that copies should be cheap to make.
 
 Prefer
 
-```rust,ignore
+```rust
 fn foo(b: Bar) -> Bar { ... }
 ```
 
 over
 
-```rust,ignore
+```rust
 fn foo(b: Box<Bar>) -> Box<Bar> { ... }
 ```
 
@@ -56,13 +56,13 @@ it becomes.
 
 Prefer
 
-```rust,ignore
+```rust
 fn foo<T: Iterator<i32>>(c: T) { ... }
 ```
 
 over any of
 
-```rust,ignore
+```rust
 fn foo(c: &[i32]) { ... }
 fn foo(c: &Vec<i32>) { ... }
 fn foo(c: &SomeOtherCollection<i32>) { ... }
@@ -83,14 +83,14 @@ concrete nor overly abstract. See the discussion on
 
 Prefer either of
 
-```rust,ignore
+```rust
 fn foo(b: &Bar) { ... }
 fn foo(b: &mut Bar) { ... }
 ```
 
 over
 
-```rust,ignore
+```rust
 fn foo(b: Bar) { ... }
 ```
 
@@ -101,13 +101,13 @@ ownership is actually needed.
 
 Prefer
 
-```rust,ignore
+```rust
 fn foo() -> (Bar, Bar)
 ```
 
 over
 
-```rust,ignore
+```rust
 fn foo(output: &mut Bar) -> Bar
 ```
 
@@ -120,7 +120,7 @@ multiple values, it should do so via one of these types.
 The primary exception: sometimes a function is meant to modify data
 that the caller already owns, for example to re-use a buffer:
 
-```rust,ignore
+```rust
 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize>
 ```
 
@@ -146,7 +146,7 @@ Choose an argument type that rules out bad inputs.
 
 For example, prefer
 
-```rust,ignore
+```rust
 enum FooMode {
     Mode1,
     Mode2,
@@ -157,7 +157,7 @@ fn foo(mode: FooMode) { ... }
 
 over
 
-```rust,ignore
+```rust
 fn foo(mode2: bool, mode3: bool) {
     assert!(!mode2 || !mode3);
     ...