Rename object_safety to dyn_compatibility

Up to a trait implemented by another package, linking to
$CARGO_HOME/registry/cache/index.crates.io-6f17d22bba15001f/

Author: noahmbright

src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs

@@ -382,8 +382,9 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
 }
 
 fnis_object_safe(&self,trait_id: chalk_ir::TraitId<Interner>) -> bool{
+// FIXME: When cargo is updated, change to dyn_compatibility
 let trait_ = from_chalk_trait_id(trait_id);
-crate::object_safety::object_safety(self.db, trait_).is_none()
+crate::dyn_compatibility::dyn_compatibility(self.db, trait_).is_none()
 }
 
 fnclosure_kind(

src/tools/rust-analyzer/crates/hir-ty/src/db.rs

@@ -20,11 +20,11 @@ use triomphe::Arc;
 usecrate::{
  chalk_db,
  consteval::ConstEvalError,
+ dyn_compatibility::DynCompatibilityViolation,
  layout::{Layout,LayoutError},
  lower::{GenericDefaults,GenericPredicates},
  method_resolution::{InherentImpls,TraitImpls,TyFingerprint},
  mir::{BorrowckResult,MirBody,MirLowerError},
- object_safety::ObjectSafetyViolation,
 Binders,ClosureId,Const,FnDefId,ImplTraitId,ImplTraits,InferenceResult,Interner,
 PolyFnSig,Substitution,TraitEnvironment,TraitRef,Ty,TyDefId,ValueTyDefId,
 };
@@ -108,8 +108,8 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
 #[salsa::invoke(crate::layout::target_data_layout_query)]
 fntarget_data_layout(&self,krate:CrateId) -> Result<Arc<TargetDataLayout>,Arc<str>>;
 
-#[salsa::invoke(crate::object_safety::object_safety_of_trait_query)]
-fnobject_safety_of_trait(&self,trait_:TraitId) -> Option<ObjectSafetyViolation>;
+#[salsa::invoke(crate::dyn_compatibility::dyn_compatibility_of_trait_query)]
+fndyn_compatibility_of_trait(&self,trait_:TraitId) -> Option<DynCompatibilityViolation>;
 
 #[salsa::invoke(crate::lower::ty_query)]
 #[salsa::cycle(crate::lower::ty_recover)]
@@ -280,8 +280,8 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
 }
 
 #[test]
