Various cosmetic improvements.

Author: Alexander Regueiro

clippy_dev/src/lib.rs

@@ -189,7 +189,7 @@ pub struct FileChange {
     pub new_lines: String,
 }
 
-/// Replace a region in a file delimited by two lines matching regexes.
+/// Replaces a region in a file delimited by two lines matching regexes.
 ///
 /// `path` is the relative path to the file on which you want to perform the replacement.
 ///
@@ -223,7 +223,7 @@ where
     file_change
 }
 
-/// Replace a region in a text delimited by two lines matching regexes.
+/// Replaces a region in a text delimited by two lines matching regexes.
 ///
 /// * `text` is the input text on which you want to perform the replacement
 /// * `start` is a `&str` that describes the delimiter line before the region you want to replace.

clippy_lints/src/approx_const.rs

@@ -104,7 +104,7 @@ fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, mod
     }
 }
 
-/// Returns false if the number of significant figures in `value` are
+/// Returns `false` if the number of significant figures in `value` are
 /// less than `min_digits`; otherwise, returns true if `value` is equal
 /// to `constant`, rounded to the number of digits present in `value`.
 fn is_approx_const(constant: f64, value: &str, min_digits: usize) -> bool {

clippy_lints/src/assertions_on_constants.rs

@@ -1,12 +1,13 @@
+use if_chain::if_chain;
+use rustc::hir::{Expr, ExprKind};
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::{declare_tool_lint, lint_array};
+
 use crate::consts::{constant, Constant};
-use crate::rustc::hir::{Expr, ExprKind};
-use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use crate::rustc::{declare_tool_lint, lint_array};
 use crate::syntax::ast::LitKind;
 use crate::utils::{in_macro, is_direct_expn_of, span_help_and_lint};
-use if_chain::if_chain;
 
-/// **What it does:** Check to call assert!(true/false)
+/// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.
 ///
 /// **Why is this bad?** Will be optimized out by the compiler or should probably be replaced by a
 /// panic!() or unreachable!()
@@ -25,7 +26,8 @@ use if_chain::if_chain;
 declare_clippy_lint! {
     pub ASSERTIONS_ON_CONSTANTS,
     style,
-    "assert!(true/false) will be optimized out by the compiler/should probably be replaced by a panic!() or unreachable!()"
+    "`assert!(true)` / `assert!(false)` will be optimized out by the compiler, \
+     and should probably be replaced by a `panic!()` or `unreachable!()`"
 }
 
 pub struct AssertionsOnConstants;

clippy_lints/src/assign_ops.rs

@@ -1,13 +1,14 @@
-use crate::utils::{get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, SpanlessEq};
-use crate::utils::{higher, sugg};
 use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc::hir;
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_tool_lint, lint_array};
-use rustc_errors::Applicability;
 use syntax::ast;
 
+use crate::utils::{get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, SpanlessEq};
+use crate::utils::{higher, sugg};
+
 /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a`
 /// patterns.
 ///
@@ -34,7 +35,7 @@ declare_clippy_lint! {
 /// op= b`.
 ///
 /// **Known problems:** Clippy cannot know for sure if `a op= a op b` should have
-/// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore it suggests both.
+/// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
 /// If `a op= a op b` is really the correct behaviour it should be
 /// written as `a = a op a op b` as it's less confusing.
 ///

clippy_lints/src/bit_mask.rs

@@ -70,7 +70,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     pub INEFFECTIVE_BIT_MASK,
     correctness,
-    "expressions where a bit mask will be rendered useless by a comparison, e.g. `(x | 1) > 2`"
+    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
 }
 
 /// **What it does:** Checks for bit masks that can be replaced by a call

clippy_lints/src/block_in_if_condition.rs

@@ -20,7 +20,7 @@ use rustc::{declare_tool_lint, lint_array};
 declare_clippy_lint! {
     pub BLOCK_IN_IF_CONDITION_EXPR,
     style,
-    "braces that can be eliminated in conditions, e.g. `if { true } ...`"
+    "braces that can be eliminated in conditions, e.g., `if { true } ...`"
 }
 
 /// **What it does:** Checks for `if` conditions that use blocks containing
@@ -39,7 +39,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     pub BLOCK_IN_IF_CONDITION_STMT,
     style,
-    "complex blocks in conditions, e.g. `if { let x = true; x } ...`"
+    "complex blocks in conditions, e.g., `if { let x = true; x } ...`"
 }
 
 #[derive(Copy, Clone)]

