Remove now-obsolete visit_pattern_type_pattern

Author: oli-obk

compiler/rustc_ast_lowering/src/index.rs

@@ -393,10 +393,6 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         });
     }
 
-    fn visit_pattern_type_pattern(&mut self, p: &'hir hir::Pat<'hir>) {
-        self.visit_pat(p)
-    }
-
     fn visit_precise_capturing_arg(
         &mut self,
         arg: &'hir PreciseCapturingArg<'hir>,

compiler/rustc_hir/src/intravisit.rs

@@ -363,11 +363,6 @@ pub trait Visitor<'v>: Sized {
     fn visit_ty(&mut self, t: &'v Ty<'v>) -> Self::Result {
         walk_ty(self, t)
     }
-    fn visit_pattern_type_pattern(&mut self, _p: &'v Pat<'v>) {
-        // Do nothing. Only a few visitors need to know the details of the pattern type,
-        // and they opt into it. All other visitors will just choke on our fake patterns
-        // because they aren't in a body.
-    }
     fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) -> Self::Result {
         walk_generic_param(self, p)
     }
@@ -929,7 +924,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) -> V::Resul
         TyKind::Infer | TyKind::InferDelegation(..) | TyKind::Err(_) => {}
         TyKind::Pat(ty, pat) => {
             try_visit!(visitor.visit_ty(ty));
-            try_visit!(visitor.visit_pattern_type_pattern(pat));
+            try_visit!(visitor.visit_pat(pat));
         }
     }
     V::Result::output()

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -870,11 +870,6 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
         }
     }
 
-    #[instrument(level = "debug", skip(self))]
-    fn visit_pattern_type_pattern(&mut self, p: &'tcx hir::Pat<'tcx>) {
-        intravisit::walk_pat(self, p)
-    }
-
     #[instrument(level = "debug", skip(self))]
     fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) {
         use self::hir::TraitItemKind::*;

compiler/rustc_lint/src/internal.rs

@@ -5,8 +5,8 @@ use rustc_ast as ast;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{
-    BinOp, BinOpKind, Expr, ExprKind, GenericArg, HirId, Impl, Item, ItemKind, Node, Pat, PatKind,
-    PatExpr, PatExprKind, Path, PathSegment, QPath, Ty, TyKind,
+    BinOp, BinOpKind, Expr, ExprKind, GenericArg, HirId, Impl, Item, ItemKind, Node, Pat, PatExpr,
+    PatExprKind, PatKind, Path, PathSegment, QPath, Ty, TyKind,
 };
 use rustc_middle::ty::{self, GenericArgsRef, Ty as MiddleTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};

compiler/rustc_passes/src/hir_id_validator.rs

@@ -161,8 +161,4 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
         let mut inner_visitor = self.new_visitor(self.tcx);
         inner_visitor.check(i.owner_id, |this| intravisit::walk_impl_item(this, i));
     }
-
-    fn visit_pattern_type_pattern(&mut self, p: &'hir hir::Pat<'hir>) {
-        self.visit_pat(p)
-    }
 }

src/tools/clippy/clippy_lints/src/equatable_if_let.rs

