Check impossible predicates, use it to skip NoopMethodCall and Inline

Author: compiler-errors

compiler/rustc_lint/src/noop_method_call.rs

@@ -67,10 +67,16 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
             // we need to perform substitution.
             return;
         }
+
+        if cx.tcx.instantiated_item_has_impossible_predicates((did, substs)) {
+            tracing::trace!("NoopMethodCall skipped for {:?}: found unsatisfiable predicates", did);
+            return;
+        }
+
         let param_env = cx.tcx.param_env(trait_id);
         // Resolve the trait method instance.
         let Ok(Some(i)) = ty::Instance::resolve(cx.tcx, param_env, did, substs) else {
-            return
+            return;
         };
         // (Re)check that it implements the noop diagnostic.
         let Some(name) = cx.tcx.get_diagnostic_name(i.def_id()) else { return };

compiler/rustc_middle/src/mir/mono.rs

@@ -175,7 +175,7 @@ impl<'tcx> MonoItem<'tcx> {
             MonoItem::GlobalAsm(..) => return true,
         };
 
-        !tcx.subst_and_check_impossible_predicates((def_id, &substs))
+        !tcx.instantiated_item_has_impossible_predicates((def_id, &substs))
     }
 
     pub fn local_span(&self, tcx: TyCtxt<'tcx>) -> Option<Span> {

compiler/rustc_middle/src/query/mod.rs

@@ -1870,10 +1870,38 @@ rustc_queries! {
         remap_env_constness
     }
 
-    query subst_and_check_impossible_predicates(key: (DefId, SubstsRef<'tcx>)) -> bool {
+    query instantiated_item_has_impossible_predicates(key: (DefId, SubstsRef<'tcx>)) -> bool {
         desc { |tcx|
-            "impossible substituted predicates:`{}`",
-            tcx.def_path_str(key.0)
+            "`{}` has impossible predicates after substituting `{:?}`",
+            tcx.def_path_str(key.0), key.1
+        }
+    }
+
+    // Check if it's even possible to satisfy the 'where' clauses
+    // for this item, without substitutions.
+    //
+    // We don't usually need to worry about this kind of case,
+    // since we would get a compilation error if the user tried
+    // to call it. However, since we can do certain mir optimizations
+    // and lints even without any calls to the function, we need to
+    // make sure that it even makes sense to try to evaluate predicates
+    // dependent on the where-clause of this function.
+    //
+    // We manually filter the predicates, skipping anything that's not
+    // "global". We are in a potentially generic context
+    // (e.g. we are evaluating a function without substituting generic
+    // parameters), so this filtering serves two purposes:
+    //
+    // 1. We skip evaluating any predicates that we would
+    // never be able prove are unsatisfiable (e.g. `<T as Foo>`
+    // 2. We avoid trying to normalize predicates involving generic
+    // parameters (e.g. `<T as Foo>::MyItem`). This can confuse
+    // the normalization code (leading to cycle errors), since
+    // it's usually never invoked in this way.
+    query item_has_impossible_predicates_for_item(key: DefId) -> bool {
+        desc { |tcx|
+            "`{}` has impossible predicates",
+            tcx.def_path_str(key)
         }
     }
 

compiler/rustc_mir_transform/src/const_prop.rs

@@ -22,7 +22,6 @@ use rustc_middle::ty::{self, ConstKind, Instance, ParamEnv, Ty, TyCtxt, TypeFold
 use rustc_span::{def_id::DefId, Span};
 use rustc_target::abi::{HasDataLayout, Size, TargetDataLayout};
 use rustc_target::spec::abi::Abi;
-use rustc_trait_selection::traits;
 
 use crate::MirPass;
 use rustc_const_eval::interpret::{
@@ -90,41 +89,7 @@ impl<'tcx> MirPass<'tcx> for ConstProp {
             return;
         }
 
-        // Check if it's even possible to satisfy the 'where' clauses
-        // for this item.
-        // This branch will never be taken for any normal function.
-        // However, it's possible to `#!feature(trivial_bounds)]` to write
-        // a function with impossible to satisfy clauses, e.g.:
-        // `fn foo() where String: Copy {}`
-        //
-        // We don't usually need to worry about this kind of case,
-        // since we would get a compilation error if the user tried
-        // to call it. However, since we can do const propagation
-        // even without any calls to the function, we need to make
-        // sure that it even makes sense to try to evaluate the body.
-        // If there are unsatisfiable where clauses, then all bets are
-        // off, and we just give up.
-        //
-        // We manually filter the predicates, skipping anything that's not
-        // "global". We are in a potentially generic context
-        // (e.g. we are evaluating a function without substituting generic
-        // parameters, so this filtering serves two purposes:
-        //
-        // 1. We skip evaluating any predicates that we would
-        // never be able prove are unsatisfiable (e.g. `<T as Foo>`
-        // 2. We avoid trying to normalize predicates involving generic
-        // parameters (e.g. `<T as Foo>::MyItem`). This can confuse
-        // the normalization code (leading to cycle errors), since
-        // it's usually never invoked in this way.
-        let predicates = tcx
-            .predicates_of(def_id.to_def_id())
-            .predicates
-            .iter()
-            .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
-        if traits::impossible_predicates(
-            tcx,
-            traits::elaborate_predicates(tcx, predicates).map(|o| o.predicate).collect(),
-        ) {
+        if tcx.item_has_impossible_predicates_for_item(def_id) {
             trace!("ConstProp skipped for {:?}: found unsatisfiable predicates", def_id);
             return;
         }

compiler/rustc_mir_transform/src/inline.rs

@@ -6,7 +6,6 @@ use rustc_index::vec::Idx;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::mir::visit::*;
 use rustc_middle::mir::*;
-use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, ConstKind, Instance, InstanceDef, ParamEnv, Ty, TyCtxt};
 use rustc_span::{hygiene::ExpnKind, ExpnData, LocalExpnId, Span};
@@ -74,18 +73,14 @@ fn inline<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> bool {
         return false;
     }
 
-    let param_env = tcx.param_env_reveal_all_normalized(def_id);
-    let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
-    let param_env = rustc_trait_selection::traits::normalize_param_env_or_error(
-        tcx,
-        def_id.to_def_id(),
-        param_env,
-        ObligationCause::misc(body.span, hir_id),
-    );
+    if tcx.item_has_impossible_predicates_for_item(def_id) {
+        trace!("Inline skipped for {:?}: found unsatisfiable predicates", def_id);
+        return false;
+    }
 
     let mut this = Inliner {
         tcx,
-        param_env,
+        param_env: tcx.param_env_reveal_all_normalized(def_id),
         codegen_fn_attrs: tcx.codegen_fn_attrs(def_id),
         history: Vec::new(),
         changed: false,

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -454,17 +454,38 @@ pub fn impossible_predicates<'tcx>(
     result
 }
 
-fn subst_and_check_impossible_predicates<'tcx>(
+fn instantiated_item_has_impossible_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: (DefId, SubstsRef<'tcx>),
 ) -> bool {
-    debug!("subst_and_check_impossible_predicates(key={:?})", key);
+    debug!("instantiated_item_has_impossible_predicates(key={:?})", key);
 
     let mut predicates = tcx.predicates_of(key.0).instantiate(tcx, key.1).predicates;
     predicates.retain(|predicate| !predicate.needs_subst());
     let result = impossible_predicates(tcx, predicates);
 
-    debug!("subst_and_check_impossible_predicates(key={:?}) = {:?}", key, result);
+    debug!("instantiated_item_has_impossible_predicates(key={:?}) = {:?}", key, result);
+    result
+}
+
+fn item_has_impossible_predicates_for_item<'tcx>(tcx: TyCtxt<'tcx>, key: DefId) -> bool {
+    debug!("item_has_impossible_predicates_for_item(key={:?})", key);
+
+    let result = impossible_predicates(
+        tcx,
+        elaborate_predicates_with_span(
+            tcx,
+            tcx.predicates_of(key)
+                .predicates
+                .iter()
+                .filter(|predicate| predicate.is_global())
+                .copied(),
+        )
+        .map(|o| o.predicate)
+        .collect(),
+    );
+
+    debug!("item_has_impossible_predicates_for_item(key={:?}) = {:?}", key, result);
     result
 }
 
@@ -847,7 +868,8 @@ pub fn provide(providers: &mut ty::query::Providers) {
         own_existential_vtable_entries,
         vtable_entries,
         vtable_trait_upcasting_coercion_new_vptr_slot,
-        subst_and_check_impossible_predicates,
+        instantiated_item_has_impossible_predicates,
+        item_has_impossible_predicates_for_item,
         thir_abstract_const: |tcx, def_id| {
             let def_id = def_id.expect_local();
             if let Some(def) = ty::WithOptConstParam::try_lookup(def_id, tcx) {

src/test/ui/trait-bounds/issue-93008.rs

@@ -1,10 +1,15 @@
-// compile-flags: -Zmir-opt-level=4
+// build-pass
+// compile-flags: -Zmir-opt-level=3 --crate-type=lib
 
-pub fn bar<T>(s: &'static mut ())
+#![feature(trivial_bounds)]
+#![allow(trivial_bounds)]
+
+trait Foo {
+    fn test(self);
+}
+fn baz<T>()
 where
-    &'static mut (): Clone, //~ ERROR the trait bound
+    &'static str: Foo,
 {
-    <&'static mut () as Clone>::clone(&s);
+    "Foo".test()
 }
-
-fn main() {}

src/test/ui/trait-bounds/issue-93008.stderr

@@ -0,0 +1,14 @@
+// check-pass
+
+fn main() {
+    println!("{:?}", {
+        type T = ();
+
+        pub fn cloneit(it: &'_ mut T) -> (&'_ mut T, &'_ mut T)
+        where
+            for<'any> &'any mut T: Clone,
+        {
+            (it.clone(), it)
+        }
+    });
+}

src/test/ui/trait-bounds/issue-94680.rs

@@ -0,0 +1,31 @@
+// check-pass
+
+trait Identity<Q> {
+    type T;
+}
+
+impl<Q, T> Identity<Q> for T {
+    type T = T;
+}
+
+trait Holds {
+    type Q;
+}
+
+
+struct S;
+struct X(S);
+
+struct XHelper;
+
+impl Holds for X {
+    type Q = XHelper;
+}
+
+impl<Q> Clone for X where <S as Identity<Q>>::T: Clone, X: Holds<Q = Q> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+fn main() {}