From 5beeb1eec7c325428f1a1cd6fb1a95c45256e9f8 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 7 Dec 2016 13:14:47 +0100 Subject: [PATCH] remove useless lifetime outlives bounds --- src/librustc/lint/builtin.rs | 2 +- src/librustc/lint/mod.rs | 169 ++++++++---------- src/librustc_lint/bad_style.rs | 32 ++-- src/librustc_lint/builtin.rs | 84 +++++---- src/librustc_lint/types.rs | 12 +- src/librustc_lint/unused.rs | 28 +-- .../auxiliary/lint_for_crate.rs | 6 +- .../auxiliary/lint_group_plugin_test.rs | 6 +- .../auxiliary/lint_for_crate.rs | 6 +- .../auxiliary/lint_group_plugin_test.rs | 6 +- .../issue-37290/auxiliary/lint.rs | 4 +- 11 files changed, 165 insertions(+), 190 deletions(-) diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 78d5067b273..02c1ece1634 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -262,4 +262,4 @@ impl LintPass for HardwiredLints { } } -impl LateLintPass for HardwiredLints {} +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for HardwiredLints {} diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 0f85494d1ab..ccf53f01cd5 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -129,106 +129,85 @@ pub trait LintPass { // // FIXME: eliminate the duplication with `Visitor`. But this also // contains a few lint-specific methods with no equivalent in `Visitor`. -pub trait LateLintPass: LintPass { +pub trait LateLintPass<'a, 'tcx>: LintPass { fn check_name(&mut self, _: &LateContext, _: Span, _: ast::Name) { } - fn check_crate<'a, 'tcx:'a >(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Crate) { } - fn check_crate_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Crate) { } - fn check_mod<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Mod, - _: Span, - _: ast::NodeId) { } - fn check_mod_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Mod, - _: Span, - _: ast::NodeId) { } - fn check_foreign_item<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::ForeignItem) { } - fn check_foreign_item_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::ForeignItem) { } - fn check_item<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Item) { } - fn check_item_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Item) { } - fn check_local<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Local) { } - fn check_block<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Block) { } - fn check_block_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Block) { } - fn check_stmt<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Stmt) { } - fn check_arm<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Arm) { } - fn check_pat<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Pat) { } - fn check_decl<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Decl) { } - fn check_expr<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Expr) { } - fn check_expr_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Expr) { } - fn check_ty<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, _: &'tcx hir::Ty) { } - fn check_generics<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Generics) { } - fn check_fn<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, - _: FnKind<'tcx>, _: &'tcx hir::FnDecl, _: &'tcx hir::Expr, _: Span, _: ast::NodeId) { } - fn check_fn_post<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, - _: FnKind<'tcx>, _: &'tcx hir::FnDecl, _: &'tcx hir::Expr, _: Span, _: ast::NodeId) { } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::TraitItem) { } - fn check_trait_item_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::TraitItem) { } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::ImplItem) { } - fn check_impl_item_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::ImplItem) { } - fn check_struct_def<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::VariantData, _: ast::Name, _: &'tcx hir::Generics, _: ast::NodeId) { } - fn check_struct_def_post<'a, 'tcx: 'a>(&mut self, _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::VariantData, _: ast::Name, _: &'tcx hir::Generics, _: ast::NodeId) { } - fn check_struct_field<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::StructField) { } - fn check_variant<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Variant, - _: &'tcx hir::Generics) { } - fn check_variant_post<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Variant, - _: &'tcx hir::Generics) { } - fn check_lifetime<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Lifetime) { } - fn check_lifetime_def<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::LifetimeDef) { } - fn check_path<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx hir::Path, - _: ast::NodeId) { } - fn check_attribute<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx ast::Attribute) { } + fn check_crate(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Crate) { } + fn check_crate_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Crate) { } + fn check_mod(&mut self, + _: &LateContext<'a, 'tcx>, + _: &'tcx hir::Mod, + _: Span, + _: ast::NodeId) { } + fn check_mod_post(&mut self, + _: &LateContext<'a, 'tcx>, + _: &'tcx hir::Mod, + _: Span, + _: ast::NodeId) { } + fn check_foreign_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ForeignItem) { } + fn check_foreign_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ForeignItem) { } + fn check_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Item) { } + fn check_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Item) { } + fn check_local(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Local) { } + fn check_block(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Block) { } + fn check_block_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Block) { } + fn check_stmt(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Stmt) { } + fn check_arm(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Arm) { } + fn check_pat(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Pat) { } + fn check_decl(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Decl) { } + fn check_expr(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Expr) { } + fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Expr) { } + fn check_ty(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Ty) { } + fn check_generics(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Generics) { } + fn check_fn(&mut self, + _: &LateContext<'a, 'tcx>, + _: FnKind<'tcx>, + _: &'tcx hir::FnDecl, + _: &'tcx hir::Expr, + _: Span, + _: ast::NodeId) { } + fn check_fn_post(&mut self, + _: &LateContext<'a, 'tcx>, + _: FnKind<'tcx>, + _: &'tcx hir::FnDecl, + _: &'tcx hir::Expr, + _: Span, + _: ast::NodeId) { } + fn check_trait_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::TraitItem) { } + fn check_trait_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::TraitItem) { } + fn check_impl_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ImplItem) { } + fn check_impl_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ImplItem) { } + fn check_struct_def(&mut self, + _: &LateContext<'a, 'tcx>, + _: &'tcx hir::VariantData, + _: ast::Name, + _: &'tcx hir::Generics, + _: ast::NodeId) { } + fn check_struct_def_post(&mut self, + _: &LateContext<'a, 'tcx>, + _: &'tcx hir::VariantData, + _: ast::Name, + _: &'tcx hir::Generics, + _: ast::NodeId) { } + fn check_struct_field(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::StructField) { } + fn check_variant(&mut self, + _: &LateContext<'a, 'tcx>, + _: &'tcx hir::Variant, + _: &'tcx hir::Generics) { } + fn check_variant_post(&mut self, + _: &LateContext<'a, 'tcx>, + _: &'tcx hir::Variant, + _: &'tcx hir::Generics) { } + fn check_lifetime(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Lifetime) { } + fn check_lifetime_def(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::LifetimeDef) { } + fn check_path(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Path, _: ast::NodeId) { } + fn check_attribute(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx ast::Attribute) { } /// Called when entering a syntax node that can have lint attributes such /// as `#[allow(...)]`. Called with *all* the attributes of that node. - fn enter_lint_attrs<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx [ast::Attribute]) { } + fn enter_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { } /// Counterpart to `enter_lint_attrs`. - fn exit_lint_attrs<'a, 'tcx: 'a>(&mut self, - _: &'a LateContext<'a, 'tcx>, - _: &'tcx [ast::Attribute]) { } + fn exit_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { } } pub trait EarlyLintPass: LintPass { @@ -282,7 +261,7 @@ pub trait EarlyLintPass: LintPass { /// A lint pass boxed up as a trait object. pub type EarlyLintPassObject = Box; -pub type LateLintPassObject = Box; +pub type LateLintPassObject = Box LateLintPass<'a, 'tcx> + 'static>; /// Identifies a lint known to the compiler. #[derive(Clone, Copy, Debug)] diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index f2bcd135063..4bdd78d55b1 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -99,8 +99,8 @@ impl LintPass for NonCamelCaseTypes { } } -impl LateLintPass for NonCamelCaseTypes { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCamelCaseTypes { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { let extern_repr_count = it.attrs .iter() .filter(|attr| { @@ -133,7 +133,7 @@ impl LateLintPass for NonCamelCaseTypes { } } - fn check_generics<'a, 'tcx: 'a>(&mut self, + fn check_generics(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Generics) { for gen in it.ty_params.iter() { @@ -228,8 +228,8 @@ impl LintPass for NonSnakeCase { } } -impl LateLintPass for NonSnakeCase { - fn check_crate<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, cr: &'tcx hir::Crate) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { + fn check_crate(&mut self, cx: &LateContext<'a, 'tcx>, cr: &'tcx hir::Crate) { let attr_crate_name = cr.attrs .iter() .find(|at| at.check_name("crate_name")) @@ -241,7 +241,7 @@ impl LateLintPass for NonSnakeCase { } } - fn check_fn<'a, 'tcx: 'a>(&mut self, + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, fk: FnKind, _: &'tcx hir::FnDecl, @@ -267,13 +267,13 @@ impl LateLintPass for NonSnakeCase { } } - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { if let hir::ItemMod(_) = it.node { self.check_snake_case(cx, "module", &it.name.as_str(), Some(it.span)); } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { if let hir::MethodTraitItem(_, None) = trait_item.node { @@ -284,7 +284,7 @@ impl LateLintPass for NonSnakeCase { } } - fn check_lifetime_def<'a, 'tcx: 'a>(&mut self, + fn check_lifetime_def(&mut self, cx: &LateContext<'a, 'tcx>, t: &'tcx hir::LifetimeDef) { self.check_snake_case(cx, @@ -293,7 +293,7 @@ impl LateLintPass for NonSnakeCase { Some(t.lifetime.span)); } - fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, p: &'tcx hir::Pat) { + fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, p: &'tcx hir::Pat) { // Exclude parameter names from foreign functions let parent_node = cx.tcx.map.get_parent_node(p.id); if let hir::map::NodeForeignItem(item) = cx.tcx.map.get(parent_node) { @@ -307,7 +307,7 @@ impl LateLintPass for NonSnakeCase { } } - fn check_struct_def<'a, 'tcx: 'a>(&mut self, + fn check_struct_def(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::VariantData, _: ast::Name, @@ -354,8 +354,8 @@ impl LintPass for NonUpperCaseGlobals { } } -impl LateLintPass for NonUpperCaseGlobals { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { match it.node { hir::ItemStatic(..) => { NonUpperCaseGlobals::check_upper_case(cx, "static variable", it.name, it.span); @@ -367,7 +367,7 @@ impl LateLintPass for NonUpperCaseGlobals { } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, ti: &'tcx hir::TraitItem) { match ti.node { @@ -378,7 +378,7 @@ impl LateLintPass for NonUpperCaseGlobals { } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, ii: &'tcx hir::ImplItem) { match ii.node { @@ -389,7 +389,7 @@ impl LateLintPass for NonUpperCaseGlobals { } } - fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, p: &'tcx hir::Pat) { + fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, p: &'tcx hir::Pat) { // Lint for constants that look like binding identifiers (#7526) if let PatKind::Path(hir::QPath::Resolved(None, ref path)) = p.node { if !path.global && path.segments.len() == 1 && path.segments[0].parameters.is_empty() { diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index f3cb4d8820a..ed6eaf0171d 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -69,8 +69,8 @@ impl LintPass for WhileTrue { } } -impl LateLintPass for WhileTrue { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for WhileTrue { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { if let hir::ExprWhile(ref cond, ..) = e.node { if let hir::ExprLit(ref lit) = cond.node { if let ast::LitKind::Bool(true) = lit.node { @@ -109,8 +109,8 @@ impl LintPass for BoxPointers { } } -impl LateLintPass for BoxPointers { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { match it.node { hir::ItemFn(..) | hir::ItemTy(..) | @@ -137,7 +137,7 @@ impl LateLintPass for BoxPointers { } } - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { let ty = cx.tcx.tables().node_id_to_type(e.id); self.check_heap_type(cx, e.span, ty); } @@ -158,8 +158,8 @@ impl LintPass for NonShorthandFieldPatterns { } } -impl LateLintPass for NonShorthandFieldPatterns { - fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx hir::Pat) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonShorthandFieldPatterns { + fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx hir::Pat) { if let PatKind::Struct(_, ref field_pats, _) = pat.node { for fieldpat in field_pats { if fieldpat.node.is_shorthand { @@ -194,8 +194,8 @@ impl LintPass for UnsafeCode { } } -impl LateLintPass for UnsafeCode { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnsafeCode { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { if let hir::ExprBlock(ref blk) = e.node { // Don't warn about generated blocks, that'll just pollute the output. if blk.rules == hir::UnsafeBlock(hir::UserProvided) { @@ -204,7 +204,7 @@ impl LateLintPass for UnsafeCode { } } - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { match it.node { hir::ItemTrait(hir::Unsafety::Unsafe, ..) => { cx.span_lint(UNSAFE_CODE, it.span, "declaration of an `unsafe` trait") @@ -218,7 +218,7 @@ impl LateLintPass for UnsafeCode { } } - fn check_fn<'a, 'tcx: 'a>(&mut self, + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, fk: FnKind<'tcx>, _: &'tcx hir::FnDecl, @@ -240,7 +240,7 @@ impl LateLintPass for UnsafeCode { } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { if let hir::MethodTraitItem(ref sig, None) = trait_item.node { @@ -329,10 +329,8 @@ impl LintPass for MissingDoc { } } -impl LateLintPass for MissingDoc { - fn enter_lint_attrs<'a, 'tcx: 'a>(&mut self, - _: &LateContext<'a, 'tcx>, - attrs: &'tcx [ast::Attribute]) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { + fn enter_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, attrs: &'tcx [ast::Attribute]) { let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| { attr.check_name("doc") && @@ -344,13 +342,11 @@ impl LateLintPass for MissingDoc { self.doc_hidden_stack.push(doc_hidden); } - fn exit_lint_attrs<'a, 'tcx: 'a>(&mut self, - _: &LateContext<'a, 'tcx>, - _attrs: &'tcx [ast::Attribute]) { + fn exit_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, _attrs: &'tcx [ast::Attribute]) { self.doc_hidden_stack.pop().expect("empty doc_hidden_stack"); } - fn check_struct_def<'a, 'tcx: 'a>(&mut self, + fn check_struct_def(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::VariantData, _: ast::Name, @@ -359,7 +355,7 @@ impl LateLintPass for MissingDoc { self.struct_def_stack.push(item_id); } - fn check_struct_def_post<'a, 'tcx: 'a>(&mut self, + fn check_struct_def_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::VariantData, _: ast::Name, @@ -369,11 +365,11 @@ impl LateLintPass for MissingDoc { assert!(popped == item_id); } - fn check_crate<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { + fn check_crate(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { self.check_missing_docs_attrs(cx, None, &krate.attrs, krate.span, "crate"); } - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { let desc = match it.node { hir::ItemFn(..) => "a function", hir::ItemMod(..) => "a module", @@ -418,7 +414,7 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs, it.span, desc); } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { if self.private_traits.contains(&trait_item.id) { @@ -438,7 +434,7 @@ impl LateLintPass for MissingDoc { desc); } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem) { // If the method is an impl for a trait, don't doc. @@ -458,7 +454,7 @@ impl LateLintPass for MissingDoc { desc); } - fn check_struct_field<'a, 'tcx: 'a>(&mut self, + fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, sf: &'tcx hir::StructField) { if !sf.is_positional() { @@ -475,7 +471,7 @@ impl LateLintPass for MissingDoc { } } - fn check_variant<'a, 'tcx: 'a>(&mut self, + fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, v: &'tcx hir::Variant, _: &'tcx hir::Generics) { @@ -488,7 +484,7 @@ impl LateLintPass for MissingDoc { self.in_variant = true; } - fn check_variant_post<'a, 'tcx: 'a>(&mut self, + fn check_variant_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Variant, _: &'tcx hir::Generics) { @@ -512,8 +508,8 @@ impl LintPass for MissingCopyImplementations { } } -impl LateLintPass for MissingCopyImplementations { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { if !cx.access_levels.is_reachable(item.id) { return; } @@ -581,8 +577,8 @@ impl LintPass for MissingDebugImplementations { } } -impl LateLintPass for MissingDebugImplementations { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDebugImplementations { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { if !cx.access_levels.is_reachable(item.id) { return; } @@ -687,8 +683,8 @@ impl LintPass for UnconditionalRecursion { } } -impl LateLintPass for UnconditionalRecursion { - fn check_fn<'a, 'tcx: 'a>(&mut self, +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion { + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, fn_kind: FnKind<'tcx>, _: &'tcx hir::FnDecl, @@ -950,8 +946,8 @@ impl LintPass for PluginAsLibrary { } } -impl LateLintPass for PluginAsLibrary { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PluginAsLibrary { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { if cx.sess().plugin_registrar_fn.get().is_some() { // We're compiling a plugin; it's fine to link other plugins. return; @@ -1016,8 +1012,8 @@ impl LintPass for InvalidNoMangleItems { } } -impl LateLintPass for InvalidNoMangleItems { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { match it.node { hir::ItemFn(.., ref generics, _) => { if attr::contains_name(&it.attrs, "no_mangle") { @@ -1070,8 +1066,8 @@ impl LintPass for MutableTransmutes { } } -impl LateLintPass for MutableTransmutes { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutableTransmutes { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { use syntax::abi::Abi::RustIntrinsic; let msg = "mutating transmuted &mut T from &T may cause undefined behavior, \ @@ -1138,8 +1134,8 @@ impl LintPass for UnstableFeatures { } } -impl LateLintPass for UnstableFeatures { - fn check_attribute<'a, 'tcx: 'a>(&mut self, +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures { + fn check_attribute(&mut self, ctx: &LateContext<'a, 'tcx>, attr: &'tcx ast::Attribute) { if attr.meta().check_name("feature") { @@ -1167,8 +1163,8 @@ impl LintPass for UnionsWithDropFields { } } -impl LateLintPass for UnionsWithDropFields { - fn check_item<'a, 'tcx: 'a>(&mut self, ctx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnionsWithDropFields { + fn check_item(&mut self, ctx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { if let hir::ItemUnion(ref vdata, _) = item.node { let param_env = &ty::ParameterEnvironment::for_item(ctx.tcx, item.id); for field in vdata.fields() { diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs index 48c209e1665..98b87a141ea 100644 --- a/src/librustc_lint/types.rs +++ b/src/librustc_lint/types.rs @@ -103,8 +103,8 @@ impl LintPass for TypeLimits { } } -impl LateLintPass for TypeLimits { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { match e.node { hir::ExprUnary(hir::UnNeg, ref expr) => { if let hir::ExprLit(ref lit) = expr.node { @@ -706,8 +706,8 @@ impl LintPass for ImproperCTypes { } } -impl LateLintPass for ImproperCTypes { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImproperCTypes { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { let mut vis = ImproperCTypesVisitor { cx: cx }; if let hir::ItemForeignMod(ref nmod) = it.node { if nmod.abi != Abi::RustIntrinsic && nmod.abi != Abi::PlatformIntrinsic { @@ -734,8 +734,8 @@ impl LintPass for VariantSizeDifferences { } } -impl LateLintPass for VariantSizeDifferences { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { if let hir::ItemEnum(ref enum_definition, ref gens) = it.node { if gens.ty_params.is_empty() { // sizes only make sense for non-generic types diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index 23fd7a86640..89f8f464ee7 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -77,8 +77,8 @@ impl LintPass for UnusedMut { } } -impl LateLintPass for UnusedMut { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedMut { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { if let hir::ExprMatch(_, ref arms, _) = e.node { for a in arms { self.check_unused_mut_pat(cx, &a.pats) @@ -86,7 +86,7 @@ impl LateLintPass for UnusedMut { } } - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::Stmt) { if let hir::StmtDecl(ref d, _) = s.node { if let hir::DeclLocal(ref l) = d.node { self.check_unused_mut_pat(cx, slice::ref_slice(&l.pat)); @@ -94,7 +94,7 @@ impl LateLintPass for UnusedMut { } } - fn check_fn<'a, 'tcx: 'a>(&mut self, + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx hir::FnDecl, @@ -128,8 +128,8 @@ impl LintPass for UnusedResults { } } -impl LateLintPass for UnusedResults { - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::Stmt) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::Stmt) { let expr = match s.node { hir::StmtSemi(ref expr, _) => &**expr, _ => return, @@ -187,8 +187,8 @@ impl LintPass for UnusedUnsafe { } } -impl LateLintPass for UnusedUnsafe { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedUnsafe { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { if let hir::ExprBlock(ref blk) = e.node { // Don't warn about generated blocks, that'll just pollute the output. if blk.rules == hir::UnsafeBlock(hir::UserProvided) && @@ -214,8 +214,8 @@ impl LintPass for PathStatements { } } -impl LateLintPass for PathStatements { - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::Stmt) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PathStatements { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx hir::Stmt) { if let hir::StmtSemi(ref expr, _) = s.node { if let hir::ExprPath(_) = expr.node { cx.span_lint(PATH_STATEMENTS, s.span, "path statement with no effect"); @@ -239,8 +239,8 @@ impl LintPass for UnusedAttributes { } } -impl LateLintPass for UnusedAttributes { - fn check_attribute<'a, 'tcx: 'a>(&mut self, +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes { + fn check_attribute(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx ast::Attribute) { debug!("checking attribute: {:?}", attr); @@ -435,8 +435,8 @@ impl LintPass for UnusedAllocation { } } -impl LateLintPass for UnusedAllocation { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAllocation { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { match e.node { hir::ExprBox(_) => {} _ => return, diff --git a/src/test/compile-fail-fulldeps/auxiliary/lint_for_crate.rs b/src/test/compile-fail-fulldeps/auxiliary/lint_for_crate.rs index b255cf11db0..4011ce86414 100644 --- a/src/test/compile-fail-fulldeps/auxiliary/lint_for_crate.rs +++ b/src/test/compile-fail-fulldeps/auxiliary/lint_for_crate.rs @@ -32,8 +32,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_crate<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_crate(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { if !attr::contains_name(&krate.attrs, "crate_okay") { cx.span_lint(CRATE_NOT_OKAY, krate.span, "crate is not marked with #![crate_okay]"); @@ -43,5 +43,5 @@ impl LateLintPass for Pass { #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { - reg.register_late_lint_pass(box Pass as LateLintPassObject); + reg.register_late_lint_pass(box Pass); } diff --git a/src/test/compile-fail-fulldeps/auxiliary/lint_group_plugin_test.rs b/src/test/compile-fail-fulldeps/auxiliary/lint_group_plugin_test.rs index ec3401e7b21..cc17a011e55 100644 --- a/src/test/compile-fail-fulldeps/auxiliary/lint_group_plugin_test.rs +++ b/src/test/compile-fail-fulldeps/auxiliary/lint_group_plugin_test.rs @@ -34,8 +34,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { match &*it.name.as_str() { "lintme" => cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'"), "pleaselintme" => cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'"), @@ -46,6 +46,6 @@ impl LateLintPass for Pass { #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { - reg.register_late_lint_pass(box Pass as LateLintPassObject); + reg.register_late_lint_pass(box Pass); reg.register_lint_group("lint_me", vec![TEST_LINT, PLEASE_LINT]); } diff --git a/src/test/run-pass-fulldeps/auxiliary/lint_for_crate.rs b/src/test/run-pass-fulldeps/auxiliary/lint_for_crate.rs index b255cf11db0..4011ce86414 100644 --- a/src/test/run-pass-fulldeps/auxiliary/lint_for_crate.rs +++ b/src/test/run-pass-fulldeps/auxiliary/lint_for_crate.rs @@ -32,8 +32,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_crate<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_crate(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { if !attr::contains_name(&krate.attrs, "crate_okay") { cx.span_lint(CRATE_NOT_OKAY, krate.span, "crate is not marked with #![crate_okay]"); @@ -43,5 +43,5 @@ impl LateLintPass for Pass { #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { - reg.register_late_lint_pass(box Pass as LateLintPassObject); + reg.register_late_lint_pass(box Pass); } diff --git a/src/test/run-pass-fulldeps/auxiliary/lint_group_plugin_test.rs b/src/test/run-pass-fulldeps/auxiliary/lint_group_plugin_test.rs index ec3401e7b21..cc17a011e55 100644 --- a/src/test/run-pass-fulldeps/auxiliary/lint_group_plugin_test.rs +++ b/src/test/run-pass-fulldeps/auxiliary/lint_group_plugin_test.rs @@ -34,8 +34,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { match &*it.name.as_str() { "lintme" => cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'"), "pleaselintme" => cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'"), @@ -46,6 +46,6 @@ impl LateLintPass for Pass { #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { - reg.register_late_lint_pass(box Pass as LateLintPassObject); + reg.register_late_lint_pass(box Pass); reg.register_lint_group("lint_me", vec![TEST_LINT, PLEASE_LINT]); } diff --git a/src/test/run-pass-fulldeps/issue-37290/auxiliary/lint.rs b/src/test/run-pass-fulldeps/issue-37290/auxiliary/lint.rs index 947d2dd22db..77996b71a46 100644 --- a/src/test/run-pass-fulldeps/issue-37290/auxiliary/lint.rs +++ b/src/test/run-pass-fulldeps/issue-37290/auxiliary/lint.rs @@ -39,8 +39,8 @@ impl LintPass for Pass { fn get_lints(&self) -> LintArray { lint_array!(REGION_HIERARCHY) } } -impl LateLintPass for Pass { - fn check_fn<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, fk: FnKind<'tcx>, _: &'tcx hir::FnDecl, expr: &'tcx hir::Expr, span: Span, node: ast::NodeId) {