clippy_lints/src/collapsible_if.rs

@@ -68,7 +68,7 @@ use rustc_errors::Applicability;
 declare_clippy_lint! {
     pub COLLAPSIBLE_IF,
     style,
-    "`if`s that can be collapsed (e.g. `if x { if y { ... } }` and `else { if x { ... } }`)"
+    "`if`s that can be collapsed (e.g., `if x { if y { ... } }` and `else { if x { ... } }`)"
 }
 
 #[derive(Copy, Clone)]

clippy_lints/src/consts.rs

@@ -21,27 +21,27 @@ use syntax_pos::symbol::Symbol;
 /// A `LitKind`-like enum to fold constant `Expr`s into.
 #[derive(Debug, Clone)]
 pub enum Constant {
-    /// a String "abc"
+    /// A `String` (e.g., "abc").
     Str(String),
-    /// a Binary String b"abc"
+    /// A binary string (e.g., `b"abc"`).
     Binary(Lrc<Vec<u8>>),
-    /// a single char 'a'
+    /// A single `char` (e.g., `'a'`).
     Char(char),
-    /// an integer's bit representation
+    /// An integer's bit representation.
     Int(u128),
-    /// an f32
+    /// An `f32`.
     F32(f32),
-    /// an f64
+    /// An `f64`
     F64(f64),
-    /// true or false
+    /// A `bool` (i.e., `true` or `false`).
     Bool(bool),
-    /// an array of constants
+    /// An array of constants
     Vec(Vec<Constant>),
-    /// also an array, but with only one constant, repeated N times
+    /// Also an array, but with only one constant, repeated `N` times.
     Repeat(Box<Constant>, u64),
-    /// a tuple of constants
+    /// A tuple of constants.
     Tuple(Vec<Constant>),
-    /// a literal with syntax error
+    /// A literal with a syntax error.
     Err(Symbol),
 }
 

clippy_lints/src/copies.rs

@@ -239,9 +239,9 @@ fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
     }
 }
 
-/// Return the list of condition expressions and the list of blocks in a
+/// Returns the list of condition expressions and the list of blocks in a
 /// sequence of `if/else`.
-/// Eg. would return `([a, b], [c, d, e])` for the expression
+/// E.g., this returns `([a, b], [c, d, e])` for the expression
 /// `if a { c } else if b { d } else { e }`.
 fn if_sequence(mut expr: &Expr) -> (SmallVec<[&Expr; 1]>, SmallVec<[&Block; 1]>) {
     let mut conds = SmallVec::new();
@@ -272,7 +272,7 @@ fn if_sequence(mut expr: &Expr) -> (SmallVec<[&Expr; 1]>, SmallVec<[&Block; 1]>)
     (conds, blocks)
 }
 