-fnhir_database_is_object_safe(){
-fn_assert_object_safe(_:&dynHirDatabase){}
+fnhir_database_is_dyn_compatible(){
+fn_assert_dyn_compatible(_:&dynHirDatabase){}
 }
 
 #[derive(Debug,Clone,Copy,PartialEq,Eq,Hash)]

…lyzer/crates/hir-ty/src/object_safety.rs …r/crates/hir-ty/src/dyn_compatibility.rssrc/tools/rust-analyzer/crates/hir-ty/src/object_safety.rs renamed to src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs src/tools/rust-analyzer/crates/hir-ty/src/object_safety.rs renamed to src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs

@@ -1,4 +1,4 @@
-//! Compute the object-safety of a trait
+//! Compute the dyn-compatibility of a trait
 
 use std::ops::ControlFlow;
 
@@ -28,14 +28,14 @@ use crate::{
 };
 
 #[derive(Debug,Clone,PartialEq,Eq,Hash)]
-pubenumObjectSafetyViolation{
+pubenumDynCompatibilityViolation{
 SizedSelf,
 SelfReferential,
 Method(FunctionId,MethodViolationCode),
 AssocConst(ConstId),
 GAT(TypeAliasId),
 // This doesn't exist in rustc, but added for better visualization
-HasNonSafeSuperTrait(TraitId),
+HasNonCompatibleSuperTrait(TraitId),
 }
 
 #[derive(Debug,Clone,PartialEq,Eq,Hash)]
@@ -50,70 +50,73 @@ pub enum MethodViolationCode {
 UndispatchableReceiver,
 }
 
-pubfnobject_safety(db:&dynHirDatabase,trait_:TraitId) -> Option<ObjectSafetyViolation>{
+pubfndyn_compatibility(
+db:&dynHirDatabase,
+trait_:TraitId,
+) -> Option<DynCompatibilityViolation>{
 for super_trait inall_super_traits(db.upcast(), trait_).into_iter().skip(1).rev(){
-if db.object_safety_of_trait(super_trait).is_some(){
-returnSome(ObjectSafetyViolation::HasNonSafeSuperTrait(super_trait));
+if db.dyn_compatibility_of_trait(super_trait).is_some(){
+returnSome(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait));
 }
 }
 
- db.object_safety_of_trait(trait_)
+ db.dyn_compatibility_of_trait(trait_)
 }
 
-pubfnobject_safety_with_callback<F>(
+pubfndyn_compatibility_with_callback<F>(
 db:&dynHirDatabase,
 trait_:TraitId,
 cb:&mutF,
 ) -> ControlFlow<()>
 where
-F:FnMut(ObjectSafetyViolation) -> ControlFlow<()>,
+F:FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
 {
 for super_trait inall_super_traits(db.upcast(), trait_).into_iter().skip(1).rev(){
-if db.object_safety_of_trait(super_trait).is_some(){
-cb(ObjectSafetyViolation::HasNonSafeSuperTrait(trait_))?;
+if db.dyn_compatibility_of_trait(super_trait).is_some(){
+cb(DynCompatibilityViolation::HasNonCompatibleSuperTrait(trait_))?;
 }
 }
 
-object_safety_of_trait_with_callback(db, trait_, cb)
+dyn_compatibility_of_trait_with_callback(db, trait_, cb)
 }
 
-pubfnobject_safety_of_trait_with_callback<F>(
+pubfndyn_compatibility_of_trait_with_callback<F>(
 db:&dynHirDatabase,
 trait_:TraitId,
 cb:&mutF,
 ) -> ControlFlow<()>
 where
-F:FnMut(ObjectSafetyViolation) -> ControlFlow<()>,
+F:FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
 {
 // Check whether this has a `Sized` bound
 ifgenerics_require_sized_self(db, trait_.into()){
-cb(ObjectSafetyViolation::SizedSelf)?;
+cb(DynCompatibilityViolation::SizedSelf)?;
 }
 
 // Check if there exist bounds that referencing self
 ifpredicates_reference_self(db, trait_){
-cb(ObjectSafetyViolation::SelfReferential)?;
+cb(DynCompatibilityViolation::SelfReferential)?;
 }
 ifbounds_reference_self(db, trait_){
-cb(ObjectSafetyViolation::SelfReferential)?;
+cb(DynCompatibilityViolation::SelfReferential)?;
 }
 
 // rustc checks for non-lifetime binders here, but we don't support HRTB yet
 
 let trait_data = db.trait_data(trait_);
 for(_, assoc_item)in&trait_data.items{
-object_safety_violation_for_assoc_item(db, trait_,*assoc_item, cb)?;
+dyn_compatibility_violation_for_assoc_item(db, trait_,*assoc_item, cb)?;
 }
 
 ControlFlow::Continue(())
 }
 
-pubfnobject_safety_of_trait_query(
+pubfndyn_compatibility_of_trait_query(
 db:&dynHirDatabase,
 trait_:TraitId,
-) -> Option<ObjectSafetyViolation>{
+) -> Option<DynCompatibilityViolation>{
 letmut res = None;
-object_safety_of_trait_with_callback(db, trait_,&mut |osv| {
+dyn_compatibility_of_trait_with_callback(db, trait_,&mut |osv| {
  res = Some(osv);
 ControlFlow::Break(())
 });
@@ -321,14 +324,14 @@ fn contains_illegal_self_type_reference<T: TypeVisitable<Interner>>(
  t.visit_with(visitor.as_dyn(), outer_binder).is_break()
 }
 
-fnobject_safety_violation_for_assoc_item<F>(
+fndyn_compatibility_violation_for_assoc_item<F>(
 db:&dynHirDatabase,
 trait_:TraitId,
 item:AssocItemId,
 cb:&mutF,
 ) -> ControlFlow<()>
 where
-F:FnMut(ObjectSafetyViolation) -> ControlFlow<()>,
+F:FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
 {
 // Any item that has a `Self : Sized` requisite is otherwise
 // exempt from the regulations.
@@ -337,10 +340,10 @@ where
 }
 
 match item {
-AssocItemId::ConstId(it) => cb(ObjectSafetyViolation::AssocConst(it)),
+AssocItemId::ConstId(it) => cb(DynCompatibilityViolation::AssocConst(it)),
 AssocItemId::FunctionId(it) => {
 virtual_call_violations_for_method(db, trait_, it,&mut |mvc| {
-cb(ObjectSafetyViolation::Method(it, mvc))
+cb(DynCompatibilityViolation::Method(it, mvc))
 })
 }
 AssocItemId::TypeAliasId(it) => {
@@ -350,7 +353,7 @@ where
 }else{
 let generic_params = db.generic_params(item.into());
 if !generic_params.is_empty(){
-cb(ObjectSafetyViolation::GAT(it))
+cb(DynCompatibilityViolation::GAT(it))
 }else{
 ControlFlow::Continue(())
 }
@@ -469,7 +472,7 @@ fn receiver_is_dispatchable(
 returnfalse;
 };
 
-// `self: Self` can't be dispatched on, but this is already considered object safe.
+// `self: Self` can't be dispatched on, but this is already considered dyn compatible
 // See rustc's comment on https://github.com/rust-lang/rust/blob/3f121b9461cce02a703a0e7e450568849dfaa074/compiler/rustc_trait_selection/src/traits/object_safety.rs#L433-L437
 if sig
 .skip_binders()