Auto merge of #66037 - nikomatsakis:degenerate-object-safe-issue-57893, r=<try>

[wip] degenerate object safety check for crater

The purpose of this PR is just to be able to do a crater run to assess the impact of the proposed fix for #57893.

With this fix:

* traits that are implemented for unsized types are not dyn safe
* unless they are marked `#[rustc_dyn]` (this would eventually be `dyn trait`)

r? @nikomatsakis  -- this doesn't need review, won't land in this form

Author: bors

src/liballoc/string.rs

@@ -2143,6 +2143,7 @@ impl FromStr for String {
 ///
 /// [`Display`]: ../../std/fmt/trait.Display.html
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(bootstrap), rustc_dyn)]
 pub trait ToString {
     /// Converts the given value to a `String`.
     ///

src/libcore/any.rs

@@ -75,6 +75,7 @@ use crate::intrinsics;
 ///
 /// [mod]: index.html
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(bootstrap), rustc_dyn)]
 pub trait Any: 'static {
     /// Gets the `TypeId` of `self`.
     ///

src/libcore/borrow.rs

@@ -157,6 +157,7 @@
 /// [`String`]: ../../std/string/struct.String.html
 /// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(bootstrap), rustc_dyn)]
 pub trait Borrow<Borrowed: ?Sized> {
     /// Immutably borrows from an owned value.
     ///
@@ -189,6 +190,7 @@ pub trait Borrow<Borrowed: ?Sized> {
 ///
 /// [`Borrow<T>`]: trait.Borrow.html
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(bootstrap), rustc_dyn)]
 pub trait BorrowMut<Borrowed: ?Sized> : Borrow<Borrowed> {
     /// Mutably borrows from an owned value.
     ///

src/librustc/traits/object_safety.rs

@@ -14,13 +14,14 @@ use crate::hir;
 use crate::hir::def_id::DefId;
 use crate::lint;
 use crate::traits::{self, Obligation, ObligationCause};
-use crate::ty::{self, Ty, TyCtxt, TypeFoldable, Predicate, ToPredicate};
+use crate::ty::{self, Ty, TyCtxt, TypeFoldable, Predicate, ToPredicate, ParamTy};
 use crate::ty::subst::{Subst, InternalSubsts};
 use std::borrow::Cow;
 use std::iter::{self};
 use syntax::ast::{self};
 use syntax::symbol::Symbol;
 use syntax_pos::{Span, DUMMY_SP};
+use syntax::symbol::sym;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ObjectSafetyViolation {
@@ -281,7 +282,40 @@ impl<'tcx> TyCtxt<'tcx> {
                     false
                 }
             }
-        )
+            )
+    }
+
+    fn generics_require_sized_param(self, def_id: DefId, param_ty: ParamTy) -> bool {
+        debug!("generics_require_sized_param(def_id={:?}, param_ty={:?})", def_id, param_ty);
+
+        let sized_def_id = match self.lang_items().sized_trait() {
+            Some(def_id) => def_id,
+            None => { return false; /* No Sized trait, can't require it! */ }
+        };
+
+        // Search for a predicate like `Self : Sized` amongst the trait bounds.
+        let predicates = self.predicates_of(def_id);
+        let predicates = predicates.instantiate_identity(self).predicates;
+        predicates
+            .iter()
+            .any(|predicate| match predicate {
+                ty::Predicate::Trait(ref trait_pred) => {
+                    debug!("generics_require_sized_param: trait_pred = {:?}", trait_pred);
+
+                    trait_pred.def_id() == sized_def_id
+                        && trait_pred.skip_binder().self_ty().is_param(param_ty.index)
+                }
+                ty::Predicate::Projection(..) |
+                ty::Predicate::Subtype(..) |
+                ty::Predicate::RegionOutlives(..) |
+                ty::Predicate::WellFormed(..) |
+                ty::Predicate::ObjectSafe(..) |
+                ty::Predicate::ClosureKind(..) |
+                ty::Predicate::TypeOutlives(..) |
+                ty::Predicate::ConstEvaluatable(..) => {
+                    false
+                }
+            })
     }
 
     /// Returns `Some(_)` if this method makes the containing trait not object safe.
@@ -724,8 +758,43 @@ impl<'tcx> TyCtxt<'tcx> {
 
         error
     }
+
+    /// Searches for an impl that potentially overlaps `dyn Trait`
+    /// (where `Trait` is the trait with def-id `trait_def_id`). This
+    /// is used to distinguish between a trait being **fully**
+    /// object-safe and being **degenerate** object-safe -- the latter
+    /// means that we permit `dyn Foo` but we do not supply a `dyn
+    /// Foo: Foo` impl.
+    fn impl_potentially_overlapping_dyn_trait(self, tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {
+        debug!("impl_potentially_overlapping_dyn_trait({:?})", trait_def_id);
+        let mut found_match = false;
+        tcx.for_each_impl(trait_def_id, |impl_def_id| {
+            let impl_self_ty = tcx.type_of(impl_def_id);
+            match impl_self_ty.kind {
+                ty::Param(param_ty) => {
+                    if !self.generics_require_sized_param(impl_def_id, param_ty) {
+                        found_match = true;
+                        debug!("Match found = {}; for param_ty {}", found_match, param_ty.name);
+                        tcx.sess.span_warn(
+                            self.def_span(impl_def_id),
+                            "impl_potentially_overlapping_dyn_trait",
+                        );
+                    }
+                }
+                _ => ()
+            }
+        });
+
+        found_match
+    }
 }
 
 pub(super) fn is_object_safe_provider(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {
-    tcx.object_safety_violations(trait_def_id).is_empty()
+    tcx.object_safety_violations(trait_def_id).is_empty() && {
+        if tcx.has_attr(trait_def_id, sym::rustc_dyn) {
+            true
+        } else {
+            !tcx.impl_potentially_overlapping_dyn_trait(tcx, trait_def_id)
+        }
+    }
 }

src/librustc_data_structures/lib.rs

@@ -24,6 +24,7 @@
 #![feature(integer_atomics)]
 #![feature(test)]
 #![feature(associated_type_bounds)]
+#![feature(rustc_attrs)]
 
 #![cfg_attr(unix, feature(libc))]
 

src/librustc_data_structures/sync.rs

@@ -28,7 +28,10 @@ pub use std::sync::atomic::Ordering;
 
 cfg_if! {
     if #[cfg(not(parallel_compiler))] {
+        #[cfg_attr(not(bootstrap), rustc_dyn)]
         pub auto trait Send {}
+
+        #[cfg_attr(not(bootstrap), rustc_dyn)]
         pub auto trait Sync {}
 
         impl<T: ?Sized> Send for T {}

src/libsyntax/feature_gate/builtin_attrs.rs

@@ -539,6 +539,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     // Internal attributes, Testing:
     // ==========================================================================
 
+    rustc_attr!(TEST, rustc_dyn, Whitelisted, template!(Word)),
     rustc_attr!(TEST, rustc_outlives, Normal, template!(Word)),
     rustc_attr!(TEST, rustc_variance, Normal, template!(Word)),
     rustc_attr!(TEST, rustc_layout, Normal, template!(List: "field1, field2, ...")),

src/libsyntax_pos/symbol.rs

@@ -590,6 +590,7 @@ symbols! {
         rustc_dump_env_program_clauses,
         rustc_dump_program_clauses,
         rustc_dump_user_substs,
+        rustc_dyn,
         rustc_error,
         rustc_expected_cgu_reuse,
         rustc_if_this_changed,