Simplify predicate handling

Author: smoelius

compiler/rustc_lint/src/internal.rs

@@ -4,9 +4,8 @@
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, HirId};
-use rustc_middle::ty::{
-    self, ClauseKind, GenericArgsRef, ParamTy, ProjectionPredicate, TraitPredicate, Ty,
-};
+use rustc_infer::infer::canonical::ir::TraitPredicate;
+use rustc_middle::ty::{self, ClauseKind, GenericArgsRef, PredicatePolarity, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::{Span, sym};
@@ -122,47 +121,38 @@ fn check_into_iter_stability<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx
         return;
     };
     // Is `expr` a function or method call?
-    let Some((callee_def_id, _span, generic_args, recv, args)) =
+    let Some((callee_def_id, span, generic_args, _recv, _args)) =
         get_callee_span_generic_args_and_args(cx, expr)
     else {
         return;
     };
-    let fn_sig = cx.tcx.fn_sig(callee_def_id).instantiate_identity().skip_binder();
-    for (arg_index, &input) in fn_sig.inputs().iter().enumerate() {
-        let &ty::Param(ParamTy { index: param_index, .. }) = input.kind() else {
+    let predicates = cx.tcx.predicates_of(callee_def_id).instantiate(cx.tcx, generic_args);
+    for (predicate, _) in predicates {
+        let ClauseKind::Trait(TraitPredicate { trait_ref, polarity: PredicatePolarity::Positive }) =
+            predicate.kind().skip_binder()
+        else {
             continue;
         };
-        let (trait_predicates, _) = get_input_traits_and_projections(cx, callee_def_id, input);
-        for TraitPredicate { trait_ref, .. } in trait_predicates {
-            // Does the function or method require any of its arguments to implement `IntoIterator`?
-            if trait_ref.def_id != into_iterator_def_id {
-                continue;
-            }
-            let self_ty_generic_arg = generic_args[param_index as usize];
-            let Ok(Some(instance)) = ty::Instance::try_resolve(
-                cx.tcx,
-                cx.typing_env(),
-                into_iter_fn_def_id,
-                cx.tcx.mk_args(&[self_ty_generic_arg]),
-            ) else {
-                continue;
-            };
-            // Does the input type's `IntoIterator` implementation have the
-            // `rustc_lint_query_instability` attribute on its `into_iter` method?
-            if !cx.tcx.has_attr(instance.def_id(), sym::rustc_lint_query_instability) {
-                return;
-            }
-            let span = if let Some(recv) = recv {
-                if arg_index == 0 { recv.span } else { args[arg_index - 1].span }
-            } else {
-                args[arg_index].span
-            };
-            cx.emit_span_lint(
-                POTENTIAL_QUERY_INSTABILITY,
-                span,
-                QueryInstability { query: cx.tcx.item_name(instance.def_id()) },
-            );
+        // Does the function or method require any of its arguments to implement `IntoIterator`?
+        if trait_ref.def_id != into_iterator_def_id {
+            continue;
+        }
+        let Ok(Some(instance)) =
+            ty::Instance::try_resolve(cx.tcx, cx.typing_env(), into_iter_fn_def_id, trait_ref.args)
+        else {
+            continue;
+        };
+        // Does the input type's `IntoIterator` implementation have the
+        // `rustc_lint_query_instability` attribute on its `into_iter` method?
+        if !cx.tcx.has_attr(instance.def_id(), sym::rustc_lint_query_instability) {
+            return;
         }
+        let span = span.with_hi(expr.span.hi());
+        cx.emit_span_lint(
+            POTENTIAL_QUERY_INSTABILITY,
+            span,
+            QueryInstability { query: cx.tcx.item_name(instance.def_id()) },
+        );
     }
 }
 
@@ -188,32 +178,6 @@ fn get_callee_span_generic_args_and_args<'tcx>(
     None
 }
 
-/// Returns the `TraitPredicate`s and `ProjectionPredicate`s for a function's input type.
-fn get_input_traits_and_projections<'tcx>(
-    cx: &LateContext<'tcx>,
-    callee_def_id: DefId,
-    input: Ty<'tcx>,
-) -> (Vec<TraitPredicate<'tcx>>, Vec<ProjectionPredicate<'tcx>>) {
-    let mut trait_predicates = Vec::new();
-    let mut projection_predicates = Vec::new();
-    for predicate in cx.tcx.param_env(callee_def_id).caller_bounds() {
-        match predicate.kind().skip_binder() {
-            ClauseKind::Trait(trait_predicate) => {
-                if trait_predicate.trait_ref.self_ty() == input {
-                    trait_predicates.push(trait_predicate);
-                }
-            }
-            ClauseKind::Projection(projection_predicate) => {
-                if projection_predicate.projection_term.self_ty() == input {
-                    projection_predicates.push(projection_predicate);
-                }
-            }
-            _ => {}
-        }
-    }
-    (trait_predicates, projection_predicates)
-}
-
 declare_tool_lint! {
     /// The `usage_of_ty_tykind` lint detects usages of `ty::TyKind::<kind>`,
     /// where `ty::<kind>` would suffice.

tests/ui-fulldeps/internal-lints/query_stability.stderr

@@ -60,18 +60,18 @@ LL |     for val in x.values_mut() {
    = note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
 
 error: using `into_iter` can result in unstable query results
-  --> $DIR/query_stability.rs:38:45
+  --> $DIR/query_stability.rs:38:38
    |
 LL |     FxHashMap::<u32, i32>::default().extend(x);
-   |                                             ^
+   |                                      ^^^^^^^^^
    |
    = note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
 
 error: using `into_iter` can result in unstable query results
-  --> $DIR/query_stability.rs:47:24
+  --> $DIR/query_stability.rs:47:9
    |
 LL |     _ = hide_into_iter(map);
-   |                        ^^^
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale