Merge pull request #2949 from rust-lang-nursery/preexpansion

Rewrite the print/write macro checks as a PreExpansionPass

clippy_lints/src/approx_const.rs

@@ -70,7 +70,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 }
 
-fn check_lit(cx: &LateContext, lit: &Lit, e: &Expr) {
+fn check_lit(cx: &LateContext<'_, '_>, lit: &Lit, e: &Expr) {
     match lit.node {
         LitKind::Float(s, FloatTy::F32) => check_known_consts(cx, e, s, "f32"),
         LitKind::Float(s, FloatTy::F64) => check_known_consts(cx, e, s, "f64"),
@@ -79,7 +79,7 @@ fn check_lit(cx: &LateContext, lit: &Lit, e: &Expr) {
     }
 }
 
-fn check_known_consts(cx: &LateContext, e: &Expr, s: symbol::Symbol, module: &str) {
+fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, module: &str) {
     let s = s.as_str();
     if s.parse::<f64>().is_ok() {
         for &(constant, name, min_digits) in KNOWN_CONSTS {

clippy_lints/src/attrs.rs

@@ -226,22 +226,22 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
     }
 }
 
-fn is_relevant_item(tcx: TyCtxt, item: &Item) -> bool {
+fn is_relevant_item(tcx: TyCtxt<'_, '_, '_>, item: &Item) -> bool {
     if let ItemKind::Fn(_, _, _, eid) = item.node {
         is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
     } else {
         true
     }
 }
 
-fn is_relevant_impl(tcx: TyCtxt, item: &ImplItem) -> bool {
+fn is_relevant_impl(tcx: TyCtxt<'_, '_, '_>, item: &ImplItem) -> bool {
     match item.node {
         ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value),
         _ => false,
     }
 }
 
-fn is_relevant_trait(tcx: TyCtxt, item: &TraitItem) -> bool {
+fn is_relevant_trait(tcx: TyCtxt<'_, '_, '_>, item: &TraitItem) -> bool {
     match item.node {
         TraitItemKind::Method(_, TraitMethod::Required(_)) => true,
         TraitItemKind::Method(_, TraitMethod::Provided(eid)) => {
@@ -251,7 +251,7 @@ fn is_relevant_trait(tcx: TyCtxt, item: &TraitItem) -> bool {
     }
 }
 
-fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> bool {
+fn is_relevant_block(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, block: &Block) -> bool {
     if let Some(stmt) = block.stmts.first() {
         match stmt.node {
             StmtKind::Decl(_, _) => true,
@@ -262,7 +262,7 @@ fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> b
     }
 }
 
-fn is_relevant_expr(tcx: TyCtxt, tables: &ty::TypeckTables, expr: &Expr) -> bool {
+fn is_relevant_expr(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr) -> bool {
     match expr.node {
         ExprKind::Block(ref block, _) => is_relevant_block(tcx, tables, block),
         ExprKind::Ret(Some(ref e)) => is_relevant_expr(tcx, tables, e),
@@ -280,7 +280,7 @@ fn is_relevant_expr(tcx: TyCtxt, tables: &ty::TypeckTables, expr: &Expr) -> bool
     }
 }
 
-fn check_attrs(cx: &LateContext, span: Span, name: Name, attrs: &[Attribute]) {
+fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attribute]) {
     if in_macro(span) {
         return;
     }
@@ -331,7 +331,7 @@ fn check_attrs(cx: &LateContext, span: Span, name: Name, attrs: &[Attribute]) {
     }
 }
 
-fn check_semver(cx: &LateContext, span: Span, lit: &Lit) {
+fn check_semver(cx: &LateContext<'_, '_>, span: Span, lit: &Lit) {
     if let LitKind::Str(ref is, _) = lit.node {
         if Version::parse(&is.as_str()).is_ok() {
             return;
@@ -358,7 +358,7 @@ fn is_word(nmi: &NestedMetaItem, expected: &str) -> bool {
 // sources that the user has no control over.
 // For some reason these attributes don't have any expansion info on them, so
 // we have to check it this way until there is a better way.
-fn is_present_in_source(cx: &LateContext, span: Span) -> bool {
+fn is_present_in_source(cx: &LateContext<'_, '_>, span: Span) -> bool {
     if let Some(snippet) = snippet_opt(cx, span) {
         if snippet.is_empty() {
             return false;

clippy_lints/src/bit_mask.rs

@@ -158,7 +158,7 @@ fn invert_cmp(cmp: BinOpKind) -> BinOpKind {
 }
 
 
-fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
+fn check_compare(cx: &LateContext<'_, '_>, bit_op: &Expr, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
     if let ExprKind::Binary(ref op, ref left, ref right) = bit_op.node {
         if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr {
             return;
@@ -169,7 +169,7 @@ fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOpKind, cmp_value:
     }
 }
 
-fn check_bit_mask(cx: &LateContext, bit_op: BinOpKind, cmp_op: BinOpKind, mask_value: u128, cmp_value: u128, span: Span) {
+fn check_bit_mask(cx: &LateContext<'_, '_>, bit_op: BinOpKind, cmp_op: BinOpKind, mask_value: u128, cmp_value: u128, span: Span) {
     match cmp_op {
         BinOpKind::Eq | BinOpKind::Ne => match bit_op {
             BinOpKind::BitAnd => if mask_value & cmp_value != cmp_value {
@@ -270,7 +270,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOpKind, cmp_op: BinOpKind, mask_v
     }
 }
 
-fn check_ineffective_lt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str) {
+fn check_ineffective_lt(cx: &LateContext<'_, '_>, span: Span, m: u128, c: u128, op: &str) {
     if c.is_power_of_two() && m < c {
         span_lint(
             cx,
@@ -286,7 +286,7 @@ fn check_ineffective_lt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str
     }
 }
 
-fn check_ineffective_gt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str) {
+fn check_ineffective_gt(cx: &LateContext<'_, '_>, span: Span, m: u128, c: u128, op: &str) {
     if (c + 1).is_power_of_two() && m <= c {
         span_lint(
             cx,
@@ -302,7 +302,7 @@ fn check_ineffective_gt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str
     }
 }
 
-fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option<u128> {
+fn fetch_int_literal(cx: &LateContext<'_, '_>, lit: &Expr) -> Option<u128> {
     match constant(cx, cx.tables, lit)?.0 {
         Constant::Int(n) => Some(n),
         _ => None,

clippy_lints/src/booleans.rs

@@ -275,7 +275,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
 }
 
 // The boolean part of the return indicates whether some simplifications have been applied.
-fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> (String, bool) {
+fn suggest(cx: &LateContext<'_, '_>, suggestion: &Bool, terminals: &[&Expr]) -> (String, bool) {
     let mut suggest_context = SuggestContext {
         terminals,
         cx,

clippy_lints/src/bytecount.rs

@@ -38,7 +38,7 @@ impl LintPass for ByteCount {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
-    fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr) {
         if_chain! {
             if let ExprKind::MethodCall(ref count, _, ref count_args) = expr.node;
             if count.ident.name == "count";

clippy_lints/src/collapsible_if.rs

@@ -80,14 +80,14 @@ impl LintPass for CollapsibleIf {
 }
 
 impl EarlyLintPass for CollapsibleIf {
-    fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
         if !in_macro(expr.span) {
             check_if(cx, expr)
         }
     }
 }
 
-fn check_if(cx: &EarlyContext, expr: &ast::Expr) {
+fn check_if(cx: &EarlyContext<'_>, expr: &ast::Expr) {
     match expr.node {
         ast::ExprKind::If(ref check, ref then, ref else_) => if let Some(ref else_) = *else_ {
             check_collapsible_maybe_if_let(cx, else_);
@@ -101,7 +101,7 @@ fn check_if(cx: &EarlyContext, expr: &ast::Expr) {
     }
 }
 
-fn check_collapsible_maybe_if_let(cx: &EarlyContext, else_: &ast::Expr) {
+fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Block(ref block, _) = else_.node;
         if let Some(else_) = expr_block(block);
@@ -122,7 +122,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext, else_: &ast::Expr) {
     }
 }
 
-fn check_collapsible_no_if_let(cx: &EarlyContext, expr: &ast::Expr, check: &ast::Expr, then: &ast::Block) {
+fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &ast::Expr, then: &ast::Block) {
     if_chain! {
         if let Some(inner) = expr_block(then);
         if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.node;

clippy_lints/src/const_static_lifetime.rs

@@ -35,7 +35,7 @@ impl LintPass for StaticConst {
 
 impl StaticConst {
     // Recursively visit types
-    fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext) {
+    fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>) {
         match ty.node {
             // Be careful of nested structures (arrays and tuples)
             TyKind::Array(ref ty, _) => {
@@ -79,7 +79,7 @@ impl StaticConst {
 }
 
 impl EarlyLintPass for StaticConst {
-    fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if !in_macro(item.span) {
             // Match only constants...
             if let ItemKind::Const(ref var_type, _) = item.node {

clippy_lints/src/consts.rs

@@ -123,7 +123,7 @@ impl Hash for Constant {
 }
 
 impl Constant {
-    pub fn partial_cmp(tcx: TyCtxt, cmp_type: &ty::TypeVariants, left: &Self, right: &Self) -> Option<Ordering> {
+    pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: &ty::TypeVariants<'_>, left: &Self, right: &Self) -> Option<Ordering> {
         match (left, right) {
             (&Constant::Str(ref ls), &Constant::Str(ref rs)) => Some(ls.cmp(rs)),
             (&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)),
@@ -236,7 +236,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
         }
     }
 
-    fn constant_not(&self, o: &Constant, ty: ty::Ty) -> Option<Constant> {
+    fn constant_not(&self, o: &Constant, ty: ty::Ty<'_>) -> Option<Constant> {
         use self::Constant::*;
         match *o {
             Bool(b) => Some(Bool(!b)),
@@ -252,7 +252,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
         }
     }
 
-    fn constant_negate(&self, o: &Constant, ty: ty::Ty) -> Option<Constant> {
+    fn constant_negate(&self, o: &Constant, ty: ty::Ty<'_>) -> Option<Constant> {
         use self::Constant::*;
         match *o {
             Int(value) => {

clippy_lints/src/copies.rs

@@ -134,7 +134,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste {
 }
 
 /// Implementation of `IF_SAME_THEN_ELSE`.
-fn lint_same_then_else(cx: &LateContext, blocks: &[&Block]) {
+fn lint_same_then_else(cx: &LateContext<'_, '_>, blocks: &[&Block]) {
     let eq: &dyn Fn(&&Block, &&Block) -> bool = &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).eq_block(lhs, rhs) };
 
     if let Some((i, j)) = search_same_sequenced(blocks, eq) {
@@ -150,7 +150,7 @@ fn lint_same_then_else(cx: &LateContext, blocks: &[&Block]) {
 }
 
 /// Implementation of `IFS_SAME_COND`.
-fn lint_same_cond(cx: &LateContext, conds: &[&Expr]) {
+fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr]) {
     let hash: &dyn Fn(&&Expr) -> u64 = &|expr| -> u64 {
         let mut h = SpanlessHash::new(cx, cx.tables);
         h.hash_expr(expr);
@@ -172,7 +172,7 @@ fn lint_same_cond(cx: &LateContext, conds: &[&Expr]) {
 }
 
 /// Implementation of `MATCH_SAME_ARMS`.
-fn lint_match_arms(cx: &LateContext, expr: &Expr) {
+fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
     if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.node {
         let hash = |&(_, arm): &(usize, &Arm)| -> u64 {
             let mut h = SpanlessHash::new(cx, cx.tables);

clippy_lints/src/cyclomatic_complexity.rs

@@ -187,7 +187,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> {
 
 #[cfg(feature = "debugging")]
 #[allow(too_many_arguments)]
-fn report_cc_bug(_: &LateContext, cc: u64, narms: u64, div: u64, shorts: u64, returns: u64, span: Span, _: NodeId) {
+fn report_cc_bug(_: &LateContext<'_, '_>, cc: u64, narms: u64, div: u64, shorts: u64, returns: u64, span: Span, _: NodeId) {
     span_bug!(
         span,
         "Clippy encountered a bug calculating cyclomatic complexity: cc = {}, arms = {}, \
@@ -201,7 +201,7 @@ fn report_cc_bug(_: &LateContext, cc: u64, narms: u64, div: u64, shorts: u64, re
 }
 #[cfg(not(feature = "debugging"))]
 #[allow(too_many_arguments)]
-fn report_cc_bug(cx: &LateContext, cc: u64, narms: u64, div: u64, shorts: u64, returns: u64, span: Span, id: NodeId) {
+fn report_cc_bug(cx: &LateContext<'_, '_>, cc: u64, narms: u64, div: u64, shorts: u64, returns: u64, span: Span, id: NodeId) {
     if !is_allowed(cx, CYCLOMATIC_COMPLEXITY, id) {
         cx.sess().span_note_without_error(
             span,

clippy_lints/src/doc.rs

@@ -52,11 +52,11 @@ impl LintPass for Doc {
 }
 
 impl EarlyLintPass for Doc {
-    fn check_crate(&mut self, cx: &EarlyContext, krate: &ast::Crate) {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &ast::Crate) {
         check_attrs(cx, &self.valid_idents, &krate.attrs);
     }
 
-    fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
         check_attrs(cx, &self.valid_idents, &item.attrs);
     }
 }
@@ -139,7 +139,7 @@ pub fn strip_doc_comment_decoration(comment: &str, span: Span) -> (String, Vec<(
     panic!("not a doc-comment: {}", comment);
 }
 
-pub fn check_attrs<'a>(cx: &EarlyContext, valid_idents: &[String], attrs: &'a [ast::Attribute]) {
+pub fn check_attrs<'a>(cx: &EarlyContext<'_>, valid_idents: &[String], attrs: &'a [ast::Attribute]) {
     let mut doc = String::new();
     let mut spans = vec![];
 
@@ -186,7 +186,7 @@ pub fn check_attrs<'a>(cx: &EarlyContext, valid_idents: &[String], attrs: &'a [a
 }
 
 fn check_doc<'a, Events: Iterator<Item = (usize, pulldown_cmark::Event<'a>)>>(
-    cx: &EarlyContext,
+    cx: &EarlyContext<'_>,
     valid_idents: &[String],
     docs: Events,
     spans: &[(usize, Span)],
@@ -232,7 +232,7 @@ fn check_doc<'a, Events: Iterator<Item = (usize, pulldown_cmark::Event<'a>)>>(
     }
 }
 
-fn check_text(cx: &EarlyContext, valid_idents: &[String], text: &str, span: Span) {
+fn check_text(cx: &EarlyContext<'_>, valid_idents: &[String], text: &str, span: Span) {
     for word in text.split_whitespace() {
         // Trim punctuation as in `some comment (see foo::bar).`
         //                                                   ^^
@@ -255,7 +255,7 @@ fn check_text(cx: &EarlyContext, valid_idents: &[String], text: &str, span: Span
     }
 }
 
-fn check_word(cx: &EarlyContext, word: &str, span: Span) {
+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
     /// ok) and one lower-case letter (`NASA` is ok). Plural are also excluded

clippy_lints/src/double_parens.rs

@@ -31,7 +31,7 @@ impl LintPass for DoubleParens {
 }
 
 impl EarlyLintPass for DoubleParens {
-    fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         match expr.node {
             ExprKind::Paren(ref in_paren) => match in_paren.node {
                 ExprKind::Paren(_) | ExprKind::Tup(_) => {

clippy_lints/src/else_if_without_else.rs

@@ -49,7 +49,7 @@ impl LintPass for ElseIfWithoutElse {
 }
 
 impl EarlyLintPass for ElseIfWithoutElse {
-    fn check_expr(&mut self, cx: &EarlyContext, mut item: &Expr) {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, mut item: &Expr) {
         if in_external_macro(cx, item.span) {
             return;
         }

clippy_lints/src/empty_enum.rs

@@ -33,7 +33,7 @@ impl LintPass for EmptyEnum {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EmptyEnum {
-    fn check_item(&mut self, cx: &LateContext, item: &Item) {
+    fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item) {
         let did = cx.tcx.hir.local_def_id(item.id);
         if let ItemKind::Enum(..) = item.node {
             let ty = cx.tcx.type_of(did);

clippy_lints/src/enum_glob_use.rs

@@ -44,7 +44,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EnumGlobUse {
 }
 
 impl EnumGlobUse {
-    fn lint_item(&self, cx: &LateContext, item: &Item) {
+    fn lint_item(&self, cx: &LateContext<'_, '_>, item: &Item) {
         if item.vis.node.is_pub() {
             return; // re-exports are fine
         }

clippy_lints/src/enum_variants.rs

@@ -149,7 +149,7 @@ fn partial_rmatch(post: &str, name: &str) -> usize {
 // FIXME: #600
 #[allow(while_let_on_iterator)]
 fn check_variant(
-    cx: &EarlyContext,
+    cx: &EarlyContext<'_>,
     threshold: u64,
     def: &EnumDef,
     item_name: &str,
@@ -240,12 +240,12 @@ fn to_camel_case(item_name: &str) -> String {
 }
 
 impl EarlyLintPass for EnumVariantNames {
-    fn check_item_post(&mut self, _cx: &EarlyContext, _item: &Item) {
+    fn check_item_post(&mut self, _cx: &EarlyContext<'_>, _item: &Item) {
         let last = self.modules.pop();
         assert!(last.is_some());
     }
 
-    fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         let item_name = item.ident.as_str();
         let item_name_chars = item_name.chars().count();
         let item_camel = to_camel_case(&item_name);

clippy_lints/src/erasing_op.rs

@@ -50,7 +50,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ErasingOp {
     }
 }
 
-fn check(cx: &LateContext, e: &Expr, span: Span) {
+fn check(cx: &LateContext<'_, '_>, e: &Expr, span: Span) {
     if let Some(Constant::Int(v)) = constant_simple(cx, cx.tables, e) {
         if v == 0 {
             span_lint(