-/// Return the list of bindings in a pattern.
+/// Returns the list of bindings in a pattern.
 fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> FxHashMap<LocalInternedString, Ty<'tcx>> {
     fn bindings_impl<'a, 'tcx>(
         cx: &LateContext<'a, 'tcx>,

clippy_lints/src/deprecated_lints.rs

@@ -90,7 +90,7 @@ declare_deprecated_lint! {
 /// counterparts, so this lint may suggest a change in behavior or the code may not compile.
 declare_deprecated_lint! {
     pub ASSIGN_OPS,
-    "using compound assignment operators (e.g. `+=`) is harmless"
+    "using compound assignment operators (e.g., `+=`) is harmless"
 }
 
 /// **What it does:** Nothing. This lint has been deprecated.

clippy_lints/src/doc.rs

@@ -257,8 +257,8 @@ fn check_text(cx: &EarlyContext<'_>, valid_idents: &FxHashSet<String>, text: &st
 }
 
 fn check_word(cx: &EarlyContext<'_>, word: &str, span: Span) {
-    /// Checks if a string is camel-case, ie. contains at least two uppercase
-    /// letter (`Clippy` is
+    /// Checks if a string is camel-case, i.e., contains at least two uppercase
+    /// letters (`Clippy` is
     /// ok) and one lower-case letter (`NASA` is ok). Plural are also excluded
     /// (`IDs` is ok).
     fn is_camel_case(s: &str) -> bool {

clippy_lints/src/else_if_without_else.rs

@@ -9,7 +9,7 @@ use crate::utils::span_help_and_lint;
 /// **What it does:** Checks for usage of if expressions with an `else if` branch,
 /// but without a final `else` branch.
 ///
-/// **Why is this bad?** Some coding guidelines require this (e.g. MISRA-C:2004 Rule 14.10).
+/// **Why is this bad?** Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).
 ///
 /// **Known problems:** None.
 ///

clippy_lints/src/eq_op.rs

@@ -24,7 +24,7 @@ use rustc_errors::Applicability;
 declare_clippy_lint! {
     pub EQ_OP,
     correctness,
-    "equal operands on both sides of a comparison or bitwise combination (e.g. `x == x`)"
+    "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
 }
 
 /// **What it does:** Checks for arguments to `==` which have their address

clippy_lints/src/erasing_op.rs

@@ -5,7 +5,7 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_tool_lint, lint_array};
 use syntax::source_map::Span;
 
-/// **What it does:** Checks for erasing operations, e.g. `x * 0`.
+/// **What it does:** Checks for erasing operations, e.g., `x * 0`.
 ///
 /// **Why is this bad?** The whole expression can be replaced by zero.
 /// This is most likely not the intended outcome and should probably be
@@ -22,7 +22,7 @@ use syntax::source_map::Span;
 declare_clippy_lint! {
     pub ERASING_OP,
     correctness,
-    "using erasing operations, e.g. `x * 0` or `y & 0`"
+    "using erasing operations, e.g., `x * 0` or `y & 0`"
 }
 
 #[derive(Copy, Clone)]

clippy_lints/src/escape.rs

@@ -68,7 +68,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         _: Span,
         node_id: NodeId,
     ) {
-        // If the method is an impl for a trait, don't warn
+        // If the method is an impl for a trait, don't warn.
         let parent_id = cx.tcx.hir().get_parent(node_id);
         let parent_node = cx.tcx.hir().find(parent_id);
 
@@ -103,7 +103,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
     fn consume(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, mode: ConsumeMode) {
         if let Categorization::Local(lid) = cmt.cat {
             if let Move(DirectRefMove) = mode {
-                // moved out or in. clearly can't be localized
+                // Moved out or in. Clearly can't be localized.
                 self.set.remove(&lid);
             }
         }
@@ -159,20 +159,20 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
     ) {
         if let Categorization::Local(lid) = cmt.cat {
             match loan_cause {
-                // x.foo()
-                // Used without autodereffing (i.e. x.clone())
+                // `x.foo()`
+                // Used without autoderef-ing (i.e., `x.clone()`).
                 LoanCause::AutoRef |
 
-                // &x
-                // foo(&x) where no extra autoreffing is happening
+                // `&x`
+                // `foo(&x)` where no extra autoref-ing is happening.
                 LoanCause::AddrOf |
 
-                // `match x` can move
+                // `match x` can move.
                 LoanCause::MatchDiscriminant => {
                     self.set.remove(&lid);
                 }
 
-                // do nothing for matches, etc. These can't escape
+                // Do nothing for matches, etc. These can't escape.
                 _ => {}
             }
         }
@@ -183,8 +183,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
 
 impl<'a, 'tcx> EscapeDelegate<'a, 'tcx> {
     fn is_large_box(&self, ty: Ty<'tcx>) -> bool {
-        // Large types need to be boxed to avoid stack
-        // overflows.
+        // Large types need to be boxed to avoid stack overflows.
         if ty.is_box() {
             self.cx.layout_of(ty.boxed_ty()).ok().map_or(0, |l| l.size.bytes()) > self.too_large_for_stack
         } else {

clippy_lints/src/eta_reduction.rs

@@ -18,8 +18,7 @@ pub struct EtaPass;
 /// **Known problems:** If creating the closure inside the closure has a side-
 /// effect then moving the closure creation out will change when that side-
 /// effect runs.
-/// See https://github.com/rust-lang/rust-clippy/issues/1439 for more
-/// details.
+/// See rust-lang/rust-clippy#1439 for more details.
 ///
 /// **Example:**
 /// ```rust
@@ -30,7 +29,7 @@ pub struct EtaPass;
 declare_clippy_lint! {
     pub REDUNDANT_CLOSURE,
     style,
-    "redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)"
+    "redundant closures, i.e., `|a| foo(a)` (which can be written as just `foo`)"
 }
 
 impl LintPass for EtaPass {

clippy_lints/src/eval_order_dependence.rs

@@ -286,7 +286,7 @@ fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> St
 /// A visitor that looks for reads from a variable.
 struct ReadVisitor<'a, 'tcx: 'a> {
     cx: &'a LateContext<'a, 'tcx>,
-    /// The id of the variable we're looking for.
+    /// The ID of the variable we're looking for.
     var: ast::NodeId,
     /// The expressions where the write to the variable occurred (for reporting
     /// in the lint).
@@ -351,7 +351,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
     }
 }
 
-/// Returns true if `expr` is the LHS of an assignment, like `expr = ...`.
+/// Returns `true` if `expr` is the LHS of an assignment, like `expr = ...`.
 fn is_in_assignment_position(cx: &LateContext<'_, '_>, expr: &Expr) -> bool {
     if let Some(parent) = get_parent_expr(cx, expr) {
         if let ExprKind::Assign(ref lhs, _) = parent.node {

clippy_lints/src/identity_op.rs

@@ -6,7 +6,7 @@ use rustc::ty;
 use rustc::{declare_tool_lint, lint_array};
 use syntax::source_map::Span;
 
-/// **What it does:** Checks for identity operations, e.g. `x + 0`.
+/// **What it does:** Checks for identity operations, e.g., `x + 0`.
 ///
 /// **Why is this bad?** This code can be removed without changing the
 /// meaning. So it just obscures what's going on. Delete it mercilessly.
@@ -20,7 +20,7 @@ use syntax::source_map::Span;
 declare_clippy_lint! {
     pub IDENTITY_OP,
     complexity,
-    "using identity operations, e.g. `x + 0` or `y / 1`"
+    "using identity operations, e.g., `x + 0` or `y / 1`"
 }
 
 #[derive(Copy, Clone)]

clippy_lints/src/indexing_slicing.rs

@@ -102,7 +102,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IndexingSlicing {
         if let ExprKind::Index(ref array, ref index) = &expr.node {
             let ty = cx.tables.expr_ty(array);
             if let Some(range) = higher::range(cx, index) {
-                // Ranged indexes, i.e. &x[n..m], &x[n..], &x[..n] and &x[..]
+                // Ranged indexes, i.e., &x[n..m], &x[n..], &x[..n] and &x[..]
                 if let ty::Array(_, s) = ty.sty {
                     let size: u128 = s.assert_usize(cx.tcx).unwrap().into();
 
@@ -148,7 +148,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IndexingSlicing {
 
                 utils::span_help_and_lint(cx, INDEXING_SLICING, expr.span, "slicing may panic.", help_msg);
             } else {
-                // Catchall non-range index, i.e. [n] or [n << m]
+                // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.sty {
                     // Index is a constant uint.
                     if let Some(..) = constant(cx, cx.tables, index) {

clippy_lints/src/infinite_iter.rs

@@ -6,7 +6,7 @@ use rustc::{declare_tool_lint, lint_array};
 /// **What it does:** Checks for iteration that is guaranteed to be infinite.
 ///
 /// **Why is this bad?** While there may be places where this is acceptable
-/// (e.g. in event streams), in most cases this is simply an error.
+/// (e.g., in event streams), in most cases this is simply an error.
 ///
 /// **Known problems:** None.
 ///
@@ -23,7 +23,7 @@ declare_clippy_lint! {
 /// **What it does:** Checks for iteration that may be infinite.
 ///
 /// **Why is this bad?** While there may be places where this is acceptable
-/// (e.g. in event streams), in most cases this is simply an error.
+/// (e.g., in event streams), in most cases this is simply an error.
 ///
 /// **Known problems:** The code may have a condition to stop iteration, but
 /// this lint is not clever enough to analyze it.
@@ -120,8 +120,8 @@ use self::Heuristic::{All, Always, Any, First};
 /// a slice of (method name, number of args, heuristic, bounds) tuples
 /// that will be used to determine whether the method in question
 /// returns an infinite or possibly infinite iterator. The finiteness
-/// is an upper bound, e.g. some methods can return a possibly
-/// infinite iterator at worst, e.g. `take_while`.
+/// is an upper bound, e.g., some methods can return a possibly
+/// infinite iterator at worst, e.g., `take_while`.
 static HEURISTICS: &[(&str, usize, Heuristic, Finiteness)] = &[
     ("zip", 2, All, Infinite),
     ("chain", 2, Any, Infinite),