check_is_object_safe -> is_object_safe

compiler-errors · compiler-errors · commit 511f1cf7c8e9 · 2024-06-03T09:49:30.000-04:00
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -881,7 +881,7 @@ fn check_object_unsafe_self_trait_by_name(tcx: TyCtxt<'_>, item: &hir::TraitItem
         _ => {}
     }
     if !trait_should_be_self.is_empty() {
-        if tcx.check_is_object_safe(trait_def_id) {
+        if tcx.is_object_safe(trait_def_id) {
             return;
         }
         let sugg = trait_should_be_self.iter().map(|span| (*span, "Self".to_string())).collect();
diff --git a/compiler/rustc_hir_analysis/src/coherence/mod.rs b/compiler/rustc_hir_analysis/src/coherence/mod.rs
@@ -191,7 +191,7 @@ fn check_object_overlap<'tcx>(
         });
 
         for component_def_id in component_def_ids {
-            if !tcx.check_is_object_safe(component_def_id) {
+            if !tcx.is_object_safe(component_def_id) {
                 // Without the 'object_safe_for_dispatch' feature this is an error
                 // which will be reported by wfcheck. Ignore it here.
                 // This is tested by `coherence-impl-trait-for-trait-object-safe.rs`.
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
@@ -182,7 +182,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             // For recursive traits, don't downgrade the error. (#119652)
                             is_downgradable = false;
                         }
-                        tcx.check_is_object_safe(id)
+                        tcx.is_object_safe(id)
                     }
                     _ => false,
                 })
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
@@ -832,7 +832,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
         let traits = tcx.traits(LOCAL_CRATE);
 
         for &tr in traits {
-            if !tcx.check_is_object_safe(tr) {
+            if !tcx.is_object_safe(tr) {
                 continue;
             }
 
diff --git a/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs b/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
@@ -38,10 +38,10 @@ declare_lint_pass!(MultipleSupertraitUpcastable => [MULTIPLE_SUPERTRAIT_UPCASTAB
 impl<'tcx> LateLintPass<'tcx> for MultipleSupertraitUpcastable {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         let def_id = item.owner_id.to_def_id();
-        // NOTE(nbdd0121): use `object_safety_violations` instead of `check_is_object_safe` because
+        // NOTE(nbdd0121): use `object_safety_violations` instead of `is_object_safe` because
         // the latter will report `where_clause_object_safety` lint.
         if let hir::ItemKind::Trait(_, _, _, _, _) = item.kind
-            && cx.tcx.object_safety_violations(def_id).is_empty()
+            && cx.tcx.is_object_safe(def_id)
         {
             let direct_super_traits_iter = cx
                 .tcx
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
@@ -1309,7 +1309,7 @@ rustc_queries! {
     query object_safety_violations(trait_id: DefId) -> &'tcx [ObjectSafetyViolation] {
         desc { |tcx| "determining object safety of trait `{}`", tcx.def_path_str(trait_id) }
     }
-    query check_is_object_safe(trait_id: DefId) -> bool {
+    query is_object_safe(trait_id: DefId) -> bool {
         desc { |tcx| "checking if trait `{}` is object safe", tcx.def_path_str(trait_id) }
     }
 
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -367,7 +367,7 @@ pub fn transform_instance<'tcx>(
             let trait_method = tcx.associated_item(method_id);
             let trait_id = trait_ref.skip_binder().def_id;
             if traits::is_vtable_safe_method(tcx, trait_id, trait_method)
-                && tcx.object_safety_violations(trait_id).is_empty()
+                && tcx.is_object_safe(trait_id)
             {
                 // Trait methods will have a Self polymorphic parameter, where the concreteized
                 // implementatation will not. We need to walk back to the more general trait method
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
@@ -714,7 +714,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
         };
 
         // Do not consider built-in object impls for non-object-safe types.
-        if bounds.principal_def_id().is_some_and(|def_id| !tcx.check_is_object_safe(def_id)) {
+        if bounds.principal_def_id().is_some_and(|def_id| !tcx.is_object_safe(def_id)) {
             return;
         }
 
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -133,7 +133,7 @@ impl<'a, 'tcx> EvalCtxt<'a, InferCtxt<'tcx>> {
     }
 
     fn compute_object_safe_goal(&mut self, trait_def_id: DefId) -> QueryResult<'tcx> {
-        if self.interner().check_is_object_safe(trait_def_id) {
+        if self.interner().is_object_safe(trait_def_id) {
             self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         } else {
             Err(NoSolution)
diff --git a/compiler/rustc_trait_selection/src/solve/trait_goals.rs b/compiler/rustc_trait_selection/src/solve/trait_goals.rs
@@ -789,7 +789,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
         let Goal { predicate: (a_ty, _), .. } = goal;
 
         // Can only unsize to an object-safe trait.
-        if b_data.principal_def_id().is_some_and(|def_id| !tcx.check_is_object_safe(def_id)) {
+        if b_data.principal_def_id().is_some_and(|def_id| !tcx.is_object_safe(def_id)) {
             return Err(NoSolution);
         }
 
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -411,7 +411,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                 }
 
                 ty::PredicateKind::ObjectSafe(trait_def_id) => {
-                    if !self.selcx.tcx().check_is_object_safe(trait_def_id) {
+                    if !self.selcx.tcx().is_object_safe(trait_def_id) {
                         ProcessResult::Error(FulfillmentErrorCode::Select(Unimplemented))
                     } else {
                         ProcessResult::Changed(vec![])
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -64,7 +64,7 @@ fn object_safety_violations(tcx: TyCtxt<'_>, trait_def_id: DefId) -> &'_ [Object
     )
 }
 
-fn check_is_object_safe(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {
+fn is_object_safe(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {
     tcx.object_safety_violations(trait_def_id).is_empty()
 }
 
@@ -854,7 +854,7 @@ pub fn contains_illegal_impl_trait_in_trait<'tcx>(
 pub fn provide(providers: &mut Providers) {
     *providers = Providers {
         object_safety_violations,
-        check_is_object_safe,
+        is_object_safe,
         generics_require_sized_self,
         ..*providers
     };
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -870,7 +870,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         if let Some(principal) = data.principal() {
                             if !self.infcx.tcx.features().object_safe_for_dispatch {
                                 principal.with_self_ty(self.tcx(), self_ty)
-                            } else if self.tcx().check_is_object_safe(principal.def_id()) {
+                            } else if self.tcx().is_object_safe(principal.def_id()) {
                                 principal.with_self_ty(self.tcx(), self_ty)
                             } else {
                                 return;
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1222,7 +1222,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // `T` -> `Trait`
             (_, &ty::Dynamic(data, r, ty::Dyn)) => {
                 let mut object_dids = data.auto_traits().chain(data.principal_def_id());
-                if let Some(did) = object_dids.find(|did| !tcx.check_is_object_safe(*did)) {
+                if let Some(did) = object_dids.find(|did| !tcx.is_object_safe(*did)) {
                     return Err(TraitNotObjectSafe(did));
                 }
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -798,7 +798,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
 
                 ty::PredicateKind::ObjectSafe(trait_def_id) => {
-                    if self.tcx().check_is_object_safe(trait_def_id) {
+                    if self.tcx().is_object_safe(trait_def_id) {
                         Ok(EvaluatedToOk)
                     } else {
                         Ok(EvaluatedToErr)
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
@@ -1451,7 +1451,7 @@ impl Trait {
         tcx.trait_def(self.def_id).safety
     }
     pub(crate) fn is_object_safe(&self, tcx: TyCtxt<'_>) -> bool {
-        tcx.check_is_object_safe(self.def_id)
+        tcx.is_object_safe(self.def_id)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -881,7 +881,7 @@ fn check_object_unsafe_self_trait_by_name(tcx: TyCtxt<'_>, item: &hir::TraitItem`
`881`	`881`	`_ => {}`
`882`	`882`	`}`
`883`	`883`	`if !trait_should_be_self.is_empty() {`
`884`		`- if tcx.check_is_object_safe(trait_def_id) {`
	`884`	`+ if tcx.is_object_safe(trait_def_id) {`
`885`	`885`	`return;`
`886`	`886`	`}`
`887`	`887`	`let sugg = trait_should_be_self.iter().map(\|span\| (*span, "Self".to_string())).collect();`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {`
`182`	`182`	`// For recursive traits, don't downgrade the error. (#119652)`
`183`	`183`	`is_downgradable = false;`
`184`	`184`	`}`
`185`		`- tcx.check_is_object_safe(id)`
	`185`	`+ tcx.is_object_safe(id)`
`186`	`186`	`}`
`187`	`187`	`_ => false,`
`188`	`188`	`})`
Original file line number	Diff line number	Diff line change
`@@ -832,7 +832,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {`
`832`	`832`	`let traits = tcx.traits(LOCAL_CRATE);`
`833`	`833`
`834`	`834`	`for &tr in traits {`
`835`		`- if !tcx.check_is_object_safe(tr) {`
	`835`	`+ if !tcx.is_object_safe(tr) {`
`836`	`836`	`continue;`
`837`	`837`	`}`
`838`	`838`
Original file line number	Diff line number	Diff line change
`@@ -1309,7 +1309,7 @@ rustc_queries! {`
`1309`	`1309`	`query object_safety_violations(trait_id: DefId) -> &'tcx [ObjectSafetyViolation] {`
`1310`	`1310`	desc { \|tcx\| "determining object safety of trait `{}`", tcx.def_path_str(trait_id) }
`1311`	`1311`	`}`
`1312`		`- query check_is_object_safe(trait_id: DefId) -> bool {`
	`1312`	`+ query is_object_safe(trait_id: DefId) -> bool {`
`1313`	`1313`	desc { \|tcx\| "checking if trait `{}` is object safe", tcx.def_path_str(trait_id) }
`1314`	`1314`	`}`
`1315`	`1315`
Original file line number	Diff line number	Diff line change
`@@ -367,7 +367,7 @@ pub fn transform_instance<'tcx>(`
`367`	`367`	`let trait_method = tcx.associated_item(method_id);`
`368`	`368`	`let trait_id = trait_ref.skip_binder().def_id;`
`369`	`369`	`if traits::is_vtable_safe_method(tcx, trait_id, trait_method)`
`370`		`- && tcx.object_safety_violations(trait_id).is_empty()`
	`370`	`+ && tcx.is_object_safe(trait_id)`
`371`	`371`	`{`
`372`	`372`	`// Trait methods will have a Self polymorphic parameter, where the concreteized`
`373`	`373`	`// implementatation will not. We need to walk back to the more general trait method`
Original file line number	Diff line number	Diff line change
`@@ -714,7 +714,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {`
`714`	`714`	`};`
`715`	`715`
`716`	`716`	`// Do not consider built-in object impls for non-object-safe types.`
`717`		`- if bounds.principal_def_id().is_some_and(\|def_id\| !tcx.check_is_object_safe(def_id)) {`
	`717`	`+ if bounds.principal_def_id().is_some_and(\|def_id\| !tcx.is_object_safe(def_id)) {`
`718`	`718`	`return;`
`719`	`719`	`}`
`720`	`720`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ impl<'a, 'tcx> EvalCtxt<'a, InferCtxt<'tcx>> {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`fn compute_object_safe_goal(&mut self, trait_def_id: DefId) -> QueryResult<'tcx> {`
`136`		`- if self.interner().check_is_object_safe(trait_def_id) {`
	`136`	`+ if self.interner().is_object_safe(trait_def_id) {`
`137`	`137`	`self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)`
`138`	`138`	`} else {`
`139`	`139`	`Err(NoSolution)`
Original file line number	Diff line number	Diff line change
`@@ -789,7 +789,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {`
`789`	`789`	`let Goal { predicate: (a_ty, _), .. } = goal;`
`790`	`790`
`791`	`791`	`// Can only unsize to an object-safe trait.`
`792`		`- if b_data.principal_def_id().is_some_and(\|def_id\| !tcx.check_is_object_safe(def_id)) {`
	`792`	`+ if b_data.principal_def_id().is_some_and(\|def_id\| !tcx.is_object_safe(def_id)) {`
`793`	`793`	`return Err(NoSolution);`
`794`	`794`	`}`
`795`	`795`
Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {`
`411`	`411`	`}`
`412`	`412`
`413`	`413`	`ty::PredicateKind::ObjectSafe(trait_def_id) => {`
`414`		`- if !self.selcx.tcx().check_is_object_safe(trait_def_id) {`
	`414`	`+ if !self.selcx.tcx().is_object_safe(trait_def_id) {`
`415`	`415`	`ProcessResult::Error(FulfillmentErrorCode::Select(Unimplemented))`
`416`	`416`	`} else {`
`417`	`417`	`ProcessResult::Changed(vec![])`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ fn object_safety_violations(tcx: TyCtxt<'_>, trait_def_id: DefId) -> &'_ [Object`
`64`	`64`	`)`
`65`	`65`	`}`
`66`	`66`
`67`		`-fn check_is_object_safe(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {`
	`67`	`+fn is_object_safe(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {`
`68`	`68`	`tcx.object_safety_violations(trait_def_id).is_empty()`
`69`	`69`	`}`
`70`	`70`
`@@ -854,7 +854,7 @@ pub fn contains_illegal_impl_trait_in_trait<'tcx>(`
`854`	`854`	`pub fn provide(providers: &mut Providers) {`
`855`	`855`	`*providers = Providers {`
`856`	`856`	`object_safety_violations,`
`857`		`- check_is_object_safe,`
	`857`	`+ is_object_safe,`
`858`	`858`	`generics_require_sized_self,`
`859`	`859`	`..*providers`
`860`	`860`	`};`