Visit for hir::Ty.

cjgillot · cjgillot · commit 5865d563eaca · 2019-12-27T19:20:28.000+01:00
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
@@ -450,7 +450,7 @@ pub fn walk_poly_trait_ref<'v, V>(
 ) where
     V: Visitor<'v>,
 {
-    walk_list!(visitor, visit_generic_param, &trait_ref.bound_generic_params);
+    walk_list!(visitor, visit_generic_param, trait_ref.bound_generic_params);
     visitor.visit_trait_ref(&trait_ref.trait_ref);
 }
 
@@ -509,7 +509,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
             visitor.visit_ty(ty);
             visitor.visit_generics(generics)
         }
-        ItemKind::OpaqueTy(OpaqueTy { ref generics, ref bounds, .. }) => {
+        ItemKind::OpaqueTy(OpaqueTy { ref generics, bounds, .. }) => {
             visitor.visit_id(item.hir_id);
             walk_generics(visitor, generics);
             walk_list!(visitor, visit_param_bound, bounds);
@@ -538,13 +538,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
                 item.span,
             );
         }
-        ItemKind::Trait(.., ref generics, ref bounds, trait_item_refs) => {
+        ItemKind::Trait(.., ref generics, bounds, trait_item_refs) => {
             visitor.visit_id(item.hir_id);
             visitor.visit_generics(generics);
             walk_list!(visitor, visit_param_bound, bounds);
             walk_list!(visitor, visit_trait_item_ref, trait_item_refs);
         }
-        ItemKind::TraitAlias(ref generics, ref bounds) => {
+        ItemKind::TraitAlias(ref generics, bounds) => {
             visitor.visit_id(item.hir_id);
             visitor.visit_generics(generics);
             walk_list!(visitor, visit_param_bound, bounds);
@@ -598,25 +598,25 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {
             visitor.visit_ty(&mutable_type.ty)
         }
         TyKind::Never => {}
-        TyKind::Tup(ref tuple_element_types) => {
+        TyKind::Tup(tuple_element_types) => {
             walk_list!(visitor, visit_ty, tuple_element_types);
         }
         TyKind::BareFn(ref function_declaration) => {
-            walk_list!(visitor, visit_generic_param, &function_declaration.generic_params);
+            walk_list!(visitor, visit_generic_param, function_declaration.generic_params);
             visitor.visit_fn_decl(&function_declaration.decl);
         }
         TyKind::Path(ref qpath) => {
             visitor.visit_qpath(qpath, typ.hir_id, typ.span);
         }
-        TyKind::Def(item_id, ref lifetimes) => {
+        TyKind::Def(item_id, lifetimes) => {
             visitor.visit_nested_item(item_id);
             walk_list!(visitor, visit_generic_arg, lifetimes);
         }
         TyKind::Array(ref ty, ref length) => {
             visitor.visit_ty(ty);
             visitor.visit_anon_const(length)
         }
-        TyKind::TraitObject(ref bounds, ref lifetime) => {
+        TyKind::TraitObject(bounds, ref lifetime) => {
             for bound in bounds {
                 visitor.visit_poly_trait_ref(bound, TraitBoundModifier::None);
             }
@@ -648,7 +648,7 @@ pub fn walk_qpath<'v, V: Visitor<'v>>(
 }
 
 pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>) {
-    for segment in &path.segments {
+    for segment in path.segments {
         visitor.visit_path_segment(path.span, segment);
     }
 }
@@ -673,7 +673,7 @@ pub fn walk_generic_args<'v, V: Visitor<'v>>(
     generic_args: &'v GenericArgs<'v>,
 ) {
     walk_list!(visitor, visit_generic_arg, &generic_args.args);
-    walk_list!(visitor, visit_assoc_type_binding, &generic_args.bindings);
+    walk_list!(visitor, visit_assoc_type_binding, generic_args.bindings);
 }
 
 pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(
@@ -686,7 +686,7 @@ pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(
         TypeBindingKind::Equality { ref ty } => {
             visitor.visit_ty(ty);
         }
-        TypeBindingKind::Constraint { ref bounds } => {
+        TypeBindingKind::Constraint { bounds } => {
             walk_list!(visitor, visit_param_bound, bounds);
         }
     }
@@ -766,7 +766,7 @@ pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericB
 
 pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam<'v>) {
     visitor.visit_id(param.hir_id);
-    walk_list!(visitor, visit_attribute, &param.attrs);
+    walk_list!(visitor, visit_attribute, param.attrs);
     match param.name {
         ParamName::Plain(ident) => visitor.visit_ident(ident),
         ParamName::Error | ParamName::Fresh(_) => {}
@@ -776,12 +776,12 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
         GenericParamKind::Type { ref default, .. } => walk_list!(visitor, visit_ty, default),
         GenericParamKind::Const { ref ty } => visitor.visit_ty(ty),
     }
-    walk_list!(visitor, visit_param_bound, &param.bounds);
+    walk_list!(visitor, visit_param_bound, param.bounds);
 }
 
 pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) {
     walk_list!(visitor, visit_generic_param, &generics.params);
-    walk_list!(visitor, visit_where_predicate, &generics.where_clause.predicates);
+    walk_list!(visitor, visit_where_predicate, generics.where_clause.predicates);
 }
 
 pub fn walk_where_predicate<'v, V: Visitor<'v>>(
@@ -791,17 +791,15 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>(
     match predicate {
         &WherePredicate::BoundPredicate(WhereBoundPredicate {
             ref bounded_ty,
-            ref bounds,
-            ref bound_generic_params,
+            bounds,
+            bound_generic_params,
             ..
         }) => {
             visitor.visit_ty(bounded_ty);
             walk_list!(visitor, visit_param_bound, bounds);
             walk_list!(visitor, visit_generic_param, bound_generic_params);
         }
-        &WherePredicate::RegionPredicate(WhereRegionPredicate {
-            ref lifetime, ref bounds, ..
-        }) => {
+        &WherePredicate::RegionPredicate(WhereRegionPredicate { ref lifetime, bounds, .. }) => {
             visitor.visit_lifetime(lifetime);
             walk_list!(visitor, visit_param_bound, bounds);
         }
@@ -822,7 +820,7 @@ pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FunctionR
 }
 
 pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl<'v>) {
-    for ty in &function_declaration.inputs {
+    for ty in function_declaration.inputs {
         visitor.visit_ty(ty)
     }
     walk_fn_ret_ty(visitor, &function_declaration.output)
@@ -877,7 +875,7 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai
                 trait_item.hir_id,
             );
         }
-        TraitItemKind::Type(ref bounds, ref default) => {
+        TraitItemKind::Type(bounds, ref default) => {
             visitor.visit_id(trait_item.hir_id);
             walk_list!(visitor, visit_param_bound, bounds);
             walk_list!(visitor, visit_ty, default);
@@ -931,7 +929,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt
             visitor.visit_id(impl_item.hir_id);
             visitor.visit_ty(ty);
         }
-        ImplItemKind::OpaqueTy(ref bounds) => {
+        ImplItemKind::OpaqueTy(bounds) => {
             visitor.visit_id(impl_item.hir_id);
             walk_list!(visitor, visit_param_bound, bounds);
         }
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
@@ -443,7 +443,7 @@ pub struct GenericArgs<'hir> {
 
 impl GenericArgs<'_> {
     pub const fn none() -> Self {
-        Self { args: HirVec::new(), bindings: HirVec::new(), parenthesized: false }
+        Self { args: HirVec::new(), bindings: &[], parenthesized: false }
     }
 
     pub fn is_empty(&self) -> bool {
@@ -580,7 +580,7 @@ impl Generics<'hir> {
     pub const fn empty() -> Generics<'hir> {
         Generics {
             params: HirVec::new(),
-            where_clause: WhereClause { predicates: HirVec::new(), span: DUMMY_SP },
+            where_clause: WhereClause { predicates: &[], span: DUMMY_SP },
             span: DUMMY_SP,
         }
     }
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
@@ -10,6 +10,7 @@ use syntax::util::parser::{self, AssocOp, Fixity};
 use syntax_pos::{self, BytePos, FileName};
 
 use crate::hir;
+use crate::hir::HirVec;
 use crate::hir::{GenericArg, GenericParam, GenericParamKind};
 use crate::hir::{GenericBound, PatKind, RangeEnd, TraitBoundModifier};
 
@@ -307,7 +308,7 @@ impl<'a> State<'a> {
             }
             hir::TyKind::Def(..) => {}
             hir::TyKind::Path(ref qpath) => self.print_qpath(qpath, false),
-            hir::TyKind::TraitObject(ref bounds, ref lifetime) => {
+            hir::TyKind::TraitObject(bounds, ref lifetime) => {
                 let mut first = true;
                 for bound in bounds {
                     if first {
@@ -418,7 +419,7 @@ impl<'a> State<'a> {
     fn print_associated_type(
         &mut self,
         ident: ast::Ident,
-        bounds: Option<&hir::GenericBounds<'_>>,
+        bounds: Option<hir::GenericBounds<'_>>,
         ty: Option<&hir::Ty<'_>>,
     ) {
         self.word_space("type");
@@ -891,7 +892,7 @@ impl<'a> State<'a> {
             hir::ImplItemKind::TyAlias(ref ty) => {
                 self.print_associated_type(ii.ident, None, Some(ty));
             }
-            hir::ImplItemKind::OpaqueTy(ref bounds) => {
+            hir::ImplItemKind::OpaqueTy(bounds) => {
                 self.word_space("type");
                 self.print_ident(ii.ident);
                 self.print_bounds("= impl", bounds);
@@ -1586,7 +1587,7 @@ impl<'a> State<'a> {
                         self.word_space("=");
                         self.print_type(ty);
                     }
-                    hir::TypeBindingKind::Constraint { ref bounds } => {
+                    hir::TypeBindingKind::Constraint { bounds } => {
                         self.print_bounds(":", bounds);
                     }
                 }
@@ -1953,9 +1954,9 @@ impl<'a> State<'a> {
         match param.kind {
             GenericParamKind::Lifetime { .. } => {
                 let mut sep = ":";
-                for bound in &param.bounds {
+                for bound in param.bounds {
                     match bound {
-                        GenericBound::Outlives(lt) => {
+                        GenericBound::Outlives(ref lt) => {
                             self.s.word(sep);
                             self.print_lifetime(lt);
                             sep = "+";
@@ -1965,7 +1966,7 @@ impl<'a> State<'a> {
                 }
             }
             GenericParamKind::Type { ref default, .. } => {
-                self.print_bounds(":", &param.bounds);
+                self.print_bounds(":", param.bounds);
                 match default {
                     Some(default) => {
                         self.s.space();
@@ -2003,7 +2004,7 @@ impl<'a> State<'a> {
                 &hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
                     ref bound_generic_params,
                     ref bounded_ty,
-                    ref bounds,
+                    bounds,
                     ..
                 }) => {
                     self.print_formal_generic_params(bound_generic_params);
@@ -2096,11 +2097,8 @@ impl<'a> State<'a> {
             self.print_generic_params(generic_params);
         }
         let generics = hir::Generics {
-            params: hir::HirVec::new(),
-            where_clause: hir::WhereClause {
-                predicates: hir::HirVec::new(),
-                span: syntax_pos::DUMMY_SP,
-            },
+            params: HirVec::new(),
+            where_clause: hir::WhereClause { predicates: &[], span: syntax_pos::DUMMY_SP },
             span: syntax_pos::DUMMY_SP,
         };
         self.print_fn(
diff --git a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs
@@ -103,7 +103,7 @@ impl Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {
                 return;
             }
 
-            hir::TyKind::TraitObject(ref bounds, _) => {
+            hir::TyKind::TraitObject(bounds, _) => {
                 for bound in bounds {
                     self.current_index.shift_in(1);
                     self.visit_poly_trait_ref(bound, hir::TraitBoundModifier::None);
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs

Original file line number	Diff line number	Diff line change
`@@ -450,7 +450,7 @@ pub fn walk_poly_trait_ref<'v, V>(`
`450`	`450`	`) where`
`451`	`451`	`V: Visitor<'v>,`
`452`	`452`	`{`
`453`		`- walk_list!(visitor, visit_generic_param, &trait_ref.bound_generic_params);`
	`453`	`+ walk_list!(visitor, visit_generic_param, trait_ref.bound_generic_params);`
`454`	`454`	`visitor.visit_trait_ref(&trait_ref.trait_ref);`
`455`	`455`	`}`
`456`	`456`
`@@ -509,7 +509,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {`
`509`	`509`	`visitor.visit_ty(ty);`
`510`	`510`	`visitor.visit_generics(generics)`
`511`	`511`	`}`
`512`		`- ItemKind::OpaqueTy(OpaqueTy { ref generics, ref bounds, .. }) => {`
	`512`	`+ ItemKind::OpaqueTy(OpaqueTy { ref generics, bounds, .. }) => {`
`513`	`513`	`visitor.visit_id(item.hir_id);`
`514`	`514`	`walk_generics(visitor, generics);`
`515`	`515`	`walk_list!(visitor, visit_param_bound, bounds);`
`@@ -538,13 +538,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {`
`538`	`538`	`item.span,`
`539`	`539`	`);`
`540`	`540`	`}`
`541`		`- ItemKind::Trait(.., ref generics, ref bounds, trait_item_refs) => {`
	`541`	`+ ItemKind::Trait(.., ref generics, bounds, trait_item_refs) => {`
`542`	`542`	`visitor.visit_id(item.hir_id);`
`543`	`543`	`visitor.visit_generics(generics);`
`544`	`544`	`walk_list!(visitor, visit_param_bound, bounds);`
`545`	`545`	`walk_list!(visitor, visit_trait_item_ref, trait_item_refs);`
`546`	`546`	`}`
`547`		`- ItemKind::TraitAlias(ref generics, ref bounds) => {`
	`547`	`+ ItemKind::TraitAlias(ref generics, bounds) => {`
`548`	`548`	`visitor.visit_id(item.hir_id);`
`549`	`549`	`visitor.visit_generics(generics);`
`550`	`550`	`walk_list!(visitor, visit_param_bound, bounds);`
`@@ -598,25 +598,25 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {`
`598`	`598`	`visitor.visit_ty(&mutable_type.ty)`
`599`	`599`	`}`
`600`	`600`	`TyKind::Never => {}`
`601`		`- TyKind::Tup(ref tuple_element_types) => {`
	`601`	`+ TyKind::Tup(tuple_element_types) => {`
`602`	`602`	`walk_list!(visitor, visit_ty, tuple_element_types);`
`603`	`603`	`}`
`604`	`604`	`TyKind::BareFn(ref function_declaration) => {`
`605`		`- walk_list!(visitor, visit_generic_param, &function_declaration.generic_params);`
	`605`	`+ walk_list!(visitor, visit_generic_param, function_declaration.generic_params);`
`606`	`606`	`visitor.visit_fn_decl(&function_declaration.decl);`
`607`	`607`	`}`
`608`	`608`	`TyKind::Path(ref qpath) => {`
`609`	`609`	`visitor.visit_qpath(qpath, typ.hir_id, typ.span);`
`610`	`610`	`}`
`611`		`- TyKind::Def(item_id, ref lifetimes) => {`
	`611`	`+ TyKind::Def(item_id, lifetimes) => {`
`612`	`612`	`visitor.visit_nested_item(item_id);`
`613`	`613`	`walk_list!(visitor, visit_generic_arg, lifetimes);`
`614`	`614`	`}`
`615`	`615`	`TyKind::Array(ref ty, ref length) => {`
`616`	`616`	`visitor.visit_ty(ty);`
`617`	`617`	`visitor.visit_anon_const(length)`
`618`	`618`	`}`
`619`		`- TyKind::TraitObject(ref bounds, ref lifetime) => {`
	`619`	`+ TyKind::TraitObject(bounds, ref lifetime) => {`
`620`	`620`	`for bound in bounds {`
`621`	`621`	`visitor.visit_poly_trait_ref(bound, TraitBoundModifier::None);`
`622`	`622`	`}`
`@@ -648,7 +648,7 @@ pub fn walk_qpath<'v, V: Visitor<'v>>(`
`648`	`648`	`}`
`649`	`649`
`650`	`650`	`pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>) {`
`651`		`- for segment in &path.segments {`
	`651`	`+ for segment in path.segments {`
`652`	`652`	`visitor.visit_path_segment(path.span, segment);`
`653`	`653`	`}`
`654`	`654`	`}`
`@@ -673,7 +673,7 @@ pub fn walk_generic_args<'v, V: Visitor<'v>>(`
`673`	`673`	`generic_args: &'v GenericArgs<'v>,`
`674`	`674`	`) {`
`675`	`675`	`walk_list!(visitor, visit_generic_arg, &generic_args.args);`
`676`		`- walk_list!(visitor, visit_assoc_type_binding, &generic_args.bindings);`
	`676`	`+ walk_list!(visitor, visit_assoc_type_binding, generic_args.bindings);`
`677`	`677`	`}`
`678`	`678`
`679`	`679`	`pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(`
`@@ -686,7 +686,7 @@ pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(`
`686`	`686`	`TypeBindingKind::Equality { ref ty } => {`
`687`	`687`	`visitor.visit_ty(ty);`
`688`	`688`	`}`
`689`		`- TypeBindingKind::Constraint { ref bounds } => {`
	`689`	`+ TypeBindingKind::Constraint { bounds } => {`
`690`	`690`	`walk_list!(visitor, visit_param_bound, bounds);`
`691`	`691`	`}`
`692`	`692`	`}`
`@@ -766,7 +766,7 @@ pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericB`
`766`	`766`
`767`	`767`	`pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam<'v>) {`
`768`	`768`	`visitor.visit_id(param.hir_id);`
`769`		`- walk_list!(visitor, visit_attribute, &param.attrs);`
	`769`	`+ walk_list!(visitor, visit_attribute, param.attrs);`
`770`	`770`	`match param.name {`
`771`	`771`	`ParamName::Plain(ident) => visitor.visit_ident(ident),`
`772`	`772`	`ParamName::Error \| ParamName::Fresh(_) => {}`
`@@ -776,12 +776,12 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi`
`776`	`776`	`GenericParamKind::Type { ref default, .. } => walk_list!(visitor, visit_ty, default),`
`777`	`777`	`GenericParamKind::Const { ref ty } => visitor.visit_ty(ty),`
`778`	`778`	`}`
`779`		`- walk_list!(visitor, visit_param_bound, &param.bounds);`
	`779`	`+ walk_list!(visitor, visit_param_bound, param.bounds);`
`780`	`780`	`}`
`781`	`781`
`782`	`782`	`pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) {`
`783`	`783`	`walk_list!(visitor, visit_generic_param, &generics.params);`
`784`		`- walk_list!(visitor, visit_where_predicate, &generics.where_clause.predicates);`
	`784`	`+ walk_list!(visitor, visit_where_predicate, generics.where_clause.predicates);`
`785`	`785`	`}`
`786`	`786`
`787`	`787`	`pub fn walk_where_predicate<'v, V: Visitor<'v>>(`
`@@ -791,17 +791,15 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>(`
`791`	`791`	`match predicate {`
`792`	`792`	`&WherePredicate::BoundPredicate(WhereBoundPredicate {`
`793`	`793`	`ref bounded_ty,`
`794`		`- ref bounds,`
`795`		`- ref bound_generic_params,`
	`794`	`+ bounds,`
	`795`	`+ bound_generic_params,`
`796`	`796`	`..`
`797`	`797`	`}) => {`
`798`	`798`	`visitor.visit_ty(bounded_ty);`
`799`	`799`	`walk_list!(visitor, visit_param_bound, bounds);`
`800`	`800`	`walk_list!(visitor, visit_generic_param, bound_generic_params);`
`801`	`801`	`}`
`802`		`- &WherePredicate::RegionPredicate(WhereRegionPredicate {`
`803`		`- ref lifetime, ref bounds, ..`
`804`		`- }) => {`
	`802`	`+ &WherePredicate::RegionPredicate(WhereRegionPredicate { ref lifetime, bounds, .. }) => {`
`805`	`803`	`visitor.visit_lifetime(lifetime);`
`806`	`804`	`walk_list!(visitor, visit_param_bound, bounds);`
`807`	`805`	`}`
`@@ -822,7 +820,7 @@ pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FunctionR`
`822`	`820`	`}`
`823`	`821`
`824`	`822`	`pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl<'v>) {`
`825`		`- for ty in &function_declaration.inputs {`
	`823`	`+ for ty in function_declaration.inputs {`
`826`	`824`	`visitor.visit_ty(ty)`
`827`	`825`	`}`
`828`	`826`	`walk_fn_ret_ty(visitor, &function_declaration.output)`
`@@ -877,7 +875,7 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai`
`877`	`875`	`trait_item.hir_id,`
`878`	`876`	`);`
`879`	`877`	`}`
`880`		`- TraitItemKind::Type(ref bounds, ref default) => {`
	`878`	`+ TraitItemKind::Type(bounds, ref default) => {`
`881`	`879`	`visitor.visit_id(trait_item.hir_id);`
`882`	`880`	`walk_list!(visitor, visit_param_bound, bounds);`
`883`	`881`	`walk_list!(visitor, visit_ty, default);`
`@@ -931,7 +929,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt`
`931`	`929`	`visitor.visit_id(impl_item.hir_id);`
`932`	`930`	`visitor.visit_ty(ty);`
`933`	`931`	`}`
`934`		`- ImplItemKind::OpaqueTy(ref bounds) => {`
	`932`	`+ ImplItemKind::OpaqueTy(bounds) => {`
`935`	`933`	`visitor.visit_id(impl_item.hir_id);`
`936`	`934`	`walk_list!(visitor, visit_param_bound, bounds);`
`937`	`935`	`}`
Original file line number	Diff line number	Diff line change
`@@ -443,7 +443,7 @@ pub struct GenericArgs<'hir> {`
`443`	`443`
`444`	`444`	`impl GenericArgs<'_> {`
`445`	`445`	`pub const fn none() -> Self {`
`446`		`- Self { args: HirVec::new(), bindings: HirVec::new(), parenthesized: false }`
	`446`	`+ Self { args: HirVec::new(), bindings: &[], parenthesized: false }`
`447`	`447`	`}`
`448`	`448`
`449`	`449`	`pub fn is_empty(&self) -> bool {`
`@@ -580,7 +580,7 @@ impl Generics<'hir> {`
`580`	`580`	`pub const fn empty() -> Generics<'hir> {`
`581`	`581`	`Generics {`
`582`	`582`	`params: HirVec::new(),`
`583`		`- where_clause: WhereClause { predicates: HirVec::new(), span: DUMMY_SP },`
	`583`	`+ where_clause: WhereClause { predicates: &[], span: DUMMY_SP },`
`584`	`584`	`span: DUMMY_SP,`
`585`	`585`	`}`
`586`	`586`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ impl Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {`
`103`	`103`	`return;`
`104`	`104`	`}`
`105`	`105`
`106`		`- hir::TyKind::TraitObject(ref bounds, _) => {`
	`106`	`+ hir::TyKind::TraitObject(bounds, _) => {`
`107`	`107`	`for bound in bounds {`
`108`	`108`	`self.current_index.shift_in(1);`
`109`	`109`	`self.visit_poly_trait_ref(bound, hir::TraitBoundModifier::None);`