@@ -1,120 +1 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::implements_trait;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Pat, PatKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::Ty;
-use rustc_session::declare_lint_pass;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for pattern matchings that can be expressed using equality.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// * It reads better and has less cognitive load because equality won't cause binding.
-    /// * It is a [Yoda condition](https://en.wikipedia.org/wiki/Yoda_conditions). Yoda conditions are widely
-    /// criticized for increasing the cognitive load of reading the code.
-    /// * Equality is a simple bool expression and can be merged with `&&` and `||` and
-    /// reuse if blocks
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// if let Some(2) = x {
-    ///     do_thing();
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// if x == Some(2) {
-    ///     do_thing();
-    /// }
-    /// ```
-    #[clippy::version = "1.57.0"]
-    pub EQUATABLE_IF_LET,
-    nursery,
-    "using pattern matching instead of equality"
-}
-
-declare_lint_pass!(PatternEquality => [EQUATABLE_IF_LET]);
-
-/// detects if pattern matches just one thing
-fn unary_pattern(pat: &Pat<'_>) -> bool {
-    fn array_rec(pats: &[Pat<'_>]) -> bool {
-        pats.iter().all(unary_pattern)
-    }
-    match &pat.kind {
-        PatKind::Slice(_, _, _)
-        | PatKind::Range(_, _, _)
-        | PatKind::Binding(..)
-        | PatKind::Wild
-        | PatKind::Never
-        | PatKind::Or(_)
-        | PatKind::Err(_) => false,
-        PatKind::Struct(_, a, etc) => !etc && a.iter().all(|x| unary_pattern(x.pat)),
-        PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => etc.as_opt_usize().is_none() && array_rec(a),
-        PatKind::Ref(x, _) | PatKind::Box(x) | PatKind::Deref(x) | PatKind::Guard(x, _) => unary_pattern(x),
-        PatKind::Expr(_) => true,
-    }
-}
-
-fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
-    if let Some(def_id) = cx.tcx.lang_items().eq_trait() {
-        implements_trait(cx, ty, def_id, &[other.into()])
-    } else {
-        false
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for PatternEquality {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let ExprKind::Let(let_expr) = expr.kind
-            && unary_pattern(let_expr.pat)
-            && !in_external_macro(cx.sess(), expr.span)
-        {
-            let exp_ty = cx.typeck_results().expr_ty(let_expr.init);
-            let pat_ty = cx.typeck_results().pat_ty(let_expr.pat);
-            let mut applicability = Applicability::MachineApplicable;
-
-            if is_structural_partial_eq(cx, exp_ty, pat_ty) {
-                let pat_str = match let_expr.pat.kind {
-                    PatKind::Struct(..) => format!(
-                        "({})",
-                        snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
-                    ),
-                    _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability)
-                        .0
-                        .to_string(),
-                };
-                span_lint_and_sugg(
-                    cx,
-                    EQUATABLE_IF_LET,
-                    expr.span,
-                    "this pattern matching can be expressed using equality",
-                    "try",
-                    format!(
-                        "{} == {pat_str}",
-                        snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
-                    ),
-                    applicability,
-                );
-            } else {
-                span_lint_and_sugg(
-                    cx,
-                    EQUATABLE_IF_LET,
-                    expr.span,
-                    "this pattern matching can be expressed using `matches!`",
-                    "try",
-                    format!(
-                        "matches!({}, {})",
-                        snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
-                        snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
-                    ),
-                    applicability,
-                );
-            }
-        }
-    }
-}

tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs

@@ -6,5 +6,6 @@ type Pat<const START: u32, const END: u32> =
 //~^ ERROR type and const arguments are not allowed on const parameter `START`
 //~| ERROR type arguments are not allowed on const parameter `END`
 //~| ERROR associated item constraints are not allowed here
+//~| ERROR the placeholder `_` is not allowed within types on item signatures
 
 fn main() {}

tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.stderr

@@ -32,7 +32,13 @@ error[E0229]: associated item constraints are not allowed here
 LL |     std::pat::pattern_type!(u32 is START::<(), i32, 2>..=END::<_, Assoc = ()>);
    |                                                                   ^^^^^^^^^^ associated item constraint not allowed here
 
-error: aborting due to 3 previous errors
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for type aliases
+  --> $DIR/bad_const_generics_args_on_const_param.rs:5:64
+   |
+LL |     std::pat::pattern_type!(u32 is START::<(), i32, 2>..=END::<_, Assoc = ()>);
+   |                                                                ^ not allowed in type signatures
+
+error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0109, E0229.
+Some errors have detailed explanations: E0109, E0121, E0229.
 For more information about an error, try `rustc --explain E0109`.