Rename Rptr to Ref in AST and HIR

Noratrieb · Noratrieb · commit c617a8e01cf3 · 2022-12-28T18:52:36.000+01:00
The name makes a lot more sense, and `ty::TyKind` calls it `Ref` already
as well.
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
@@ -969,14 +969,14 @@ fn binding_ty_auto_deref_stability<'tcx>(
     precedence: i8,
     binder_args: &'tcx List<BoundVariableKind>,
 ) -> Position {
-    let TyKind::Rptr(_, ty) = &ty.kind else {
+    let TyKind::Ref(_, ty) = &ty.kind else {
         return Position::Other(precedence);
     };
     let mut ty = ty;
 
     loop {
         break match ty.ty.kind {
-            TyKind::Rptr(_, ref ref_ty) => {
+            TyKind::Ref(_, ref ref_ty) => {
                 ty = ref_ty;
                 continue;
             },
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
@@ -152,7 +152,7 @@ fn captures_all_lifetimes(inputs: &[Ty<'_>], output_lifetimes: &[LifetimeName])
     let input_lifetimes: Vec<LifetimeName> = inputs
         .iter()
         .filter_map(|ty| {
-            if let TyKind::Rptr(lt, _) = ty.kind {
+            if let TyKind::Ref(lt, _) = ty.kind {
                 Some(lt.res)
             } else {
                 None
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
@@ -3986,7 +3986,7 @@ impl OutType {
             (Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,
             (Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,
             (Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,
-            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Rptr(_, _)),
+            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Ref(_, _)),
             _ => false,
         }
     }
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
@@ -86,15 +86,15 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
             return;
         }
 
-        if let hir::TyKind::Rptr(
+        if let hir::TyKind::Ref(
             _,
             hir::MutTy {
                 ty: pty,
                 mutbl: hir::Mutability::Mut,
             },
         ) = ty.kind
         {
-            if let hir::TyKind::Rptr(
+            if let hir::TyKind::Ref(
                 _,
                 hir::MutTy {
                     mutbl: hir::Mutability::Mut,
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -124,7 +124,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
                     check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl);
                 }
             },
-            TyKind::Rptr(lifetime, mut_ty) => {
+            TyKind::Ref(lifetime, mut_ty) => {
                 if_chain! {
                 if let TyKind::Path(None, path) = &mut_ty.ty.kind;
                 if let PatKind::Ident(BindingAnnotation::NONE, _, _) = p.pat.kind;
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -184,7 +184,7 @@ impl<'tcx> PassByRefOrValue {
                     if is_copy(cx, ty)
                         && let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes())
                         && size <= self.ref_min_size
-                        && let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind
+                        && let hir::TyKind::Ref(_, MutTy { ty: decl_ty, .. }) = input.kind
                     {
                         if let Some(typeck) = cx.maybe_typeck_results() {
                             // Don't lint if an unsafe pointer is created.
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
@@ -421,7 +421,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                 if let ty::Ref(_, ty, mutability) = *ty.kind();
                 if let ty::Adt(adt, substs) = *ty.kind();
 
-                if let TyKind::Rptr(lt, ref ty) = hir_ty.kind;
+                if let TyKind::Ref(lt, ref ty) = hir_ty.kind;
                 if let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind;
 
                 // Check that the name as typed matches the actual name of the type.
@@ -503,14 +503,14 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
 
 fn check_mut_from_ref<'tcx>(cx: &LateContext<'tcx>, sig: &FnSig<'_>, body: Option<&'tcx Body<'_>>) {
     if let FnRetTy::Return(ty) = sig.decl.output
-        && let Some((out, Mutability::Mut, _)) = get_rptr_lm(ty)
+        && let Some((out, Mutability::Mut, _)) = get_ref_lm(ty)
     {
         let out_region = cx.tcx.named_region(out.hir_id);
         let args: Option<Vec<_>> = sig
             .decl
             .inputs
             .iter()
-            .filter_map(get_rptr_lm)
+            .filter_map(get_ref_lm)
             .filter(|&(lt, _, _)| cx.tcx.named_region(lt.hir_id) == out_region)
             .map(|(_, mutability, span)| (mutability == Mutability::Not).then_some(span))
             .collect();
@@ -704,8 +704,8 @@ fn matches_preds<'tcx>(
     })
 }
 
-fn get_rptr_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
-    if let TyKind::Rptr(lt, ref m) = ty.kind {
+fn get_ref_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
+    if let TyKind::Ref(lt, ref m) = ty.kind {
         Some((lt, m.mutbl, ty.span))
     } else {
         None
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -59,7 +59,7 @@ impl RedundantStaticLifetimes {
                 }
             },
             // This is what we are looking for !
-            TyKind::Rptr(ref optional_lifetime, ref borrow_type) => {
+            TyKind::Ref(ref optional_lifetime, ref borrow_type) => {
                 // Match the 'static lifetime
                 if let Some(lifetime) = *optional_lifetime {
                     match borrow_type.ty.kind {
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
@@ -39,7 +39,7 @@ declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);
 impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
         if_chain! {
-            if let TyKind::Rptr(_, ref mut_ty) = ty.kind;
+            if let TyKind::Ref(_, ref mut_ty) = ty.kind;
             if mut_ty.mutbl == Mutability::Not;
             if let TyKind::Path(ref qpath) = &mut_ty.ty.kind;
             let last = last_path_segment(qpath);
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
                 GenericArg::Type(inner_ty) => Some(inner_ty),
                 _ => None,
             });
-            if let TyKind::Rptr(_, ref inner_mut_ty) = inner_ty.kind;
+            if let TyKind::Ref(_, ref inner_mut_ty) = inner_ty.kind;
             if inner_mut_ty.mutbl == Mutability::Not;
 
             then {
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -71,7 +71,7 @@ pub(super) fn check<'tcx>(
 /// Gets the type `Bar` in `…::transmute<Foo, &Bar>`.
 fn get_explicit_type<'tcx>(path: &'tcx Path<'tcx>) -> Option<&'tcx hir::Ty<'tcx>> {
     if let GenericArg::Type(ty) = path.segments.last()?.args?.args.get(1)?
-        && let TyKind::Rptr(_, ty) = &ty.kind
+        && let TyKind::Ref(_, ty) = &ty.kind
     {
         Some(ty.ty)
     } else {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
@@ -539,7 +539,7 @@ impl Types {
                     QPath::LangItem(..) => {},
                 }
             },
-            TyKind::Rptr(lt, ref mut_ty) => {
+            TyKind::Ref(lt, ref mut_ty) => {
                 context.is_nested_call = true;
                 if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {
                     self.check_ty(cx, mut_ty.ty, context);
diff --git a/clippy_lints/src/types/type_complexity.rs b/clippy_lints/src/types/type_complexity.rs
@@ -44,7 +44,7 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
     fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
         let (add_score, sub_nest) = match ty.kind {
             // _, &x and *x have only small overhead; don't mess with nesting level
-            TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
+            TyKind::Infer | TyKind::Ptr(..) | TyKind::Ref(..) => (1, 0),
 
             // the "normal" components of a type: named types, arrays/tuples
             TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
diff --git a/clippy_lints/src/types/utils.rs b/clippy_lints/src/types/utils.rs
@@ -13,7 +13,7 @@ pub(super) fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>)
             GenericArg::Type(ty) => Some(ty),
             _ => None,
         });
-        if let TyKind::Rptr(..) = ty.kind;
+        if let TyKind::Ref(..) = ty.kind;
         then {
             return Some(ty.span);
         }
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -257,7 +257,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
 }
 
 pub(super) fn is_lint_ref_type(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
-    if let TyKind::Rptr(
+    if let TyKind::Ref(
         _,
         MutTy {
             ty: inner,
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
@@ -625,7 +625,7 @@ pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
         (Slice(l), Slice(r)) => eq_ty(l, r),
         (Array(le, ls), Array(re, rs)) => eq_ty(le, re) && eq_expr(&ls.value, &rs.value),
         (Ptr(l), Ptr(r)) => l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty),
-        (Rptr(ll, l), Rptr(rl, r)) => {
+        (Ref(ll, l), Ref(rl, r)) => {
             both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
         },
         (BareFn(l), BareFn(r)) => {
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
@@ -430,7 +430,7 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
             (&TyKind::Array(lt, ll), &TyKind::Array(rt, rl)) => self.eq_ty(lt, rt) && self.eq_array_length(ll, rl),
             (TyKind::Ptr(l_mut), TyKind::Ptr(r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(l_mut.ty, r_mut.ty),
-            (TyKind::Rptr(_, l_rmut), TyKind::Rptr(_, r_rmut)) => {
+            (TyKind::Ref(_, l_rmut), TyKind::Ref(_, r_rmut)) => {
                 l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(l_rmut.ty, r_rmut.ty)
             },
             (TyKind::Path(l), TyKind::Path(r)) => self.eq_qpath(l, r),
@@ -950,7 +950,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);
             },
-            TyKind::Rptr(lifetime, ref mut_ty) => {
+            TyKind::Ref(lifetime, ref mut_ty) => {
                 self.hash_lifetime(lifetime);
                 self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
@@ -2264,7 +2264,7 @@ pub fn peel_hir_ty_refs<'a>(mut ty: &'a hir::Ty<'a>) -> (&'a hir::Ty<'a>, usize)
     let mut count = 0;
     loop {
         match &ty.kind {
-            TyKind::Rptr(_, ref_ty) => {
+            TyKind::Ref(_, ref_ty) => {
                 ty = ref_ty.ty;
                 count += 1;
             },
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
@@ -813,9 +813,9 @@ pub fn deref_closure_args(cx: &LateContext<'_>, closure: &hir::Expr<'_>) -> Opti
         let closure_body = cx.tcx.hir().body(body);
         // is closure arg a type annotated double reference (i.e.: `|x: &&i32| ...`)
         // a type annotation is present if param `kind` is different from `TyKind::Infer`
-        let closure_arg_is_type_annotated_double_ref = if let TyKind::Rptr(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind
+        let closure_arg_is_type_annotated_double_ref = if let TyKind::Ref(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind
         {
-            matches!(ty.kind, TyKind::Rptr(_, MutTy { .. }))
+            matches!(ty.kind, TyKind::Ref(_, MutTy { .. }))
         } else {
             false
         };
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
@@ -496,7 +496,7 @@ pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bo
 /// Returns the base type for HIR references and pointers.
 pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
     match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
+        TyKind::Ptr(ref mut_ty) | TyKind::Ref(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
         _ => ty,
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -3986,7 +3986,7 @@ impl OutType {`
`3986`	`3986`	`(Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,`
`3987`	`3987`	`(Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,`
`3988`	`3988`	`(Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,`
`3989`		`- (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Rptr(_, _)),`
	`3989`	`+ (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Ref(_, _)),`
`3990`	`3990`	`_ => false,`
`3991`	`3991`	`}`
`3992`	`3992`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {`
`124`	`124`	`check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl);`
`125`	`125`	`}`
`126`	`126`	`},`
`127`		`- TyKind::Rptr(lifetime, mut_ty) => {`
	`127`	`+ TyKind::Ref(lifetime, mut_ty) => {`
`128`	`128`	`if_chain! {`
`129`	`129`	`if let TyKind::Path(None, path) = &mut_ty.ty.kind;`
`130`	`130`	`if let PatKind::Ident(BindingAnnotation::NONE, _, _) = p.pat.kind;`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ impl<'tcx> PassByRefOrValue {`
`184`	`184`	`if is_copy(cx, ty)`
`185`	`185`	`&& let Some(size) = cx.layout_of(ty).ok().map(\|l\| l.size.bytes())`
`186`	`186`	`&& size <= self.ref_min_size`
`187`		`- && let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind`
	`187`	`+ && let hir::TyKind::Ref(_, MutTy { ty: decl_ty, .. }) = input.kind`
`188`	`188`	`{`
`189`	`189`	`if let Some(typeck) = cx.maybe_typeck_results() {`
`190`	`190`	`// Don't lint if an unsafe pointer is created.`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ impl RedundantStaticLifetimes {`
`59`	`59`	`}`
`60`	`60`	`},`
`61`	`61`	`// This is what we are looking for !`
`62`		`- TyKind::Rptr(ref optional_lifetime, ref borrow_type) => {`
	`62`	`+ TyKind::Ref(ref optional_lifetime, ref borrow_type) => {`
`63`	`63`	`// Match the 'static lifetime`
`64`	`64`	`if let Some(lifetime) = *optional_lifetime {`
`65`	`65`	`match borrow_type.ty.kind {`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ pub(super) fn check<'tcx>(`
`71`	`71`	/// Gets the type `Bar` in `…::transmute<Foo, &Bar>`.
`72`	`72`	`fn get_explicit_type<'tcx>(path: &'tcx Path<'tcx>) -> Option<&'tcx hir::Ty<'tcx>> {`
`73`	`73`	`if let GenericArg::Type(ty) = path.segments.last()?.args?.args.get(1)?`
`74`		`- && let TyKind::Rptr(_, ty) = &ty.kind`
	`74`	`+ && let TyKind::Ref(_, ty) = &ty.kind`
`75`	`75`	`{`
`76`	`76`	`Some(ty.ty)`
`77`	`77`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,7 @@ impl Types {`
`539`	`539`	`QPath::LangItem(..) => {},`
`540`	`540`	`}`
`541`	`541`	`},`
`542`		`- TyKind::Rptr(lt, ref mut_ty) => {`
	`542`	`+ TyKind::Ref(lt, ref mut_ty) => {`
`543`	`543`	`context.is_nested_call = true;`
`544`	`544`	`if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {`
`545`	`545`	`self.check_ty(cx, mut_ty.ty, context);`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ pub(super) fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>)`
`13`	`13`	`GenericArg::Type(ty) => Some(ty),`
`14`	`14`	`_ => None,`
`15`	`15`	`});`
`16`		`- if let TyKind::Rptr(..) = ty.kind;`
	`16`	`+ if let TyKind::Ref(..) = ty.kind;`
`17`	`17`	`then {`
`18`	`18`	`return Some(ty.span);`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`pub(super) fn is_lint_ref_type(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {`
`260`		`- if let TyKind::Rptr(`
	`260`	`+ if let TyKind::Ref(`
`261`	`261`	`_,`
`262`	`262`	`MutTy {`
`263`	`263`	`ty: inner,`
Original file line number	Diff line number	Diff line change
`@@ -496,7 +496,7 @@ pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bo`
`496`	`496`	`/// Returns the base type for HIR references and pointers.`
`497`	`497`	`pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {`
`498`	`498`	`match ty.kind {`
`499`		`- TyKind::Ptr(ref mut_ty) \| TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),`
	`499`	`+ TyKind::Ptr(ref mut_ty) \| TyKind::Ref(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),`
`500`	`500`	`_ => ty,`
`501`	`501`	`}`
`502`	`502`	`}`