diff --git a/src/escape.rs b/src/escape.rs
index 21bf30e131c6..4b6a8258dbe5 100644
--- a/src/escape.rs
+++ b/src/escape.rs
@@ -16,9 +16,9 @@ pub struct EscapePass;
 
 /// **What it does:** This lint checks for usage of `Box<T>` where an unboxed `T` would work fine. It is `Warn` by default.
 ///
-/// **Why is this bad?** This is an unnecessary allocation, and bad for performance
+/// **Why is this bad?** This is an unnecessary allocation, and bad for performance. It is only necessary to allocate if you wish to move the box into something.
 ///
-/// It is only necessary to allocate if you wish to move the box into something.
+/// **Known problems:** None
 ///
 /// **Example:**
 ///
diff --git a/src/mut_reference.rs b/src/mut_reference.rs
index 133462071e43..ddfd9ddcc13a 100644
--- a/src/mut_reference.rs
+++ b/src/mut_reference.rs
@@ -36,7 +36,7 @@ impl LateLintPass for UnnecessaryMutPassed {
                 match borrowed_table.node_types.get(&fn_expr.id) {
                     Some(function_type) => {
                         if let ExprPath(_, ref path) = fn_expr.node {
-                            check_arguments(cx, &arguments, function_type, 
+                            check_arguments(cx, &arguments, function_type,
                                             &format!("{}", path));
                         }
                     }
@@ -50,7 +50,7 @@ impl LateLintPass for UnnecessaryMutPassed {
             ExprMethodCall(ref name, _, ref arguments) => {
                 let method_call = MethodCall::expr(e.id);
                 match borrowed_table.method_map.get(&method_call) {
-                    Some(method_type) => check_arguments(cx, &arguments, method_type.ty, 
+                    Some(method_type) => check_arguments(cx, &arguments, method_type.ty,
                                                          &format!("{}", name.node.as_str())),
                     None => unreachable!(), // Just like above, this should never happen.
                 };
@@ -68,9 +68,9 @@ fn check_arguments(cx: &LateContext, arguments: &[P<Expr>], type_definition: &Ty
                 TypeVariants::TyRef(_, TypeAndMut {mutbl: MutImmutable, ..}) |
                 TypeVariants::TyRawPtr(TypeAndMut {mutbl: MutImmutable, ..}) => {
                     if let ExprAddrOf(MutMutable, _) = argument.node {
-                        span_lint(cx, UNNECESSARY_MUT_PASSED, 
+                        span_lint(cx, UNNECESSARY_MUT_PASSED,
                                   argument.span, &format!("The function/method \"{}\" \
-                                  doesn't need a mutable reference", 
+                                  doesn't need a mutable reference",
                                   name));
                     }
                 }
diff --git a/src/precedence.rs b/src/precedence.rs
index 39a3e9e56c29..3aae9fd0d6c3 100644
--- a/src/precedence.rs
+++ b/src/precedence.rs
@@ -4,7 +4,7 @@ use syntax::ast::*;
 
 use utils::{span_lint, snippet};
 
-/// **What it does:** This lint checks for operations where precedence may be unclear and `Warn`'s about them by default, suggesting to add parentheses. Currently it catches the following:
+/// **What it does:** This lint checks for operations where precedence may be unclear and `Warn`s about them by default, suggesting to add parentheses. Currently it catches the following:
 /// * mixed usage of arithmetic and bit shifting/combining operators without parentheses
 /// * a "negative" numeric literal (which is really a unary `-` followed by a numeric literal) followed by a method call
 ///
@@ -33,17 +33,17 @@ impl EarlyLintPass for Precedence {
         if let ExprBinary(Spanned { node: op, ..}, ref left, ref right) = expr.node {
             if !is_bit_op(op) { return; }
             match (is_arith_expr(left), is_arith_expr(right)) {
-                (true, true) =>  span_lint(cx, PRECEDENCE, expr.span, 
+                (true, true) =>  span_lint(cx, PRECEDENCE, expr.span,
                     &format!("operator precedence can trip the unwary. \
                          Consider parenthesizing your expression:\
                          `({}) {} ({})`", snippet(cx, left.span, ".."),
                          op.to_string(), snippet(cx, right.span, ".."))),
-                (true, false) => span_lint(cx, PRECEDENCE, expr.span, 
+                (true, false) => span_lint(cx, PRECEDENCE, expr.span,
                     &format!("operator precedence can trip the unwary. \
                          Consider parenthesizing your expression:\
                          `({}) {} {}`", snippet(cx, left.span, ".."),
                          op.to_string(), snippet(cx, right.span, ".."))),
-                (false, true) => span_lint(cx, PRECEDENCE, expr.span, 
+                (false, true) => span_lint(cx, PRECEDENCE, expr.span,
                     &format!("operator precedence can trip the unwary. \
                          Consider parenthesizing your expression:\
                          `{} {} ({})`", snippet(cx, left.span, ".."),