Don't eagerly monomorphize drop for types that are impossible to inst…

…antiate

compiler/rustc_monomorphize/src/collector.rs

@@ -1434,6 +1434,15 @@ impl<'v> RootCollector<'_, 'v> {
                 {
                     debug!("RootCollector: ADT drop-glue for `{id:?}`",);
 
+                    // This type is impossible to instantiate, so we should not try to
+                    // generate a `drop_in_place` instance for it.
+                    if self.tcx.instantiate_and_check_impossible_predicates((
+                        id.owner_id.to_def_id(),
+                        ty::List::empty(),
+                    )) {
+                        return;
+                    }
+
                     let ty = self.tcx.type_of(id.owner_id.to_def_id()).no_bound_vars().unwrap();
                     visit_drop_use(self.tcx, ty, true, DUMMY_SP, self.output);
                 }

tests/ui/codegen/mono-impossible.rs

@@ -3,11 +3,18 @@
 
 // Make sure that we don't monomorphize the impossible method `<() as Visit>::visit`,
 // which does not hold under a reveal-all param env.
-
 pub trait Visit {
     fn visit() {}
 }
-
 pub trait Array<'a> {}
-
 impl Visit for () where (): for<'a> Array<'a> {}
+
+// Make sure we don't monomorphize the drop impl for `Baz`, since it has predicates
+// that don't hold under a reveal-all param env.
+trait Foo {
+    type Assoc;
+}
+struct Bar;
+pub struct Baz(<Bar as Foo>::Assoc)
+where
+    Bar: Foo;