Silence errors in expressions caused by bare traits in paths in 2021 edition #125784

estebank · 2024-05-30T18:42:14Z

Address #51077 in editions>=2021 by treating <Trait> as a <{type error}> instead of <dyn Trait>, silencing subsequent errors. We now emit a single error ("missing dyn").

error[E0782]: trait objects must include the `dyn` keyword
 --> f800.rs:2:15
  |
2 | let x: u32 = <Default>::default();
  |               ^^^^^^^
  |
help: add `dyn` keyword before this trait
  |
2 | let x: u32 = <dyn Default>::default();
  |               +++

instead of 6

error[E0782]: trait objects must include the `dyn` keyword
 --> f800.rs:2:15
  |
2 | let x: u32 = <Default>::default();
  |               ^^^^^^^
  |
help: add `dyn` keyword before this trait
  |
2 | let x: u32 = <dyn Default>::default();
  |               +++

error[E0038]: the trait `Default` cannot be made into an object
 --> f800.rs:2:15
  |
2 | let x: u32 = <Default>::default();
  |               ^^^^^^^ `Default` cannot be made into an object
  |
  = note: the trait cannot be made into an object because it requires `Self: Sized`
  = 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>

error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time
   --> f800.rs:2:15
    |
2   | let x: u32 = <Default>::default();
    |               ^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `dyn Default`
note: required by a bound in `default`
   --> /home/gh-estebank/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/default.rs:104:20
    |
