Tweak suggestions for bare trait used as a type #119148

estebank · 2023-12-20T01:05:18Z

error[E0782]: trait objects must include the `dyn` keyword
  --> $DIR/not-on-bare-trait-2021.rs:11:11
   |
LL | fn bar(x: Foo) -> Foo {
   |           ^^^
   |
help: use a generic type parameter, constrained by the trait `Foo`
   |
LL | fn bar<T: Foo>(x: T) -> Foo {
   |       ++++++++    ~
help: you can also use `impl Foo`, but users won't be able to specify the type paramer when calling the `fn`, having to rely exclusively on type inference
   |
LL | fn bar(x: impl Foo) -> Foo {
   |           ++++
help: alternatively, use a trait object to accept any type that implements `Foo`, accessing its methods at runtime using dynamic dispatch
   |
LL | fn bar(x: &dyn Foo) -> Foo {
   |           ++++

error[E0782]: trait objects must include the `dyn` keyword
  --> $DIR/not-on-bare-trait-2021.rs:11:19
   |
LL | fn bar(x: Foo) -> Foo {
   |                   ^^^
   |
help: use `impl Foo` to return an opaque type, as long as you return a single underlying type
   |
LL | fn bar(x: Foo) -> impl Foo {
   |                   ++++
help: alternatively, you can return an owned trait object
   |
LL | fn bar(x: Foo) -> Box<dyn Foo> {
   |                   +++++++    +

Fix #119525:


error[E0038]: the trait `Ord` cannot be made into an object
  --> $DIR/bare-trait-dont-suggest-dyn.rs:3:33
   |
LL | fn ord_prefer_dot(s: String) -> Ord {
   |                                 ^^^ `Ord` cannot be made into an object
   |
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_DIR/core/src/cmp.rs:LL:COL
   |
   = note: the trait cannot be made into an object because it uses `Self` as a type parameter
  ::: $SRC_DIR/core/src/cmp.rs:LL:COL
   |
   = note: the trait cannot be made into an object because it uses `Self` as a type parameter
help: consider using an opaque type instead
   |
LL | fn ord_prefer_dot(s: String) -> impl Ord {
   |                                 ++++

rustbot · 2023-12-20T01:05:27Z

r? @davidtwco

(rustbot has picked a reviewer for you, use r? to override)

tests/ui/traits/bound/not-on-bare-trait.stderr

rustbot · 2023-12-20T19:47:04Z

Some changes occurred in src/tools/clippy

cc @rust-lang/clippy

compiler/rustc_hir_analysis/src/astconv/lint.rs

Add the following suggestions: ``` error[E0782]: trait objects must include the `dyn` keyword --> $DIR/not-on-bare-trait-2021.rs:11:11 | LL | fn bar(x: Foo) -> Foo { | ^^^ | help: use a generic type parameter, constrained by the trait `Foo` | LL | fn bar<T: Foo>(x: T) -> Foo { | ++++++++ ~ help: you can also use `impl Foo`, but users won't be able to specify the type paramer when calling the `fn`, having to rely exclusively on type inference | LL | fn bar(x: impl Foo) -> Foo { | ++++ help: alternatively, use a trait object to accept any type that implements `Foo`, accessing its methods at runtime using dynamic dispatch | LL | fn bar(x: &dyn Foo) -> Foo { | ++++ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/not-on-bare-trait-2021.rs:11:19 | LL | fn bar(x: Foo) -> Foo { | ^^^ | help: use `impl Foo` to return an opaque type, as long as you return a single underlying type | LL | fn bar(x: Foo) -> impl Foo { | ++++ help: alternatively, you can return an owned trait object | LL | fn bar(x: Foo) -> Box<dyn Foo> { | +++++++ + ```

Note the parentheses in the last suggestion: ``` error[E0277]: the size for values of type `(dyn Foo + Send + 'static)` cannot be known at compilation time --> $DIR/not-on-bare-trait.rs:7:8 | LL | fn foo(_x: Foo + Send) { | ^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `(dyn Foo + Send + 'static)` = help: unsized fn params are gated as an unstable feature help: you can use `impl Trait` as the argument type | LL | fn foo(_x: impl Foo + Send) { | ++++ help: function arguments must have a statically known size, borrowed types always have a known size | LL | fn foo(_x: &(Foo + Send)) { | ++ + ```

…tType` This gets us more accurate suggestions.

Fix rust-lang#119525.

davidtwco · 2024-01-05T10:07:56Z

@bors r+

bors · 2024-01-05T10:07:58Z

📌 Commit 698dfc3 has been approved by davidtwco

It is now in the queue for this repository.

…mpiler-errors Rollup of 10 pull requests Successful merges: - rust-lang#119034 (Allow coverage tests to ignore test modes, and to enable color in coverage reports) - rust-lang#119148 (Tweak suggestions for bare trait used as a type) - rust-lang#119538 (Cleanup error handlers: round 5) - rust-lang#119566 (Remove `-Zdump-mir-spanview`) - rust-lang#119567 (Remove `-Zreport-delayed-bugs`.) - rust-lang#119577 (Migrate memory overlap check from validator to lint) - rust-lang#119583 (Make `intrinsics::assume` const stable) - rust-lang#119586 ([rustdoc] Fix invalid handling for static method calls in jump to definition feature) - rust-lang#119588 (Move `i586-unknown-netbsd` from tier 2 to tier 3 platform support table) - rust-lang#119601 (`Emitter` cleanups) r? `@ghost` `@rustbot` modify labels: rollup

Rollup merge of rust-lang#119148 - estebank:bare-traits, r=davidtwco Tweak suggestions for bare trait used as a type ``` error[E0782]: trait objects must include the `dyn` keyword --> $DIR/not-on-bare-trait-2021.rs:11:11 | LL | fn bar(x: Foo) -> Foo { | ^^^ | help: use a generic type parameter, constrained by the trait `Foo` | LL | fn bar<T: Foo>(x: T) -> Foo { | ++++++++ ~ help: you can also use `impl Foo`, but users won't be able to specify the type paramer when calling the `fn`, having to rely exclusively on type inference | LL | fn bar(x: impl Foo) -> Foo { | ++++ help: alternatively, use a trait object to accept any type that implements `Foo`, accessing its methods at runtime using dynamic dispatch | LL | fn bar(x: &dyn Foo) -> Foo { | ++++ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/not-on-bare-trait-2021.rs:11:19 | LL | fn bar(x: Foo) -> Foo { | ^^^ | help: use `impl Foo` to return an opaque type, as long as you return a single underlying type | LL | fn bar(x: Foo) -> impl Foo { | ++++ help: alternatively, you can return an owned trait object | LL | fn bar(x: Foo) -> Box<dyn Foo> { | +++++++ + ``` Fix rust-lang#119525: ``` error[E0038]: the trait `Ord` cannot be made into an object --> $DIR/bare-trait-dont-suggest-dyn.rs:3:33 | LL | fn ord_prefer_dot(s: String) -> Ord { | ^^^ `Ord` cannot be made into an object | 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_DIR/core/src/cmp.rs:LL:COL | = note: the trait cannot be made into an object because it uses `Self` as a type parameter ::: $SRC_DIR/core/src/cmp.rs:LL:COL | = note: the trait cannot be made into an object because it uses `Self` as a type parameter help: consider using an opaque type instead | LL | fn ord_prefer_dot(s: String) -> impl Ord { | ++++ ```

Tweak suggestions for bare trait used as a type ``` error[E0782]: trait objects must include the `dyn` keyword --> $DIR/not-on-bare-trait-2021.rs:11:11 | LL | fn bar(x: Foo) -> Foo { | ^^^ | help: use a generic type parameter, constrained by the trait `Foo` | LL | fn bar<T: Foo>(x: T) -> Foo { | ++++++++ ~ help: you can also use `impl Foo`, but users won't be able to specify the type paramer when calling the `fn`, having to rely exclusively on type inference | LL | fn bar(x: impl Foo) -> Foo { | ++++ help: alternatively, use a trait object to accept any type that implements `Foo`, accessing its methods at runtime using dynamic dispatch | LL | fn bar(x: &dyn Foo) -> Foo { | ++++ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/not-on-bare-trait-2021.rs:11:19 | LL | fn bar(x: Foo) -> Foo { | ^^^ | help: use `impl Foo` to return an opaque type, as long as you return a single underlying type | LL | fn bar(x: Foo) -> impl Foo { | ++++ help: alternatively, you can return an owned trait object | LL | fn bar(x: Foo) -> Box<dyn Foo> { | +++++++ + ``` Fix rust-lang#119525: ``` error[E0038]: the trait `Ord` cannot be made into an object --> $DIR/bare-trait-dont-suggest-dyn.rs:3:33 | LL | fn ord_prefer_dot(s: String) -> Ord { | ^^^ `Ord` cannot be made into an object | 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_DIR/core/src/cmp.rs:LL:COL | = note: the trait cannot be made into an object because it uses `Self` as a type parameter ::: $SRC_DIR/core/src/cmp.rs:LL:COL | = note: the trait cannot be made into an object because it uses `Self` as a type parameter help: consider using an opaque type instead | LL | fn ord_prefer_dot(s: String) -> impl Ord { | ++++ ```

estebank marked this pull request as ready for review December 20, 2023 01:05

rustbot assigned davidtwco Dec 20, 2023

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Dec 20, 2023

estebank commented Dec 20, 2023

View reviewed changes

tests/ui/traits/bound/not-on-bare-trait.stderr Outdated Show resolved Hide resolved

This comment has been minimized.

Sign in to view

estebank force-pushed the bare-traits branch from 9528085 to 5b8bfc1 Compare December 20, 2023 19:47

This comment was marked as resolved.

Sign in to view

estebank force-pushed the bare-traits branch from 5b8bfc1 to 544e871 Compare December 26, 2023 20:24

fmease mentioned this pull request Jan 3, 2024

rustc suggests dyn SomeTrait for traits which aren't object safe #119525

Closed

davidtwco reviewed Jan 3, 2024

View reviewed changes

compiler/rustc_hir_analysis/src/astconv/lint.rs Outdated Show resolved Hide resolved

compiler/rustc_hir_analysis/src/astconv/lint.rs Outdated Show resolved Hide resolved

compiler/rustc_hir_analysis/src/astconv/lint.rs Outdated Show resolved Hide resolved

estebank added 5 commits January 3, 2024 18:59

Track HirId instead of Span in `ObligationCauseCode::SizedArgumen…

79bef72

…tType` This gets us more accurate suggestions.

review comments

771966b

Account for object unsafe traits

78ef946

Fix rust-lang#119525.

estebank force-pushed the bare-traits branch from 544e871 to 78ef946 Compare January 3, 2024 21:00

This comment has been minimized.

Sign in to view

Silence redundant warning when E0038 will be emitted

698dfc3

estebank force-pushed the bare-traits branch from 96836b9 to 698dfc3 Compare January 4, 2024 00:46

davidtwco approved these changes Jan 5, 2024

View reviewed changes

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Jan 5, 2024

compiler-errors mentioned this pull request Jan 5, 2024

Rollup of 10 pull requests #119621

Merged

bors merged commit f41ad1b into rust-lang:master Jan 5, 2024
11 checks passed

rustbot added this to the 1.77.0 milestone Jan 5, 2024

matthiaskrgr mentioned this pull request Jan 5, 2024

ICE: downgrade_to_delayed_bug: cannot downgrade Warning(None) to DelayedBug: not an error #119633

Closed

fmease mentioned this pull request Jan 6, 2024

ice: self.err_count() changed but an error was not emitted #119652

Closed

matthiaskrgr mentioned this pull request Jan 7, 2024

Conflicting trait impls cause ICE with generic_const_exprs #119692

Open

fmease mentioned this pull request Jan 12, 2024

ice: async fn coroutine return type not an inference variable #119890

Closed

matthiaskrgr mentioned this pull request Jan 22, 2024

ICE: E0391 #120241

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Tweak suggestions for bare trait used as a type #119148

Tweak suggestions for bare trait used as a type #119148

estebank commented Dec 20, 2023 •

edited

Loading

rustbot commented Dec 20, 2023

This comment has been minimized.

rustbot commented Dec 20, 2023

This comment was marked as resolved.

This comment has been minimized.

davidtwco commented Jan 5, 2024

bors commented Jan 5, 2024

Tweak suggestions for bare trait used as a type #119148

Tweak suggestions for bare trait used as a type #119148

Conversation

estebank commented Dec 20, 2023 • edited Loading

rustbot commented Dec 20, 2023

This comment has been minimized.

rustbot commented Dec 20, 2023

This comment was marked as resolved.

This comment has been minimized.

davidtwco commented Jan 5, 2024

bors commented Jan 5, 2024

estebank commented Dec 20, 2023 •

edited

Loading