WIP: has_required_preds

Author: ada4a

clippy_lints/src/needless_path_new.rs

@@ -4,10 +4,14 @@ use clippy_utils::{expr_or_init, is_path_diagnostic_item, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_infer::infer::InferCtxt;
+use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, GenericPredicates, ParamTy, Ty};
+use rustc_middle::ty::{self, GenericPredicates, ParamTy, PredicatePolarity, Ty};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
+use rustc_trait_selection::infer::TyCtxtInferExt;
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use std::iter;
 
 declare_clippy_lint! {
@@ -59,10 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPathNew {
 
         let sig = tcx.fn_sig(fn_did).skip_binder().skip_binder();
 
-        let has_required_preds = |_param_ty: &ParamTy, _preds: GenericPredicates<'_>| -> bool {
-            // TODO
-            true
-        };
+        let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
 
         // `ExprKind::MethodCall` doesn't include the receiver in `args`, but does in `sig.inputs()`
         // -- so we iterate over both in `rev`erse in order to line them up starting from the _end_
@@ -87,7 +88,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPathNew {
                             .enumerate()
                             .filter_map(|(i, input)| (i != arg_idx).then_some(*input)),
                     )
-                    && has_required_preds(arg_param_ty, cx.tcx.predicates_of(fn_did))
+                    && let x_ty = cx.typeck_results().expr_ty(x)
+                    && has_required_preds(cx, &infcx, *arg_ty, x_ty, cx.tcx.predicates_of(fn_did))
                 {
                     let mut applicability = Applicability::MachineApplicable;
                     let sugg = Sugg::hir_with_applicability(cx, x, "_", &mut applicability);
@@ -105,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPathNew {
     }
 }
 
-fn is_used_anywhere_else<'a>(param_ty: &'_ ParamTy, mut other_sig_tys: impl Iterator<Item = Ty<'a>>) -> bool {
+fn is_used_anywhere_else<'tcx>(param_ty: &ParamTy, mut other_sig_tys: impl Iterator<Item = Ty<'tcx>>) -> bool {
     other_sig_tys.any(|sig_ty| {
         sig_ty.walk().any(|generic_arg| {
             if let Some(ty) = generic_arg.as_type()
@@ -119,3 +121,49 @@ fn is_used_anywhere_else<'a>(param_ty: &'_ ParamTy, mut other_sig_tys: impl Iter
         })
     })
 }
+
+fn has_required_preds<'tcx>(
+    cx: &LateContext<'tcx>,
+    infcx: &InferCtxt<'tcx>,
+    param_ty: Ty<'tcx>,
+    x_ty: Ty<'tcx>,
+    preds: GenericPredicates<'tcx>,
+) -> bool {
+    let mut has_preds = false;
+
+    let has_required_preds = preds
+        .predicates
+        .iter()
+        .filter_map(|(clause, _)| clause.as_trait_clause())
+        .map(|pred| pred.skip_binder())
+        .filter(|pred| {
+            // dbg!(pred.self_ty(), param_ty);
+            pred.self_ty() == param_ty
+        })
+        .all(|pred| {
+            has_preds = true;
+
+            if pred.polarity != PredicatePolarity::Positive {
+                return false;
+            }
+
+            let new_pred = pred.with_replaced_self_ty(cx.tcx, x_ty);
+            let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, new_pred);
+            infcx.predicate_must_hold_modulo_regions(&obligation)
+            //     match cx.tcx.get_diagnostic_name(pred.def_id()) {
+            //     Some(sym::AsRef) => {
+            //         // TODO: check if it's `AsRef<Path>` in paricular
+            //     },
+            //     Some(sym::Sized) => todo!(),
+            //     _ => return false,
+            // };
+        });
+
+    if !has_preds {
+        // There were no trait clauses -- this means that the type just needs to be `Path`, so the
+        // lint is not applicable
+        return false;
+    }
+
+    has_required_preds
+}