Fallout in other crates.

Author: cjgillot

src/librustc_lint/builtin.rs

@@ -983,7 +983,7 @@ impl UnreachablePub {
         cx: &LateContext<'_, '_>,
         what: &str,
         id: hir::HirId,
-        vis: &hir::Visibility,
+        vis: &hir::Visibility<'_>,
         span: Span,
         exportable: bool,
     ) {
@@ -1065,7 +1065,7 @@ declare_lint_pass!(
 );
 
 impl TypeAliasBounds {
-    fn is_type_variable_assoc(qpath: &hir::QPath) -> bool {
+    fn is_type_variable_assoc(qpath: &hir::QPath<'_>) -> bool {
         match *qpath {
             hir::QPath::TypeRelative(ref ty, _) => {
                 // If this is a type variable, we found a `T::Assoc`.
@@ -1081,7 +1081,7 @@ impl TypeAliasBounds {
         }
     }
 
-    fn suggest_changing_assoc_types(ty: &hir::Ty, err: &mut DiagnosticBuilder<'_>) {
+    fn suggest_changing_assoc_types(ty: &hir::Ty<'_>, err: &mut DiagnosticBuilder<'_>) {
         // Access to associates types should use `<T as Bound>::Assoc`, which does not need a
         // bound.  Let's see if this type does that.
 
@@ -1095,7 +1095,7 @@ impl TypeAliasBounds {
                 intravisit::NestedVisitorMap::None
             }
 
-            fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: hir::HirId, span: Span) {
+            fn visit_qpath(&mut self, qpath: &'v hir::QPath<'v>, id: hir::HirId, span: Span) {
                 if TypeAliasBounds::is_type_variable_assoc(qpath) {
                     self.err.span_help(
                         span,
@@ -1533,7 +1533,7 @@ impl ExplicitOutlivesRequirements {
 
     fn collect_outlived_lifetimes<'tcx>(
         &self,
-        param: &'tcx hir::GenericParam,
+        param: &'tcx hir::GenericParam<'tcx>,
         tcx: TyCtxt<'tcx>,
         inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
         ty_generics: &'tcx ty::Generics,
@@ -1554,7 +1554,7 @@ impl ExplicitOutlivesRequirements {
     fn collect_outlives_bound_spans<'tcx>(
         &self,
         tcx: TyCtxt<'tcx>,
-        bounds: &hir::GenericBounds,
+        bounds: &hir::GenericBounds<'_>,
         inferred_outlives: &[ty::Region<'tcx>],
         infer_static: bool,
     ) -> Vec<(usize, Span)> {
@@ -1585,7 +1585,7 @@ impl ExplicitOutlivesRequirements {
     fn consolidate_outlives_bound_spans(
         &self,
         lo: Span,
-        bounds: &hir::GenericBounds,
+        bounds: &hir::GenericBounds<'_>,
         bound_spans: Vec<(usize, Span)>,
     ) -> Vec<Span> {
         if bounds.is_empty() {

src/librustc_lint/nonstandard_style.rs

@@ -293,7 +293,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
         }
     }
 
-    fn check_generic_param(&mut self, cx: &LateContext<'_, '_>, param: &hir::GenericParam) {
+    fn check_generic_param(&mut self, cx: &LateContext<'_, '_>, param: &hir::GenericParam<'_>) {
         if let GenericParamKind::Lifetime { .. } = param.kind {
             self.check_snake_case(cx, "lifetime", &param.name.ident());
         }
@@ -303,7 +303,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
         &mut self,
         cx: &LateContext<'_, '_>,
         fk: FnKind<'_>,
-        _: &hir::FnDecl,
+        _: &hir::FnDecl<'_>,
         _: &hir::Body<'_>,
         _: Span,
         id: hir::HirId,
@@ -425,7 +425,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals {
         }
     }
 
-    fn check_generic_param(&mut self, cx: &LateContext<'_, '_>, param: &hir::GenericParam) {
+    fn check_generic_param(&mut self, cx: &LateContext<'_, '_>, param: &hir::GenericParam<'_>) {
         if let GenericParamKind::Const { .. } = param.kind {
             NonUpperCaseGlobals::check_upper_case(cx, "const parameter", &param.name.ident());
         }

src/librustc_lint/types.rs

@@ -963,12 +963,12 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         }
     }
 
-    fn check_foreign_fn(&mut self, id: hir::HirId, decl: &hir::FnDecl) {
+    fn check_foreign_fn(&mut self, id: hir::HirId, decl: &hir::FnDecl<'_>) {
         let def_id = self.cx.tcx.hir().local_def_id(id);
         let sig = self.cx.tcx.fn_sig(def_id);
         let sig = self.cx.tcx.erase_late_bound_regions(&sig);
 
-        for (input_ty, input_hir) in sig.inputs().iter().zip(&decl.inputs) {
+        for (input_ty, input_hir) in sig.inputs().iter().zip(decl.inputs) {
             self.check_type_for_ffi_and_report_errors(input_hir.span, input_ty, false);
         }
 

src/librustc_metadata/rmeta/encoder.rs

@@ -664,7 +664,7 @@ impl EncodeContext<'tcx> {
         id: hir::HirId,
         md: &hir::Mod<'_>,
         attrs: &[ast::Attribute],
-        vis: &hir::Visibility,
+        vis: &hir::Visibility<'_>,
     ) {
         let tcx = self.tcx;
         let def_id = tcx.hir().local_def_id(id);
@@ -1547,7 +1547,7 @@ impl Visitor<'tcx> for EncodeContext<'tcx> {
         let def_id = self.tcx.hir().local_def_id(ni.hir_id);
         self.encode_info_for_foreign_item(def_id, ni);
     }
-    fn visit_generics(&mut self, generics: &'tcx hir::Generics) {
+    fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
         intravisit::walk_generics(self, generics);
         self.encode_info_for_generics(generics);
     }
@@ -1568,7 +1568,7 @@ impl EncodeContext<'tcx> {
         }
     }
 
-    fn encode_info_for_generics(&mut self, generics: &hir::Generics) {
+    fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) {
         for param in &generics.params {
             let def_id = self.tcx.hir().local_def_id(param.hir_id);
             match param.kind {

src/librustc_mir/borrow_check/diagnostics/region_name.rs

@@ -410,7 +410,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     ) -> Option<RegionName> {
         let mir_hir_id = infcx.tcx.hir().as_local_hir_id(mir_def_id)?;
         let fn_decl = infcx.tcx.hir().fn_decl_by_hir_id(mir_hir_id)?;
-        let argument_hir_ty: &hir::Ty = fn_decl.inputs.get(argument_index)?;
+        let argument_hir_ty: &hir::Ty<'_> = fn_decl.inputs.get(argument_index)?;
         match argument_hir_ty.kind {
             // This indicates a variable with no type annotation, like
             // `|x|`... in that case, we can't highlight the type but
@@ -504,10 +504,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         tcx: TyCtxt<'tcx>,
         needle_fr: RegionVid,
         argument_ty: Ty<'tcx>,
-        argument_hir_ty: &hir::Ty,
+        argument_hir_ty: &hir::Ty<'_>,
         renctx: &mut RegionErrorNamingCtx,
     ) -> Option<RegionName> {
-        let search_stack: &mut Vec<(Ty<'tcx>, &hir::Ty)> =
+        let search_stack: &mut Vec<(Ty<'tcx>, &hir::Ty<'_>)> =
             &mut vec![(argument_ty, argument_hir_ty)];
 
         while let Some((ty, hir_ty)) = search_stack.pop() {
@@ -570,7 +570,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 // just worry about trying to match up the rustc type
                 // with the HIR types:
                 (ty::Tuple(elem_tys), hir::TyKind::Tup(elem_hir_tys)) => {
-                    search_stack.extend(elem_tys.iter().map(|k| k.expect_ty()).zip(elem_hir_tys));
+                    search_stack.extend(elem_tys.iter().map(|k| k.expect_ty()).zip(*elem_hir_tys));
                 }
 
                 (ty::Slice(elem_ty), hir::TyKind::Slice(elem_hir_ty))
@@ -600,9 +600,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         &self,
         substs: SubstsRef<'tcx>,
         needle_fr: RegionVid,
-        last_segment: &'hir hir::PathSegment,
+        last_segment: &'hir hir::PathSegment<'hir>,
         renctx: &mut RegionErrorNamingCtx,
-        search_stack: &mut Vec<(Ty<'tcx>, &'hir hir::Ty)>,
+        search_stack: &mut Vec<(Ty<'tcx>, &'hir hir::Ty<'hir>)>,
     ) -> Option<RegionName> {
         // Did the user give explicit arguments? (e.g., `Foo<..>`)
         let args = last_segment.args.as_ref()?;
@@ -647,8 +647,8 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         &self,
         substs: SubstsRef<'tcx>,
         needle_fr: RegionVid,
-        args: &'hir hir::GenericArgs,
-        search_stack: &mut Vec<(Ty<'tcx>, &'hir hir::Ty)>,
+        args: &'hir hir::GenericArgs<'hir>,
+        search_stack: &mut Vec<(Ty<'tcx>, &'hir hir::Ty<'hir>)>,
     ) -> Option<&'hir hir::Lifetime> {
         for (kind, hir_arg) in substs.iter().zip(&args.args) {
             match (kind.unpack(), hir_arg) {

src/librustc_mir/hair/pattern/check_match.rs

@@ -255,7 +255,7 @@ fn const_not_var(
     err: &mut DiagnosticBuilder<'_>,
     tcx: TyCtxt<'_>,
     pat: &Pat<'_>,
-    path: &hir::Path,
+    path: &hir::Path<'_>,
 ) {
     let descr = path.res.descr();
     err.span_label(

src/librustc_mir/hair/pattern/mod.rs

@@ -732,7 +732,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
     /// Takes a HIR Path. If the path is a constant, evaluates it and feeds
     /// it to `const_to_pat`. Any other path (like enum variants without fields)
     /// is converted to the corresponding pattern via `lower_variant_or_leaf`.
-    fn lower_path(&mut self, qpath: &hir::QPath, id: hir::HirId, span: Span) -> Pat<'tcx> {
+    fn lower_path(&mut self, qpath: &hir::QPath<'_>, id: hir::HirId, span: Span) -> Pat<'tcx> {
         let ty = self.tables.node_type(id);
         let res = self.tables.qpath_res(qpath, id);
         let is_associated_const = match res {

src/librustc_mir/transform/mod.rs

@@ -77,7 +77,7 @@ fn mir_keys(tcx: TyCtxt<'_>, krate: CrateNum) -> &DefIdSet {
             &mut self,
             v: &'tcx hir::VariantData<'tcx>,
             _: ast::Name,
-            _: &'tcx hir::Generics,
+            _: &'tcx hir::Generics<'tcx>,
             _: hir::HirId,
             _: Span,
         ) {

src/librustc_passes/dead.rs

@@ -229,7 +229,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkSymbolVisitor<'a, 'tcx> {
         &mut self,
         def: &'tcx hir::VariantData<'tcx>,
         _: ast::Name,
-        _: &hir::Generics,
+        _: &hir::Generics<'_>,
         _: hir::HirId,
         _: syntax_pos::Span,
     ) {
@@ -295,12 +295,12 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkSymbolVisitor<'a, 'tcx> {
         self.in_pat = false;
     }
 
-    fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {
+    fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
         self.handle_res(path.res);
         intravisit::walk_path(self, path);
     }
 
-    fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
+    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) {
         match ty.kind {
             TyKind::Def(item_id, _) => {
                 let item = self.tcx.hir().expect_item(item_id.id);
@@ -619,7 +619,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> {
     fn visit_variant(
         &mut self,
         variant: &'tcx hir::Variant<'tcx>,
-        g: &'tcx hir::Generics,
+        g: &'tcx hir::Generics<'tcx>,
         id: hir::HirId,
     ) {
         if self.should_warn_about_variant(&variant) {

src/librustc_passes/hir_stats.rs

@@ -160,15 +160,15 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_expr(self, ex)
     }
 
-    fn visit_ty(&mut self, t: &'v hir::Ty) {
+    fn visit_ty(&mut self, t: &'v hir::Ty<'v>) {
         self.record("Ty", Id::Node(t.hir_id), t);
         hir_visit::walk_ty(self, t)
     }
 
     fn visit_fn(
         &mut self,
         fk: hir_visit::FnKind<'v>,
-        fd: &'v hir::FnDecl,
+        fd: &'v hir::FnDecl<'v>,
         b: hir::BodyId,
         s: Span,
         id: hir::HirId,
@@ -177,7 +177,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_fn(self, fk, fd, b, s, id)
     }
 
-    fn visit_where_predicate(&mut self, predicate: &'v hir::WherePredicate) {
+    fn visit_where_predicate(&mut self, predicate: &'v hir::WherePredicate<'v>) {
         self.record("WherePredicate", Id::None, predicate);
         hir_visit::walk_where_predicate(self, predicate)
     }
@@ -192,7 +192,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_impl_item(self, ii)
     }
 
-    fn visit_param_bound(&mut self, bounds: &'v hir::GenericBound) {
+    fn visit_param_bound(&mut self, bounds: &'v hir::GenericBound<'v>) {
         self.record("GenericBound", Id::None, bounds);
         hir_visit::walk_param_bound(self, bounds)
     }
@@ -205,7 +205,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
     fn visit_variant(
         &mut self,
         v: &'v hir::Variant<'v>,
-        g: &'v hir::Generics,
+        g: &'v hir::Generics<'v>,
         item_id: hir::HirId,
     ) {
         self.record("Variant", Id::None, v);
@@ -217,22 +217,22 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_lifetime(self, lifetime)
     }
 
-    fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: hir::HirId, span: Span) {
+    fn visit_qpath(&mut self, qpath: &'v hir::QPath<'v>, id: hir::HirId, span: Span) {
         self.record("QPath", Id::None, qpath);
         hir_visit::walk_qpath(self, qpath, id, span)
     }
 
-    fn visit_path(&mut self, path: &'v hir::Path, _id: hir::HirId) {
+    fn visit_path(&mut self, path: &'v hir::Path<'v>, _id: hir::HirId) {
         self.record("Path", Id::None, path);
         hir_visit::walk_path(self, path)
     }
 
-    fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v hir::PathSegment) {
+    fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v hir::PathSegment<'v>) {
         self.record("PathSegment", Id::None, path_segment);
         hir_visit::walk_path_segment(self, path_span, path_segment)
     }
 
-    fn visit_assoc_type_binding(&mut self, type_binding: &'v hir::TypeBinding) {
+    fn visit_assoc_type_binding(&mut self, type_binding: &'v hir::TypeBinding<'v>) {
         self.record("TypeBinding", Id::Node(type_binding.hir_id), type_binding);
         hir_visit::walk_assoc_type_binding(self, type_binding)
     }