---

yaml
---
r: 275707
b: refs/heads/master
c: abf00c6
h: refs/heads/master
i:
  275705: edde0f0
  275703: 8824029

Author: c4rlo

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8d0dd7876e733555b0284e9b6cbf0f33ed792b67
+refs/heads/master: abf00c65c28fbbfe5d26caa118cf40c22ecb8079
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
 refs/heads/try: 49312a405e14a449b98fe0056b12a40ac128be4a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/configure

@@ -823,19 +823,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

trunk/mk/tests.mk

@@ -619,8 +619,7 @@ 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_ANDROID_CROSS_PATH) \

trunk/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);
-}

trunk/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),

trunk/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 } => {

trunk/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
 ~~~~
 

trunk/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 with over `'a` but invariant over `T`
+* `&'a mut T` is variant 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

trunk/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 {

trunk/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) { ... }
 ```
 

trunk/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);
     ...

trunk/src/doc/style/features/functions-and-methods/output.md

@@ -16,7 +16,7 @@ API.
 
 Prefer
 
-```rust,ignore
+```rust
 struct SearchResult {
     found: bool,          // item in container?
     expected_index: usize // what would the item's index be?
@@ -26,27 +26,27 @@ fn binary_search(&self, k: Key) -> SearchResult
 ```
 or
 
-```rust,ignore
+```rust
 fn binary_search(&self, k: Key) -> (bool, usize)
 ```
 
 over
 
-```rust,ignore
+```rust
 fn binary_search(&self, k: Key) -> bool
 ```
 
 #### Yield back ownership:
 
 Prefer
 
-```rust,ignore
+```rust
 fn from_utf8_owned(vv: Vec<u8>) -> Result<String, Vec<u8>>
 ```
 
 over
 
-```rust,ignore
+```rust
 fn from_utf8_owned(vv: Vec<u8>) -> Option<String>
 ```