104 | pub trait Default: Sized {
    |                    ^^^^^ required by this bound in `Default::default`
...
136 |     fn default() -> Self;
    |        ------- required by a bound in this associated function

error[E0308]: mismatched types
 --> f800.rs:2:14
  |
2 | let x: u32 = <Default>::default();
  |        ---   ^^^^^^^^^^^^^^^^^^^^ expected `u32`, found `dyn Default`
  |        |
  |        expected due to this
  |
  = note:      expected type `u32`
          found trait object `dyn Default`
  = help: `u32` implements `Default` so you could change the expected type to `Box<dyn Default>`

error[E0038]: the trait `Default` cannot be made into an object
 --> f800.rs:2:14
  |
2 | let x: u32 = <Default>::default();
  |              ^^^^^^^^^^^^^^^^^^^^ `Default` cannot be made into an object
  |
  = note: the trait cannot be made into an object because it requires `Self: Sized`
  = 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>

error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time
 --> f800.rs:2:14
  |
2 | let x: u32 = <Default>::default();
  |              ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `dyn Default`
  = note: the return type of a function must have a statically known size

In all editions, whenever we encounter !Sized E0277 and object safety E0038 errors for the same expression, silence the former:

warning: trait objects without an explicit `dyn` are deprecated
  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19
   |
LL |     let x: u32 = <Default>::default();
   |                   ^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
   = note: `#[warn(bare_trait_objects)]` on by default
help: if this is an object-safe trait, use `dyn`
   |
LL |     let x: u32 = <dyn Default>::default();
   |                   +++

error[E0038]: the trait `Default` cannot be made into an object
  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19
   |
LL |     let x: u32 = <Default>::default();
   |                   ^^^^^^^ `Default` cannot be made into an object
   |
   = note: the trait cannot be made into an object because it requires `Self: Sized`
   = 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>

error[E0308]: mismatched types
  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:18
   |
LL |     let x: u32 = <Default>::default();
   |            ---   ^^^^^^^^^^^^^^^^^^^^ expected `u32`, found `dyn Default`
   |            |
   |            expected due to this
   |
   = note:      expected type `u32`
           found trait object `dyn Default`
   = help: `u32` implements `Default` so you could change the expected type to `Box<dyn Default>`

error[E0038]: the trait `Default` cannot be made into an object
  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:18
   |
LL |     let x: u32 = <Default>::default();
   |                  ^^^^^^^^^^^^^^^^^^^^ `Default` cannot be made into an object
   |
   = note: the trait cannot be made into an object because it requires `Self: Sized`
   = 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>

rustbot · 2024-05-30T18:42:22Z

r? @TaKO8Ki

rustbot has assigned @TaKO8Ki.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

rustbot · 2024-05-30T18:42:23Z

HIR ty lowering was modified

cc @fmease

fmease · 2024-05-30T19:00:38Z

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

+                        tcx.parent_hir_node(hir_ty.hir_id)
+                    {
+                        // `tests/ui/suggestions/issue-116434-2021.rs` and others would otherwise
+                        // fail with no error beign emitted. We restrict the silencing only to


What do you mean by "fail with no error [being] emitted"? In this branch we have guard : ErrorGuaranteed, we should've emitted at least one error?

For some reason (which I don't understand, as it goes against my understanding of how this is meant to work), the stashed error ends up never getting emitted, which of course causes an ICE for an error being constructed but not emitted. This check does side step that.

nnethercote has dug into this a while back and written a nice explainer: #120482 (comment)

fmease

I love the core change (→ {type error}) but I'm not fond of the workaround because it doesn't seem very robust and I bet it doesn't fix all pathological cases without having looked further into it.

Would you be willing to look into fixing the stash/downgrade issue?

fmease · 2024-05-31T01:05:31Z

I wonder if we could just ignore the request to downgrade a stashed diagnostic to a bug inside downgrade_to_delayed_bug?

estebank · 2024-05-31T23:12:54Z

@fmease I see the problem:

delay_as_bug consumes the diagnostic, in the same way that emit does,
downgrade_to_delayed_bug doesn't,
this interacts badly with stashing

I changed the code here in hir analysis so that we either stash or delay as bug, but never both. Removed the unnecessary check and now a few more cases get correctly silenced in the test suite.

We could look to better account for downgraded diagnostics that got stashed and not ICE in that case, but for now I think it is not as bad an idea to be very noisy about that happening. That way we can actually make a determination (if annoyingly), instead of paper over it and miss potential unintended mistakes.

rustbot · 2024-06-03T06:27:30Z

These commits modify the Cargo.lock file. Unintentional changes to Cargo.lock can be introduced when switching branches and rebasing PRs.

If this was unintentional then you should revert the changes before this PR is merged.
Otherwise, you can ignore this comment.

estebank · 2024-06-03T06:29:10Z

If reviewing all commits is too much (which is likely), feel free to review until the 4th commit and the rest can go on their own PR.

fmease · 2024-06-06T15:50:16Z

I guess suggesting <_ as Default>::default() or Default::default() is the next step here? Esp. if the trait in question is not object-safe (without intro'ing cycle errors ofc)?

fmease · 2024-06-06T15:56:51Z

On a second thought, the help message add `dyn` keyword before this trait is way too assertive. I remember we merged a PR of yours which changed such messages if the trait wasn't object-safe which lead to ICEs and cycle errors and thus we had to partially revert it. We then had a PR by sb. else that changed the wording to sth. like add `dyn` keyword before this trait if this trait is object-safe in some places (arguably, we should change it in all places to be less assertive unless we know for sure it's object-safe).

All that too say, while the output on master is horrendously verbose, the output of the current PR might be too terse because it would take the user an additional edit (addition of dyn) to learn that the suggestion wasn't correct after all as Default is not object-safe.

I guess I'm fine that as long as we/you/I do follow-up work and make the suggestion more correct.

fmease

Note to self: I've stopped my review right before commit "Add more HIR tracking information to ObligationCauseCode". I see that you're working on sugg'ing <_ as Default>::default. I've read your comment about splitting this PR. I don't really care as long as the history is self-explanatory.

You might want to update the PR description as well.

Regarding the actual changes I still need to review & re-review things but already have some feedback.

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

tests/ui/dyn-keyword/trait-missing-dyn-in-qualified-path.edition2021.stderr

fmease · 2024-06-06T16:07:07Z

tests/ui/resolve/issue-111312.rs

-    HasNot::has();
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR no function or associated item named `has` found for trait `HasNot`
+    <dyn HasNot>::has();


:/ So does this PR undo the work done by #111588? I'm pretty sure that #111312 was specifically about using HasNot::has. This change is not faithful to the original version.

I'll see if I can do something in E0782 to at the resolve, but I am generally of the position that if an error leads to another error that has the right suggestion, that is reasonable.

Now I check if HasNot is object safe and if the type is part of a qualified path to an associated item that didn't resolve (unresolved assoc item can be because it doesn't exist in the trait or because it exists but an appropriate self ty couldn't be found). If it is, I don't turn it into {type error}, which makes the error about "has not found" still be emitted. But if the trait is not object safe, we still turn it into a {type error} to avoid any further errors. At the same time, I've added more context to the E0782 about object safety so we don't lose any information when emitting only that one.

fmease · 2024-06-06T16:07:59Z

tests/ui/resolve/issue-111727.rs

@@ -3,5 +3,4 @@
 fn main() {
    std::any::Any::create();
    //~^ ERROR trait objects must include the `dyn` keyword


This represents another #111312 / #111588 regression.

fmease · 2024-06-06T16:10:50Z

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

+                        if Some(trait_ref.def_id()) == self.tcx.lang_items().sized_trait() {
+                            if !self.tcx.object_safety_violations(trait_ref.def_id()).is_empty() {


Sized is never object-safe. Why the need to check the object_safe_violations?

Could you maybe add a comment outlining the motivation for delaying the error in these cases for future readers?

This is now completely gone.

fmease · 2024-06-06T16:14:43Z

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

+                                    ) => {
+                                        return err.delay_as_bug();
+                                    }
+                                    (ObligationCauseCode::SizedCallReturnType(did), _) => {


I'd like to note that these checks are like super specific / not really general. Cost in complexity vs. benefit.

fmease · 2024-06-06T16:24:39Z

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

-                                        ObligationCauseCode::WhereClauseInExpr(..),
-                                        ty::Dynamic(..),
-                                    ) => {
+                                if let ObligationCauseCode::SizedCallReturnType(did)


Right, I've just arrived at this commit (the 4th). Noticing you had to make this change less "aggressive" makes me think that this branch is still super fragile. Like I don't know if the delay_as_bug is correct in all perceivable cases

All delay_as_bugs are now gone after the "Fix tidy" commit.

fmease · 2024-06-06T16:30:36Z

compiler/rustc_hir_analysis/src/check/wfcheck.rs

(note to self): I haven't properly reviewed commit "Add more tracking for HIR source well-formedness requirement" yet.

fmease · 2024-06-06T16:33:56Z

tests/ui/dyn-keyword/inferred-type-in-qualified-path-for-with-one-impl.rs

At commit "Add tests for various dyn Trait in path cases" right now. I think we should make sure to remove files that are duplicates of the new tests. For example rg 'cannot call associated function on trait without specifying the corresponding `impl` type' tests -t rust gave me tests/ui/type/issue-101866.rs, tests/ui/suggestions/issue-104328.rs, tests/ui/suggestions/issue-104327.rs. We might want to remove them or move them here. I haven't looked at the contents.

I feel like this specific test doesn't actually fit into dyn-keyword/?

Address rust-lang#51077 in editions>=2021 by treating `<Trait>` as a `<{type error}>` instead of `<dyn Trait>`, silencing subsequent errors. We new emit a single error ("missing `dyn`"). ``` error[E0782]: trait objects must include the `dyn` keyword --> f800.rs:2:15 | 2 | let x: u32 = <Default>::default(); | ^^^^^^^ | help: add `dyn` keyword before this trait | 2 | let x: u32 = <dyn Default>::default(); | +++ ``` instead of 6 ``` error[E0782]: trait objects must include the `dyn` keyword --> f800.rs:2:15 | 2 | let x: u32 = <Default>::default(); | ^^^^^^^ | help: add `dyn` keyword before this trait | 2 | let x: u32 = <dyn Default>::default(); | +++ error[E0038]: the trait `Default` cannot be made into an object --> f800.rs:2:15 | 2 | let x: u32 = <Default>::default(); | ^^^^^^^ `Default` cannot be made into an object | = note: the trait cannot be made into an object because it requires `Self: Sized` = 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> error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time --> f800.rs:2:15 | 2 | let x: u32 = <Default>::default(); | ^^^^^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `dyn Default` note: required by a bound in `default` --> /home/gh-estebank/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/default.rs:104:20 | 104 | pub trait Default: Sized { | ^^^^^ required by this bound in `Default::default` ... 136 | fn default() -> Self; | ------- required by a bound in this associated function error[E0308]: mismatched types --> f800.rs:2:14 | 2 | let x: u32 = <Default>::default(); | --- ^^^^^^^^^^^^^^^^^^^^ expected `u32`, found `dyn Default` | | | expected due to this | = note: expected type `u32` found trait object `dyn Default` = help: `u32` implements `Default` so you could change the expected type to `Box<dyn Default>` error[E0038]: the trait `Default` cannot be made into an object --> f800.rs:2:14 | 2 | let x: u32 = <Default>::default(); | ^^^^^^^^^^^^^^^^^^^^ `Default` cannot be made into an object | = note: the trait cannot be made into an object because it requires `Self: Sized` = 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> error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time --> f800.rs:2:14 | 2 | let x: u32 = <Default>::default(); | ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `dyn Default` = note: the return type of a function must have a statically known size ```

When encountering an unsized E0277 error on a method that returns `Self` silence that error as it a prior unsized error will have been emitted when constructing the value of `Self`. On E0227 unsized error caused on a bare trait associated function with object safety violations, silence it.

…nce more redundant errors Instead of calling `dowgrade_to_delayed_bug` and then stashing a diagnostic, we either stash the diagnostic or we `delay_as_bug` it. Remove unnecessary restriction of silencing of knock down errors on bare trait objects in edition >=2021.

This data will help with extending E0038 object safety errors.

We use the new HIR node tracking for well-formedness obligations to point at the specific trait object in a path/type (`dyn T` instead of a whole `Box<dyn T>`, for example). ``` error[E0038]: the trait `MapLike` cannot be made into an object --> $DIR/file.rs:47:16 | LL | as Box<dyn Trait>; | ^^^^^^^^^ `Trait` cannot be made into an object ``` We also provide a structured suggestion for `<dyn Trait>::assoc`: ``` = help: when writing `<dyn Trait>::function` you are requiring `Trait` be "object safe", which it isn't help: you might have meant to access the associated function of a specific `impl` to avoid requiring "object safety" from `Trait`, either with some explicit type... | LL | </* Type */ as Trait>::function(); | ~~~~~~~~~~~~~ help: ...or rely on inference if the compiler has enough context to identify the desired type on its own... | LL - <dyn Trait>::function(); LL + Trait::function(); | help: ...which is equivalent to | LL | <_ as Trait>::function(); | ~~~~ ```

…often On casts to `dyn Trait` caused by explicit `as` or return type, we point at the type instead of the expression. Silence note with context about the cast when we'd point at the type, which allows automatic deduplication to happen.

…lf`.

estebank · 2024-06-10T18:28:15Z

The last two commits remove the two delay_as_bug so that you can see the diff. After all the other changes, I'm not as married to silencing those errors that are left.

Given `Trait::foo()` in edition 2021 where `Trait` is object safe and `foo` isn't resolved, emit E0782 instead of marking the expression as `{type error}`, as `foo` not being part of `Trait` is more useful information. If `Trait` *isn't* object safe, then the resolve error isn't as useful because E0782 will have more actionable feedback.

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

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

tests/ui/suggestions/issue-116434-2021.stderr

``` error[E0782]: trait objects must include the `dyn` keyword --> $DIR/issue-116434-2021.rs:5:17 | LL | type Clone; | ---------- you might have meant to use this associated type LL | fn foo() -> Clone; | ^^^^^ | help: `Clone` is not object safe, use `impl Clone` to return an opaque type, as long as you return a single underlying type | LL | fn foo() -> impl Clone; | ++++ help: there is an associated type with the same name | LL | fn foo() -> Self::Clone; | ++++++ ```

When encountering `static FOO: Trait = ...`, if `Trait` is object safe, suggest `static FOO: Box<dyn Trait> = ...`.

estebank · 2024-06-11T18:26:49Z

...ric_const_exprs/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.stderr

@@ -62,7 +39,7 @@ help: you might have meant to write a bound here
 LL | ) -> impl Iterator<Item: SubAssign> {
   |                        ~


Pre-existing, I feel that if we wait long enough to fix it, the syntax will be valid in stable 😈

bors · 2024-06-14T05:41:53Z

☔ The latest upstream changes (presumably #126439) made this pull request unmergeable. Please resolve the merge conflicts.

rustbot assigned TaKO8Ki May 30, 2024

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 May 30, 2024

fmease reviewed May 30, 2024

View reviewed changes

fmease changed the title ~~Silence errors in experssions caused by bare traits in paths in 2021 edition~~ Silence errors in expressions caused by bare traits in paths in 2021 edition May 30, 2024

fmease reviewed May 31, 2024

View reviewed changes

fmease assigned fmease and unassigned TaKO8Ki Jun 3, 2024

fmease reviewed Jun 6, 2024

View reviewed changes

This comment was marked as resolved.

Sign in to view

estebank added 12 commits June 9, 2024 00:01

Do not silence some sized errors as they would cause ICEs

f1f9842

Add more tracking for the HIR source of well-formedness requirement

5441f71

Add tests for various dyn Trait in path cases

9a8f343

Add more HIR tracking information to ObligationCauseCode

9ada8bc

This data will help with extending E0038 object safety errors.

Move FnCtxt::get_fn_decl to TyCtxt

e2f2151

Move suggestions out of main error logic

e55ab93

Tweak wording and only suggest dyn Trait if Trait is object safe

c9e8029

estebank added 4 commits June 9, 2024 21:15

Suggest <_ as Default>::default() when given <Default>::default()

adc750f

review comment: guard -> guar

dd7b36f

review comment: unnecessary check for object safety on sized trait

e6d9050

Add explanatory comment

5f22c02

estebank force-pushed the issue-51077 branch from 5d8b31a to 5f22c02 Compare June 9, 2024 21:16

This comment has been minimized.

Sign in to view

estebank added 3 commits June 10, 2024 17:20

Fix tidy

84be44b

Remove conditional delay_as_bug from "missing dyn error"

d8f5b14

Remove delay_as_bug for fn call with unsized Self that return `Se…

8ee6812

…lf`.

This comment was marked as resolved.

Sign in to view

Move tests that no longer ICE

f116d4d

estebank commented Jun 10, 2024

View reviewed changes

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

estebank commented Jun 11, 2024

View reviewed changes

tests/ui/suggestions/issue-116434-2021.stderr Outdated Show resolved Hide resolved

estebank added 2 commits June 11, 2024 16:40

Account for static and const in suggestion

88ccfa4

When encountering `static FOO: Trait = ...`, if `Trait` is object safe, suggest `static FOO: Box<dyn Trait> = ...`.

estebank commented Jun 11, 2024

View reviewed changes

This comment has been minimized.

Sign in to view

estebank added 2 commits June 11, 2024 22:18

Use verbose format for fully-qualified path suggestion

a62bfcd

Fix tidy

7f923f3

This comment was marked as resolved.

Sign in to view

estebank force-pushed the issue-51077 branch from fa382d6 to 7f923f3 Compare June 13, 2024 02:05

		if Some(trait_ref.def_id()) == self.tcx.lang_items().sized_trait() {
		if !self.tcx.object_safety_violations(trait_ref.def_id()).is_empty() {

		@@ -62,7 +39,7 @@ help: you might have meant to write a bound here
		LL \| ) -> impl Iterator<Item: SubAssign> {
		\| ~

Silence errors in expressions caused by bare traits in paths in 2021 edition #125784

Are you sure you want to change the base?

Silence errors in expressions caused by bare traits in paths in 2021 edition #125784

Conversation

estebank commented May 30, 2024 • edited Loading

rustbot commented May 30, 2024

rustbot commented May 30, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fmease left a comment

Choose a reason for hiding this comment

fmease commented May 31, 2024 • edited Loading

estebank commented May 31, 2024

rustbot commented Jun 3, 2024

estebank commented Jun 3, 2024

fmease commented Jun 6, 2024

fmease commented Jun 6, 2024 • edited Loading

fmease left a comment • edited Loading

Choose a reason for hiding this comment

fmease Jun 6, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fmease Jun 6, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

This comment was marked as resolved.

This comment has been minimized.

estebank commented Jun 10, 2024

This comment was marked as resolved.

This comment was marked as resolved.

Choose a reason for hiding this comment

This comment has been minimized.

This comment was marked as resolved.

bors commented Jun 14, 2024

estebank commented May 30, 2024 •

edited

Loading

fmease commented May 31, 2024 •

edited

Loading

fmease commented Jun 6, 2024 •

edited

Loading

fmease left a comment •

edited

Loading

fmease Jun 6, 2024 •

edited

Loading

fmease Jun 6, 2024 •

edited

Loading