Merge branch 'master' into move_links

Author: oli-obk

.github/deploy.sh

@@ -33,6 +33,19 @@ if [ -n "$TRAVIS_TAG" ]; then
     ln -s "$TRAVIS_TAG" out/current
 fi
 
+# Generate version index that is shown as root index page
+(
+    cp util/gh-pages/versions.html out/index.html
+
+    cd out
+    python -c '\
+        import os, json;\
+        print json.dumps([\
+            dir for dir in os.listdir(".")\
+            if not dir.startswith(".") and os.path.isdir(dir)\
+        ])' > versions.json
+)
+
 # Pull requests and commits to other branches shouldn't try to deploy, just build to verify
 if [ "$TRAVIS_PULL_REQUEST" != "false" ] || [ "$TRAVIS_BRANCH" != "$SOURCE_BRANCH" ]; then
     # Tags should deploy

.travis.yml

@@ -8,11 +8,6 @@ os:
 
 sudo: false
 
-cache:
-  cargo: true
-  directories:
-  - target
-
 env:
  global:
    # TRAVIS_TOKEN_CLIPPY_SERVICE

CHANGELOG.md

@@ -1,6 +1,12 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## 0.0.151
+* Update to *rustc 1.21.0-nightly (13d94d5fa 2017-08-10)*
+
+## 0.0.150
+* Update to *rustc 1.21.0-nightly (215e0b10e 2017-08-08)*
+
 ## 0.0.148
 * Update to *rustc 1.21.0-nightly (37c7d0ebb 2017-07-31)*
 * New lints: [`unreadable_literal`], [`inconsisten_digit_grouping`], [`large_digit_groups`]

CONTRIBUTING.md

@@ -4,7 +4,16 @@ Hello fellow Rustacean! Great to see your interest in compiler internals and lin
 
 ## Getting started
 
