Closed leoyvens closed 3 hours ago
To clarify: we are specifically interested in getting feedback on places where this lint causes you issues, since that will help us to judge how well more precise fixes would work.
This caused a future-compat warning in the upcoming futures
0.3 crate. Minimized example:
#![feature(arbitrary_self_types, pin)]
use std::marker::Unpin;
use std::mem::PinMut;
trait Future {
fn poll(self: PinMut<Self>);
}
trait FutureExt: Future {
fn poll_unpin(&mut self) where Self: Unpin {
PinMut::new(self).poll()
}
}
The error:
warning: the trait `FutureExt` cannot be made into an object
--> foo.rs:11:5
|
11 | / fn poll_unpin(&mut self) where Self: Unpin {
12 | | PinMut::new(self).poll()
13 | | }
| |_____^
|
= note: #[warn(where_clauses_object_safety)] on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
= note: method `poll_unpin` references the `Self` type in where clauses
It seems like it should be possible to permit calls to poll_unpin
in cases where Self
is a dyn Trait
type where Trait: Unpin
.
Thanks @cramertj -- that falls pretty squarely into the rules we had in mind! Let's discuss the details of those rules in #50781 I guess, I want to try and "re-sync" (but I guess I'd rather keep this thread for people to report issues).
But just to summarize, the rule we had in mind is roughly this:
Trait
has a method method
with a where-clause where Self: XXX
dyn Trait: XXX
cannot be proventrait Trait: XXX
-- we could perhaps try to distinguish those cases; in Chalk terms, XXX
would be an implied bound of Trait
That applies to your example, I believe, since dyn Future: Unpin
does not hold.
This is a kind of generalization of the rule around where Self: Sized
-- except that, in that case, we know that dyn Trait: Sized
could never be proven, and hence we can suspend the where-clause requirements entirely.
For anyone reading this, I got the warning/error on a trait that was like this:
pub trait Config {
fn save(&self, path: &Path) -> Result<(), ()> where Self: serde::Serialize { ... }
}
In my case I was able to make the problem go away by requiring the thing implementing Config to also implement serde::Serialize:
pub trait Config: serde::Serialize {
fn save(&self, path: &Path) -> Result<(), ()> { ... }
}
This broke bindgen:
error: the trait `ir::template::TemplateParameters` cannot be made into an object
--> src/ir/template.rs:134:5
|
134 | / fn all_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
135 | | where
136 | | Self: ItemAncestors,
137 | | {
... |
141 | | }).collect()
142 | | }
| |_____^
|
note: lint level defined here
--> src/lib.rs:11:9
|
11 | #![deny(warnings)]
| ^^^^^^^^
= note: #[deny(where_clauses_object_safety)] implied by #[deny(warnings)]
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
= note: method `all_template_params` references the `Self` type in where clauses
error: the trait `ir::template::TemplateParameters` cannot be made into an object
--> src/ir/template.rs:147:5
|
147 | / fn used_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
148 | | where
149 | | Self: AsRef<ItemId>,
150 | | {
... |
160 | | .collect()
161 | | }
| |_____^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
= note: method `used_template_params` references the `Self` type in where clauses
error: aborting due to 2 previous errors
error: Could not compile `bindgen`.
This is on this bindgen commit fwiw: https://github.com/rust-lang-nursery/rust-bindgen/commit/29dad405165756be9ce8da659a76c4cfa331a01e
I have an extension trait that was never supposed to be made into an object which triggers this. It only exists to add a few methods.
I could limit the implementors to just [T]
down from T: AsRef<[T]>
which would stop the lint from firing (and also be a better design), but it would also make the dyn capability pointless as there's only one type that could be made into the object.
I like this as a lint but the it will become a hard error in a future release!
part of the error message should go. Not all traits require dyn capability.
Edit: In fact, the lint is a false positive. The trait isn't dyn capable already because it contains generic functions.
I bumped into this upcasting boxed trait objects with marker traits. There may be a way to do this safely that doesn't fall foul of this lint?
use std::any::Any;
trait Trait: Any {
fn into_any(self: Box<Self>) -> Box<Any>;
fn into_any_send(self: Box<Self>) -> Box<Any+Send> where Self: Send;
fn into_any_sync(self: Box<Self>) -> Box<Any+Sync> where Self: Sync;
fn into_any_send_sync(self: Box<Self>) -> Box<Any+Send+Sync> where Self: Send+Sync;
}
impl<T> Trait for T where T: Any {
fn into_any(self: Box<Self>) -> Box<Any> {
self
}
fn into_any_send(self: Box<Self>) -> Box<Any+Send> where Self: Send {
self
}
fn into_any_sync(self: Box<Self>) -> Box<Any+Sync> where Self: Sync {
self
}
fn into_any_send_sync(self: Box<Self>) -> Box<Any+Send+Sync> where Self: Send+Sync {
self
}
}
fn main() {
let a: usize = 123;
let b: Box<Trait+Send+Sync> = Box::new(a);
let c: Box<Any+Send+Sync> = b.into_any_send_sync();
let _d: usize = *Box::<Any>::downcast(c).unwrap();
}
This warns on AnyMap
, but I don't understand enough to really figure out what's going on and how it should be fixed:
warning: the trait `anymap::any::CloneToAny` cannot be made into an object
--> /home/.cargo/registry/src/github.com-1ecc6299db9ec823/anymap-0.12.1/src/any.rs:21:5
|
21 | fn clone_to_any_send_sync(&self) -> Box<CloneAny + Send + Sync> where Self: Send + Sync;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
= note: method `clone_to_any_send_sync` references the `Self` type in where clauses
I have an extension trait that i want to be usable with ?Sized types (including str) where this is causing a problem.
This is the reduced version of the trait:
trait SelfOps{
fn piped_ref<'a,F, U>(&'a self, f: F) -> U
where
F: FnOnce(&'a Self) -> U,
{
f(self)
}
fn format_debug(&self)->String
where Self:fmt::Debug
{
format!("{:?}",self)
}
}
impl<This:?Sized> SelfOps for This{}
With the previous 2 methods I get this somewhat confusing pair of warning and error :
warning: the trait `SelfOps` cannot be made into an object
--> src/main.rs:11:5
|
11 | / fn format_debug(&self)->String
12 | | where Self:fmt::Debug
13 | | {
14 | | format!("{:?}",self)
15 | | }
| |_____^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
= note: method `format_debug` references the `Self` type in where clauses
error[E0038]: the trait `SelfOps` cannot be made into an object
--> src/main.rs:23:18
|
23 | let x=&() as &SelfOps;
| ^^^^^^^^ the trait `SelfOps` cannot be made into an object
|
= note: method `piped_ref` has generic type parameters
It seems to me that if it knows that it can't be turned into a trait object because it has a generic method, then it should not warn because of the Self type in the where clause of format_debug.
On the AnyMap case: it’s substantially the same as what @alecmocatta is reporting. This lint causes trouble with auto traits.
core::any::Any
has the ability to be Any + Send
, and Any + Send + Sync
, and that’s OK because it doesn’t need any support inside the trait object for code specific to Send and/or Sync functionality—just an impl Any + Send
block.
AnyMap has an extension of that, a cloneable Any. That part is fine, but when you get to additional trait bounds, you need a function that will be in the vtable; and that’s where we run into trouble under this new scheme.
Here’s a simplified version of some of the code (covering only the Send
bound):
#[doc(hidden)]
pub trait CloneToAny {
/// Clone `self` into a new `Box<CloneAny>` object.
fn clone_to_any(&self) -> Box<CloneAny>;
/// Clone `self` into a new `Box<CloneAny + Send>` object.
fn clone_to_any_send(&self) -> Box<CloneAny + Send> where Self: Send;
}
impl<T: Any + Clone> CloneToAny for T {
fn clone_to_any(&self) -> Box<CloneAny> {
Box::new(self.clone())
}
fn clone_to_any_send(&self) -> Box<CloneAny + Send> where Self: Send {
Box::new(self.clone())
}
}
pub trait CloneAny: Any + CloneToAny { }
impl<T: Any + Clone> CloneAny for T { }
impl Clone for Box<CloneAny> {
fn clone(&self) -> Box<CloneAny> {
(**self).clone_to_any()
}
}
impl Clone for Box<CloneAny + Send> {
fn clone(&self) -> Box<CloneAny + Send> {
(**self).clone_to_any_send()
}
}
Now as it stands, I know that if I have a Box<CloneAny + Send>
, then I know that calling clone_to_any_send
is safe.
I would like to retain the same interface: adding trait bounds is a known and sane way of handling these things—the way you’re supposed to handle it. But if necessary, I suppose the proliferation of traits can begin, with CloneAny
, CloneSendAny
, CloneSendSyncAny
, &c.
As it stands, I’m seeing a few options for me as a developer:
#[allow(where_clauses_object_safety)]
!);clone_to_any_*
methods, leaving only clone_to_any
, then cross my fingers, make the Clone
implementation transmute between Box<CloneAny>
and Box<CloneAny + Send>
, and hope that the vtables are the same and that nothing will explode;Expanding on the appeal: I don’t know, but my impression is that auto traits won’t trigger the memory unsafety problem. If so, is it reasonable to check whether the additional bounds on Self are all auto traits, and consider that acceptable code?
And if tweaking the lint is not reasonable, is what I outline in the second item reasonable? Will Rust eat my laundry if I transmute Box<CloneAny>
and Box<CloneAny + Send>
?
(Quite incidentally: where I’m from “laundry” refers to the room where clothes washing is done, not to the pile of clothes, which is called the “washing”. The whole “may eat your laundry” thing was therefore much more amusing to contemplate than it would have been if it were mere clothes that were being devoured.)
And if tweaking the lint is not reasonable, is what I outline in the second item reasonable? Will Rust eat my laundry if I transmute
Box<CloneAny>
andBox<CloneAny + Send>
?
This is effectively what's done by the stdlib here:
my impression is that auto traits won’t trigger the memory unsafety problem. If so, is it reasonable to check whether the additional bounds on Self are all auto traits, and consider that acceptable code?
This is true, this lint can be tweaked to not fire if the bounds are all auto traits.
How should I deal with that warning?
Does it only trigger if I create a trait object or otherwise interact with dyn Trait
? I think I'm doing neither but the warning still triggers.
I'm hitting this on a method that doesn't appear to reference the Self
type in a where
clause. When I try to use a dyn Store
elsewhere in the program I get the error on this method:
#[async_trait]
pub trait Store {
async fn fetch_pod_modules(&self, pod: &Pod) -> anyhow::Result<HashMap<String, Vec<u8>>> {
// ...
}
}
// Error:
// the trait `kubelet::store::Store` cannot be made into an object
// the trait cannot be made into an object because method `fetch_pod_modules`
// references the `Self` type in its `where` clause
I think this is to do with the way async_trait
expands async methods. The docs give the following example of an expansion (https://docs.rs/async-trait/0.1.36/async_trait/#explanation):
impl Advertisement for AutoplayingVideo {
fn run<'async>(
&'async self,
) -> Pin<Box<dyn core::future::Future<Output = ()> + Send + 'async>>
where
Self: Sync + 'async, // <--------- AHA?
{
// ...
}
}
Is there a recommended workaround for async_trait
members?
Answering my own question: the workaround is to add Sync
as a supertrait of Store
(documentation: https://docs.rs/async-trait/0.1.36/async_trait/#dyn-traits).
I wanted to provide feedback that the warnings emitted by this in 1.57 (which are effectively unchanged from previous comments) when async_trait
(and presumably other macros) is in play are confusing. Concretely:
warning: the trait `repository::ReleaseReader` cannot be made into an object
--> tugger-debian/src/repository/mod.rs:283:14
|
283 | async fn resolve_packages(
| ^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> tugger-debian/src/repository/mod.rs:283:14
|
172 | pub trait ReleaseReader {
| ------------- this trait cannot be made into an object...
...
283 | async fn resolve_packages(
| ^^^^^^^^^^^^^^^^ ...because method `resolve_packages` references the `Self` type in its `where` clause
= help: consider moving `resolve_packages` to another trait
As @itowlson pointed out in previous comments, this is an issue with how async_trait
works and can easily be worked around by adding Sync
as a supertrait (thank you for the tips!). But, the compiler warning didn't make it obvious that a macro was involved.
In other compiler diagnostics, when an issue involves a macro, the compiler can give me the hint that a macro is in play. This can often short-circuit a lot of debugging. Would it be possible for the compiler to detect when this issue is (possibly) influenced via a macro and provide such a hint?
Furthermore, the existing warning says e.g.
because method `resolve_packages` references the `Self` type in its `where` clause`
However, my trait member is defined as async fn resolve_packages(&self, ...) -> Result<BinaryPackageList<'static>, RepositoryReadError>;
and... doesn't have a where
clause! I think the macro expansion performed by async_trait
does introduce a where
clause. But since the compiler isn't printing the expanded output, this left me scratching my head as to what exactly the references the...
error message was referring to! (What where clause?!) Again, I think this warning could be much more actionable if there were a hint that a macro were involved and/or a pointer to the exact where
clause introducing the constraint.
I'm encoutering the same issue: https://github.com/lunar-mining/trait_ptr
When I add Sync to the trait it compiles fine providing the trait methods pass &self.
But if I change this to an Arc<Self>
then it produces the same warning.
This compiles without the warning:
use std::sync::{Arc, Weak};
fn main() {
println!("Hello, world!");
}
pub type MyTraitPtr = Arc<dyn MyTrait>;
#[async_trait]
pub trait MyTrait: Sync {
async fn foo(&self) {}
}
pub struct Parent {
child: MyTraitPtr,
}
This does not:
use async_trait::async_trait;
use std::sync::{Arc, Weak};
fn main() {
println!("Hello, world!");
}
pub type MyTraitPtr = Arc<dyn MyTrait>;
#[async_trait]
pub trait MyTrait: Sync {
async fn foo(self: Arc<Self>) {}
}
pub struct Parent {
child: MyTraitPtr,
}
This is the full warning:
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> src/main.rs:12:14
|
11 | pub trait MyTrait: Sync {
| ------- this trait cannot be made into an object...
12 | async fn foo(self: Arc<Self>) {}
| ^^^ ...because method `foo` references the `Self` type in its `where` clause
= help: consider moving `foo` to another trait
Did something happen intentionally with this recently? The following code compiles cleanly on nightly-2022-12-28, but triggers a warning with nightly-2022-12-29. Yet I don't see any recent PR linked to this tracking issue.
pub trait Trait {
fn method(&self) where Self: Sync;
}
warning: the trait `Trait` cannot be made into an object
--> src/main.rs:2:8
|
2 | fn method(&self) where Self: Sync;
| ^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> src/main.rs:2:8
|
1 | pub trait Trait {
| ----- this trait cannot be made into an object...
2 | fn method(&self) where Self: Sync;
| ^^^^^^ ...because method `method` references the `Self` type in its `where` clause
= help: consider moving `method` to another trait
= note: `#[warn(where_clauses_object_safety)]` on by default
This has also recently started triggering on tokio::io::AsyncBufReadExt
.
Triggering on der
(RustCrypto/formats) as well: https://github.com/RustCrypto/formats/actions/runs/3803406941/jobs/6469791942
The triggering offending code:
/// Encode the value part of a Tag-Length-Value encoded field, sans the [`Tag`]
/// and [`Length`].
pub trait EncodeValue {
/// Get the [`Header`] used to encode this value.
fn header(&self) -> Result<Header>
where
Self: Tagged,
{
Header::new(self.tag(), self.value_len()?)
}
/// Compute the length of this value (sans [`Tag`]+[`Length`] header) when
/// encoded as ASN.1 DER.
fn value_len(&self) -> Result<Length>;
/// Encode value (sans [`Tag`]+[`Length`] header) as ASN.1 DER using the
/// provided [`Writer`].
fn encode_value(&self, encoder: &mut dyn Writer) -> Result<()>;
}
(Based on my reading of the object safety docs, the problem here is the where Self: Tagged
constraint?)
we are specifically interested in getting feedback on places where this lint causes you issues, since that will help us to judge how well more precise fixes would work.
Overall my impression is that this lint is too burdensome in the current form.
Async_trait is a casualty if we keep this. For example:
#[async_trait]
pub trait Trait {
fn synchronous(&self) {}
async fn asynchronous(&self) {}
}
This needs to expand to something like:
pub trait Trait {
// want to call this on non-Sync impls
fn synchronous(&self) {}
// as long as we're using Send futures (e.g. tokio) this only makes
// sense to call on Sync impls, hence the where-clause
fn asynchronous(&self) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>
where
Self: Sync,
{
Box::pin(async move { ... })
}
}
Using the following expansion instead is not a sufficient workaround because that prevents calling synchronous
on non-Sync impls:
pub trait Trait: Sync {
fn synchronous(&self) {}
fn asynchronous(&self) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
Box::pin(async move { ... })
}
}
From studying https://github.com/rust-lang/rust/issues/51443#issue-330805907, it's not clear to me that the justification for this lint applies to the above trait in the first place. The motivation for the lint is that someone might write:
unsafe impl Sync for dyn Trait + '_ {}
and then improperly be able to call the asynchronous
method on non-Sync receivers. However that's silly for 2 reasons:
error[E0321]: cross-crate traits with a default impl, like `Sync`, can only be implemented for a struct/enum type, not `dyn Trait`
--> src/main.rs
|
| unsafe impl Sync for dyn Trait + '_ {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type
So I think this needs to be allowed.
Well, we need to change something to fix https://github.com/rust-lang/rust/issues/50781. Have there been other plausible proposals?
Yes I tried to imply a counterproposal in the "2 reasons" in my comment.
This lint is no longer emitted by the compiler. It has been upgraded to hard error. Closing as fixed by #125380.
This is the summary issue for the
WHERE_CLAUSES_OBJECT_SAFETY
future-compatibility warning and other related errors. The goal of this page is describe why this change was made and how you can fix code that is affected by it. It also provides a place to ask questions or register a complaint if you feel the change should not be made. For more information on the policy around future-compatibility warnings, see our [breaking change policy guidelines (https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md).What is the warning for?
As was discovered in #50781 a combination of implementing a trait directly for a
dyn
type and where clauses involvingSelf
can punch a hole in our dyn-capability rules rules. See the minimization:The fix applied in #50966 is to tighten the dyn-capability rules to make
X
not dyn-capable in this case, in general making any trait that containsSelf
in where clauses not dyn-capable, much like we disallowSelf
in arguments or return type. Few root regressions appeared in the crater run and those were fixable, though some crates being unmaintained complicates things.However that fix is heavy handed and disallows things we actually wish to support, still we went ahead with the warning as a stop gap while we look for a better, more targeted fix. The original issue contains some discussion of alternative fixes. With tight chalk integration, we could do some clever things.
Other alternatives discussed for the short-term:
impl Foo for dyn Bar + ..
whether that impl is causing trouble. This seems to be a dead end because it's hard to tell whichdyn
types are targeted by a blanket impl such asimpl<U: ?Sized + Bounds> Trait for U
.dyn Foo: Trait
then to castT
intodyn Foo
we require thatT: Trait
must also hold", probably for everyTrait
such thatSelf: Trait
appears in where clauses in the traits methods. This would alleviate the warning forSelf: Trait
where clauses. This may be practical to implement now, but seems subtle, we'd need to give it more thought.When will this warning become a hard error?
Hopefully we will develop a finer-grained rule and this warning will never be an error.
How to fix this?
Either drop the where clause or stop using
dyn
types with the affected trait. If this is not viable, that's probably ok, it's very unlikely that your code is actually unsound. But please do report your case here so take we may take it into consideration and see how to better support it!