---

yaml
---
r: 277029
b: refs/heads/try
c: a563711
h: refs/heads/master
i:
  277027: 128fa9e

Author: eddyb

[refs]

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

branches/try/mk/tests.mk

@@ -240,16 +240,52 @@ cleantestlibs:
 # Tidy
 ######################################################################
 
+ifdef CFG_NOTIDY
 .PHONY: tidy
-tidy: $(HBIN0_H_$(CFG_BUILD))/tidy$(X_$(CFG_BUILD))
-	$(TARGET_RPATH_VAR0_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $< $(S)src
-
-$(HBIN0_H_$(CFG_BUILD))/tidy$(X_$(CFG_BUILD)): \
-		$(TSREQ0_T_$(CFG_BUILD)_H_$(CFG_BUILD)) \
-		$(TLIB0_T_$(CFG_BUILD)_H_$(CFG_BUILD))/stamp.std \
-		$(call rwildcard,$(S)src/tools/tidy/src,*.rs)
-	$(STAGE0_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(S)src/tools/tidy/src/main.rs \
-		--out-dir $(@D) --crate-name tidy
+tidy:
+else
+
+# Run the tidy script in multiple parts to avoid huge 'echo' commands
+.PHONY: tidy
+tidy: tidy-basic tidy-binaries tidy-errors tidy-features
+
+endif
+
+.PHONY: tidy-basic
+tidy-basic:
+		@$(call E, check: formatting)
+		$(Q) $(CFG_PYTHON) $(S)src/etc/tidy.py $(S)src/
+
+.PHONY: tidy-binaries
+tidy-binaries:
+		@$(call E, check: binaries)
+		$(Q)find $(S)src -type f \
+		    \( -perm -u+x -or -perm -g+x -or -perm -o+x \) \
+		    -not -name '*.rs' -and -not -name '*.py' \
+		    -and -not -name '*.sh' -and -not -name '*.pp' \
+		| grep '^$(S)src/jemalloc' -v \
+		| grep '^$(S)src/libuv' -v \
+		| grep '^$(S)src/llvm' -v \
+		| grep '^$(S)src/rt/hoedown' -v \
+		| grep '^$(S)src/gyp' -v \
+		| grep '^$(S)src/etc' -v \
+		| grep '^$(S)src/doc' -v \
+		| grep '^$(S)src/compiler-rt' -v \
+		| grep '^$(S)src/libbacktrace' -v \
+		| grep '^$(S)src/rust-installer' -v \
+		| grep '^$(S)src/liblibc' -v \
+		| xargs $(CFG_PYTHON) $(S)src/etc/check-binaries.py
+
+.PHONY: tidy-errors
+tidy-errors:
+		@$(call E, check: extended errors)
+		$(Q) $(CFG_PYTHON) $(S)src/etc/errorck.py $(S)src/
+
+.PHONY: tidy-features
+tidy-features:
+		@$(call E, check: feature sanity)
+		$(Q) $(CFG_PYTHON) $(S)src/etc/featureck.py $(S)src/
+
 
 ######################################################################
 # Sets of tests

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

@@ -33,10 +33,3 @@ pub fn cargotest(build: &Build, stage: u32, host: &str) {
               .env("PATH", newpath)
               .arg(&build.cargo));
 }
-
-pub fn tidy(build: &Build, stage: u32, host: &str) {
-    println!("tidy check stage{} ({})", stage, host);
-    let compiler = Compiler::new(stage, host);
-    build.run(build.tool_cmd(&compiler, "tidy")
-                   .arg(build.src.join("src")));
-}

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

@@ -197,9 +197,6 @@ impl Build {
                 ToolCargoTest { stage } => {
                     compile::tool(self, stage, target.target, "cargotest");
                 }
-                ToolTidy { stage } => {
-                    compile::tool(self, stage, target.target, "tidy");
-                }
                 DocBook { stage } => {
                     doc::rustbook(self, stage, target.target, "book", &doc_out);
                 }
@@ -233,9 +230,6 @@ impl Build {
                 CheckCargoTest { stage } => {
                     check::cargotest(self, stage, target.target);
                 }
-                CheckTidy { stage } => {
-                    check::tidy(self, stage, target.target);
-                }
 
                 DistDocs { stage } => dist::docs(self, stage, target.target),
                 DistMingw { _dummy } => dist::mingw(self, target.target),

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

@@ -51,7 +51,6 @@ macro_rules! targets {
             (tool_rustbook, ToolRustbook { stage: u32 }),
             (tool_error_index, ToolErrorIndex { stage: u32 }),
             (tool_cargotest, ToolCargoTest { stage: u32 }),
-            (tool_tidy, ToolTidy { stage: u32 }),
 
             // Steps for long-running native builds. Ideally these wouldn't
             // actually exist and would be part of build scripts, but for now
@@ -80,7 +79,6 @@ macro_rules! targets {
             (check, Check { stage: u32, compiler: Compiler<'a> }),
             (check_linkcheck, CheckLinkcheck { stage: u32 }),
             (check_cargotest, CheckCargoTest { stage: u32 }),
-            (check_tidy, CheckTidy { stage: u32 }),
 
             // Distribution targets, creating tarballs
             (dist, Dist { stage: u32 }),
@@ -318,12 +316,8 @@ impl<'a> Step<'a> {
             Source::CheckCargoTest { stage } => {
                 vec![self.tool_cargotest(stage)]
             }
-            Source::CheckTidy { stage } => {
-                vec![self.tool_tidy(stage)]
-            }
 
-            Source::ToolLinkchecker { stage } |
-            Source::ToolTidy { stage } => {
+            Source::ToolLinkchecker { stage } => {
                 vec![self.libstd(self.compiler(stage))]
             }
             Source::ToolErrorIndex { stage } |

branches/try/src/bootstrap/mk/Makefile.in

@@ -42,7 +42,5 @@ check-cargotest:
 	$(Q)$(BOOTSTRAP) --step check-cargotest
 dist:
 	$(Q)$(BOOTSTRAP) --step dist
-tidy:
-	$(Q)$(BOOTSTRAP) --step check-tidy --stage 0
 
 .PHONY: dist

branches/try/src/compiletest/compiletest.rs

@@ -13,6 +13,7 @@
 #![feature(box_syntax)]
 #![feature(libc)]
 #![feature(rustc_private)]
+#![feature(str_char)]
 #![feature(test)]
 #![feature(question_mark)]
 
@@ -411,26 +412,16 @@ fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
 
             // used to be a regex "(^|[^0-9])([0-9]\.[0-9]+)"
             for (pos, c) in full_version_line.char_indices() {
-                if !c.is_digit(10) {
-                    continue
-                }
-                if pos + 2 >= full_version_line.len() {
-                    continue
-                }
-                if full_version_line[pos + 1..].chars().next().unwrap() != '.' {
-                    continue
-                }
-                if !full_version_line[pos + 2..].chars().next().unwrap().is_digit(10) {
-                    continue
-                }
-                if pos > 0 && full_version_line[..pos].chars().next_back()
-                                                      .unwrap().is_digit(10) {
+                if !c.is_digit(10) { continue }
+                if pos + 2 >= full_version_line.len() { continue }
+                if full_version_line.char_at(pos + 1) != '.' { continue }
+                if !full_version_line.char_at(pos + 2).is_digit(10) { continue }
+                if pos > 0 && full_version_line.char_at_reverse(pos).is_digit(10) {
                     continue
                 }
                 let mut end = pos + 3;
                 while end < full_version_line.len() &&
-                      full_version_line[end..].chars().next()
-                                              .unwrap().is_digit(10) {
+                      full_version_line.char_at(end).is_digit(10) {
                     end += 1;
                 }
                 return Some(full_version_line[pos..end].to_owned());
@@ -462,13 +453,13 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
             for (pos, l) in full_version_line.char_indices() {
                 if l != 'l' && l != 'L' { continue }
                 if pos + 5 >= full_version_line.len() { continue }
-                let l = full_version_line[pos + 1..].chars().next().unwrap();
+                let l = full_version_line.char_at(pos + 1);
                 if l != 'l' && l != 'L' { continue }
-                let d = full_version_line[pos + 2..].chars().next().unwrap();
+                let d = full_version_line.char_at(pos + 2);
                 if d != 'd' && d != 'D' { continue }
-                let b = full_version_line[pos + 3..].chars().next().unwrap();
+                let b = full_version_line.char_at(pos + 3);
                 if b != 'b' && b != 'B' { continue }
-                let dash = full_version_line[pos + 4..].chars().next().unwrap();
+                let dash = full_version_line.char_at(pos + 4);
                 if dash != '-' { continue }
 
                 let vers = full_version_line[pos + 5..].chars().take_while(|c| {

branches/try/src/compiletest/errors.rs

@@ -115,7 +115,7 @@ fn parse_expected(last_nonfollow_error: Option<usize>,
                   tag: &str)
                   -> Option<(WhichLine, ExpectedError)> {
     let start = match line.find(tag) { Some(i) => i, None => return None };
-    let (follow, adjusts) = if line[start + tag.len()..].chars().next().unwrap() == '|' {
+    let (follow, adjusts) = if line.char_at(start + tag.len()) == '|' {
         (true, 0)
     } else {
         (false, line[start + tag.len()..].chars().take_while(|c| *c == '^').count())

branches/try/src/compiletest/runtest.rs

@@ -1177,7 +1177,7 @@ fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
-    let ch = haystack[*idx..].chars().next().unwrap();
+    let ch = haystack.char_at(*idx);
     if ch != needle {
         return false;
     }
@@ -1188,7 +1188,7 @@ fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
 fn scan_integer(haystack: &str, idx: &mut usize) -> bool {
     let mut i = *idx;
     while i < haystack.len() {
-        let ch = haystack[i..].chars().next().unwrap();
+        let ch = haystack.char_at(i);
         if ch < '0' || '9' < ch {
             break;
         }
@@ -1208,7 +1208,7 @@ fn scan_string(haystack: &str, needle: &str, idx: &mut usize) -> bool {
         if haystack_i >= haystack.len() {
             return false;
         }
-        let ch = haystack[haystack_i..].chars().next().unwrap();
+        let ch = haystack.char_at(haystack_i);
         haystack_i += ch.len_utf8();
         if !scan_char(needle, ch, &mut needle_i) {
             return false;

branches/try/src/doc/book/concurrency.md

@@ -162,7 +162,7 @@ The same [ownership system](ownership.html) that helps prevent using pointers
 incorrectly also helps rule out data races, one of the worst kinds of
 concurrency bugs.
 
-As an example, here is a Rust program that would have a data race in many
+As an example, here is a Rust program that could have a data race in many
 languages. It will not compile:
 
 ```ignore
@@ -174,7 +174,7 @@ fn main() {
 
     for i in 0..3 {
         thread::spawn(move || {
-            data[0] += i;
+            data[i] += 1;
         });
     }
 
@@ -186,7 +186,7 @@ This gives us an error:
 
 ```text
 8:17 error: capture of moved value: `data`
-        data[0] += i;
+        data[i] += 1;
         ^~~~
 ```
 
@@ -195,6 +195,11 @@ thread, and the thread takes ownership of the reference, we'd have three owners!
 `data` gets moved out of `main` in the first call to `spawn()`, so subsequent
 calls in the loop cannot use this variable.
 
+Note that this specific example will not cause a data race since different array
+indices are being accessed. But this can't be determined at compile time, and in
+a similar situation where `i` is a constant or is random, you would have a data
+race.
+
 So, we need some type that lets us have more than one owning reference to a
 value. Usually, we'd use `Rc<T>` for this, which is a reference counted type
 that provides shared ownership. It has some runtime bookkeeping that keeps track
@@ -218,7 +223,7 @@ fn main() {
 
         // use it in a thread
         thread::spawn(move || {
-            data_ref[0] += i;
+            data_ref[i] += 1;
         });
     }
 
@@ -261,7 +266,7 @@ fn main() {
     for i in 0..3 {
         let data = data.clone();
         thread::spawn(move || {
-            data[0] += i;
+            data[i] += 1;
         });
     }
 
@@ -276,7 +281,7 @@ And... still gives us an error.
 
 ```text
 <anon>:11:24 error: cannot borrow immutable borrowed content as mutable
-<anon>:11                    data[0] += i;
+<anon>:11                    data[i] += 1;
                              ^~~~
 ```
 
@@ -312,7 +317,7 @@ fn main() {
         let data = data.clone();
         thread::spawn(move || {
             let mut data = data.lock().unwrap();
-            data[0] += i;
+            data[i] += 1;
         });
     }
 
@@ -355,7 +360,7 @@ Let's examine the body of the thread more closely:
 #         let data = data.clone();
 thread::spawn(move || {
     let mut data = data.lock().unwrap();
-    data[0] += i;
+    data[i] += 1;
 });
 #     }
 #     thread::sleep(Duration::from_millis(50));

branches/try/src/etc/check-binaries.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+#
+# Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+import sys
+
+offenders = sys.argv[1:]
+if len(offenders) > 0:
+    print("Binaries checked into src:")
+    for offender in offenders:
+        print(offender)
+    sys.exit(1)