-All issues on Clippy are mentored, if you want help with a bug just ask @Manishearth or @llogiq.
+High level approach:
+
+1. Find something to fix/improve
+2. Change code (likely some file in `clippy_lints/src/`)
+3. Run `cargo test` in the root directory and wiggle code until it passes
+4. Open a PR (also can be done between 2. and 3. if you run into problems)
+
+### Finding something to fix/improve
+
+All issues on Clippy are mentored, if you want help with a bug just ask @Manishearth, @llogiq, @mcarton or @oli-obk.
 
 Some issues are easier than others. The [E-easy](https://github.com/rust-lang-nursery/rust-clippy/labels/E-easy)
 label can be used to find the easy issues. If you want to work on an issue, please leave a comment
@@ -16,7 +25,8 @@ matching of the syntax tree structure, and are generally easier than
 and resolved paths.
 
 Issues marked [E-medium](https://github.com/rust-lang-nursery/rust-clippy/labels/E-medium) are generally
-pretty easy too, though it's recommended you work on an E-easy issue first.
+pretty easy too, though it's recommended you work on an E-easy issue first. They are mostly classified
+as `E-medium`, since they might be somewhat involved code wise, but not difficult per-se.
 
 [Llogiq's blog post on lints](https://llogiq.github.io/2015/06/04/workflows.html) is a nice primer
 to lint-writing, though it does get into advanced stuff. Most lints consist of an implementation of
@@ -35,16 +45,14 @@ T-middle issues can be more involved and require verifying types. The
 lot of methods that are useful, though one of the most useful would be `expr_ty` (gives the type of
 an AST expression). `match_def_path()` in Clippy's `utils` module can also be useful.
 
+### Writing code
+
 Compiling clippy can take almost a minute or more depending on your machine.
 You can set the environment flag `CARGO_INCREMENTAL=1` to cut down that time to
 almost a third on average, depending on the influence your change has.
 
-Clippy uses UI tests. UI tests check that the output of the compiler is exactly as expected.
-Of course there's little sense in writing the output yourself or copying it around.
-Therefore you can simply run `tests/ui/update-all-references.sh` and check whether
-the output looks as you expect with `git diff`. Commit all `*.stderr` files, too.
+Please document your lint with a doc comment akin to the following:
 
-Also please document your lint with a doc comment akin to the following:
 ```rust
 /// **What it does:** Checks for ... (describe what the lint matches).
 ///
@@ -58,7 +66,12 @@ Also please document your lint with a doc comment akin to the following:
 /// ```
 ```
 
-Our `util/update_wiki.py` script can then add your lint docs to the wiki.
+### Running test suite
+
+Clippy uses UI tests. UI tests check that the output of the compiler is exactly as expected.
+Of course there's little sense in writing the output yourself or copying it around.
+Therefore you can simply run `tests/ui/update-all-references.sh` and check whether
+the output looks as you expect with `git diff`. Commit all `*.stderr` files, too.
 
 ## Contributions
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.0.149"
+version = "0.0.151"
 authors = [
 	"Manish Goregaokar <[email protected]>",
 	"Andre Bogus <[email protected]>",
@@ -31,7 +31,7 @@ path = "src/main.rs"
 
 [dependencies]
 # begin automatic update
-clippy_lints = { version = "0.0.149", path = "clippy_lints" }
+clippy_lints = { version = "0.0.151", path = "clippy_lints" }
 # end automatic update
 cargo_metadata = "0.2"
 

clippy_lints/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "clippy_lints"
 # begin automatic update
-version = "0.0.149"
+version = "0.0.151"
 # end automatic update
 authors = [
 	"Manish Goregaokar <[email protected]>",

clippy_lints/src/approx_const.rs

@@ -7,9 +7,11 @@ use utils::span_lint;
 
 /// **What it does:** Checks for floating point literals that approximate
 /// constants which are defined in
-/// [`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants)
+/// [`std::f32::consts`](https://doc.rust-lang.
+/// org/stable/std/f32/consts/#constants)
 /// or
-/// [`std::f64::consts`](https://doc.rust-lang.org/stable/std/f64/consts/#constants),
+/// [`std::f64::consts`](https://doc.rust-lang.
+/// org/stable/std/f64/consts/#constants),
 /// respectively, suggesting to use the predefined constant.
 ///
 /// **Why is this bad?** Usually, the definition in the standard library is more
@@ -33,24 +35,26 @@ declare_lint! {
 }
 
 // Tuples are of the form (constant, name, min_digits)
-const KNOWN_CONSTS: &'static [(f64, &'static str, usize)] = &[(f64::E, "E", 4),
-                                                              (f64::FRAC_1_PI, "FRAC_1_PI", 4),
-                                                              (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
-                                                              (f64::FRAC_2_PI, "FRAC_2_PI", 5),
-                                                              (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
-                                                              (f64::FRAC_PI_2, "FRAC_PI_2", 5),
-                                                              (f64::FRAC_PI_3, "FRAC_PI_3", 5),
-                                                              (f64::FRAC_PI_4, "FRAC_PI_4", 5),
-                                                              (f64::FRAC_PI_6, "FRAC_PI_6", 5),
-                                                              (f64::FRAC_PI_8, "FRAC_PI_8", 5),
-                                                              (f64::LN_10, "LN_10", 5),
-                                                              (f64::LN_2, "LN_2", 5),
-                                                              (f64::LOG10_E, "LOG10_E", 5),
-                                                              (f64::LOG2_E, "LOG2_E", 5),
-                                                              (f64::PI, "PI", 3),
-                                                              (f64::SQRT_2, "SQRT_2", 5)];
+const KNOWN_CONSTS: &'static [(f64, &'static str, usize)] = &[
+    (f64::E, "E", 4),
+    (f64::FRAC_1_PI, "FRAC_1_PI", 4),
+    (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
+    (f64::FRAC_2_PI, "FRAC_2_PI", 5),
+    (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
+    (f64::FRAC_PI_2, "FRAC_PI_2", 5),
+    (f64::FRAC_PI_3, "FRAC_PI_3", 5),
+    (f64::FRAC_PI_4, "FRAC_PI_4", 5),
+    (f64::FRAC_PI_6, "FRAC_PI_6", 5),
+    (f64::FRAC_PI_8, "FRAC_PI_8", 5),
+    (f64::LN_10, "LN_10", 5),
+    (f64::LN_2, "LN_2", 5),
+    (f64::LOG10_E, "LOG10_E", 5),
+    (f64::LOG2_E, "LOG2_E", 5),
+    (f64::PI, "PI", 3),
+    (f64::SQRT_2, "SQRT_2", 5),
+];
 
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct Pass;
 
 impl LintPass for Pass {
@@ -81,13 +85,17 @@ fn check_known_consts(cx: &LateContext, e: &Expr, s: &symbol::Symbol, module: &s
     if s.parse::<f64>().is_ok() {
         for &(constant, name, min_digits) in KNOWN_CONSTS {
             if is_approx_const(constant, &s, min_digits) {
-                span_lint(cx,
-                          APPROX_CONSTANT,
-                          e.span,
-                          &format!("approximate value of `{}::consts::{}` found. \
+                span_lint(
+                    cx,
+                    APPROX_CONSTANT,
+                    e.span,
+                    &format!(
+                        "approximate value of `{}::consts::{}` found. \
                                     Consider using it directly",
-                                   module,
-                                   &name));
+                        module,
+                        &name
+                    ),
+                );
                 return;
             }
         }

clippy_lints/src/array_indexing.rs

@@ -8,7 +8,8 @@ use rustc::hir;
 use syntax::ast::RangeLimits;
 use utils::{self, higher};
 
-/// **What it does:** Checks for out of bounds array indexing with a constant index.
+/// **What it does:** Checks for out of bounds array indexing with a constant
+/// index.
 ///
 /// **Why is this bad?** This will always panic at runtime.
 ///
@@ -46,7 +47,7 @@ declare_restriction_lint! {
     "indexing/slicing usage"
 }
 
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct ArrayIndexing;
 
 impl LintPass for ArrayIndexing {
@@ -61,8 +62,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
             // Array with known size can be checked statically
             let ty = cx.tables.expr_ty(array);
             if let ty::TyArray(_, size) = ty.sty {
-                let size = ConstInt::Usize(ConstUsize::new(size as u64, cx.sess().target.uint_type)
-                    .expect("array size is invalid"));
+                let size = ConstInt::Usize(
+                    ConstUsize::new(size as u64, cx.sess().target.uint_type).expect("array size is invalid"),
+                );
                 let parent_item = cx.tcx.hir.get_parent(e.id);
                 let parent_def_id = cx.tcx.hir.local_def_id(parent_item);
                 let substs = Substs::identity_for_item(cx.tcx, parent_def_id);
@@ -80,12 +82,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
 
                 // Index is a constant range
                 if let Some(range) = higher::range(index) {
-                    let start = range.start
-                        .map(|start| constcx.eval(start))
-                        .map(|v| v.ok());
-                    let end = range.end
-                        .map(|end| constcx.eval(end))
-                        .map(|v| v.ok());
+                    let start = range.start.map(|start| constcx.eval(start)).map(|v| v.ok());
+                    let end = range.end.map(|end| constcx.eval(end)).map(|v| v.ok());
 
                     if let Some((start, end)) = to_const_range(&start, &end, range.limits, size) {
                         if start > size || end > size {
@@ -111,12 +109,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
     }
 }
 
-/// Returns an option containing a tuple with the start and end (exclusive) of the range.
+/// Returns an option containing a tuple with the start and end (exclusive) of
+/// the range.
 fn to_const_range(
     start: &Option<Option<ConstVal>>,
     end: &Option<Option<ConstVal>>,
     limits: RangeLimits,
-    array_size: ConstInt
+    array_size: ConstInt,
 ) -> Option<(ConstInt, ConstInt)> {
     let start = match *start {
         Some(Some(ConstVal::Integral(x))) => x,
@@ -128,24 +127,23 @@ fn to_const_range(
         Some(Some(ConstVal::Integral(x))) => {
             if limits == RangeLimits::Closed {
                 match x {
-                        ConstInt::U8(_) => (x + ConstInt::U8(1)),
-                        ConstInt::U16(_) => (x + ConstInt::U16(1)),
-                        ConstInt::U32(_) => (x + ConstInt::U32(1)),
-                        ConstInt::U64(_) => (x + ConstInt::U64(1)),
-                        ConstInt::U128(_) => (x + ConstInt::U128(1)),
-                        ConstInt::Usize(ConstUsize::Us16(_)) => (x + ConstInt::Usize(ConstUsize::Us16(1))),
-                        ConstInt::Usize(ConstUsize::Us32(_)) => (x + ConstInt::Usize(ConstUsize::Us32(1))),
-                        ConstInt::Usize(ConstUsize::Us64(_)) => (x + ConstInt::Usize(ConstUsize::Us64(1))),
-                        ConstInt::I8(_) => (x + ConstInt::I8(1)),
-                        ConstInt::I16(_) => (x + ConstInt::I16(1)),
-                        ConstInt::I32(_) => (x + ConstInt::I32(1)),
-                        ConstInt::I64(_) => (x + ConstInt::I64(1)),
-                        ConstInt::I128(_) => (x + ConstInt::I128(1)),
-                        ConstInt::Isize(ConstIsize::Is16(_)) => (x + ConstInt::Isize(ConstIsize::Is16(1))),
-                        ConstInt::Isize(ConstIsize::Is32(_)) => (x + ConstInt::Isize(ConstIsize::Is32(1))),
-                        ConstInt::Isize(ConstIsize::Is64(_)) => (x + ConstInt::Isize(ConstIsize::Is64(1))),
-                    }
-                    .expect("such a big array is not realistic")
+                    ConstInt::U8(_) => (x + ConstInt::U8(1)),
+                    ConstInt::U16(_) => (x + ConstInt::U16(1)),
+                    ConstInt::U32(_) => (x + ConstInt::U32(1)),
+                    ConstInt::U64(_) => (x + ConstInt::U64(1)),
+                    ConstInt::U128(_) => (x + ConstInt::U128(1)),
+                    ConstInt::Usize(ConstUsize::Us16(_)) => (x + ConstInt::Usize(ConstUsize::Us16(1))),
+                    ConstInt::Usize(ConstUsize::Us32(_)) => (x + ConstInt::Usize(ConstUsize::Us32(1))),
+                    ConstInt::Usize(ConstUsize::Us64(_)) => (x + ConstInt::Usize(ConstUsize::Us64(1))),
+                    ConstInt::I8(_) => (x + ConstInt::I8(1)),
+                    ConstInt::I16(_) => (x + ConstInt::I16(1)),
+                    ConstInt::I32(_) => (x + ConstInt::I32(1)),
+                    ConstInt::I64(_) => (x + ConstInt::I64(1)),
+                    ConstInt::I128(_) => (x + ConstInt::I128(1)),
+                    ConstInt::Isize(ConstIsize::Is16(_)) => (x + ConstInt::Isize(ConstIsize::Is16(1))),
+                    ConstInt::Isize(ConstIsize::Is32(_)) => (x + ConstInt::Isize(ConstIsize::Is32(1))),
+                    ConstInt::Isize(ConstIsize::Is64(_)) => (x + ConstInt::Isize(ConstIsize::Is64(1))),
+                }.expect("such a big array is not realistic")
             } else {
                 x
             }