[jdonszelmann]

View all comments

r? @lcnr

As part of #162126, I found some small performance wins resulting from the fact that shallow_resolve now returns root vids.

The last commit also makes it so calls to shallow_resolve need to explicitly handle the possibility of reusing the existing interned value.

Note

I've not used an LLM for any part of this PR, or any other PR I make. This includes any related work like research.

[rustbot]

changes to inspect_obligations.rs

cc @lcnr

changes to the core type system

cc @lcnr

Some changes occurred in need_type_info.rs

cc @lcnr

Some changes occurred to the core trait solver

cc @rust-lang/initiative-trait-system-refactor

changes to the core type system

cc @lcnr

[jdonszelmann]

@bors try @rust-timer queue

[jdonszelmann]

this method (and the one below) now also does the recursive resolving shallow_resolve already did. No tests change here.

View changes since the review

[jdonszelmann]

the non-recursive caase helps ~0.5% on local benchmarks. Not much, but still a bit.

View changes since the review

[jdonszelmann]

By taking an Option here, we can merge more methods' implementations. Doing this has 0 performance overhead, #[inline(always)] makes sure the callsites that always call with Some get optimized properly.

View changes since the review

[lcnr]

could we instead change this function to not take a ty and return and Option instead?

[rust-bors]

💔 Test for 7e8d4ec failed: CI. Failed job:

• try - dist-x86_64-linux-quick (web logs, enhanced plaintext logs)

[jdonszelmann]

@bors try (failed due to missing rustdoc changes now applied)

[rust-bors]

Unknown argument "(failed". Did you mean to use @bors jobs=<jobs>|parent=<parent>? Run @bors help or go to https://bors.rust-lang.org/help to see available commands.

[panstromek]

@bors try

[rust-bors]

☀️ Try build successful (CI)
Build commit: d881e22 (d881e228b79422918a125ef8385170091369309b)
Base parent: a04c7a0 (a04c7a037d59b6dedc9f921e84e391f13a257aa4)

[lcnr]

some nits, unsure about one of them. otherwise r=me

View changes since this review

[lcnr]

still weird formatting

[lcnr]

talked about this in person

@rustbot author

[rustbot]

Reminder, once the PR becomes ready for a review, use @rustbot ready.

[jdonszelmann]

In-person, @lcnr and I discussed that the unresolved function should get a closure, as I made it have in the last version I pushed. Since lcnr is gone, could I ask someone in @rust-lang/initiative-trait-system-refactor to have a quick look and do the final sign off? We went through several rounds of review already, shouldn't take much but I don't want to blindly r=lcnr.

[rustbot]

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

[rust-log-analyzer]

The job test-x86_64-gnu-gcc-core-tests failed! Check out the build log: (web) (plain enhanced) (plain)

Click to see the possible cause of the failure (guessed by this bot)

[RUSTC-TIMING] profiler_builtins test:false 0.041
error[E0282]: type annotations needed
  --> library/core/src/iter/adapters/cloned.rs:30:16
   |
30 |     move |acc, elt| f(acc, elt.clone())
   |                ^^^         --- type must be known at this point
   |
help: consider giving this closure parameter an explicit type
   |
30 |     move |acc, elt: /* Type */| f(acc, elt.clone())
   |                   ++++++++++++

error[E0277]: expected `FnMut(Acc, &T)` signature, found `{closure@library/core/src/iter/adapters/copied.rs:36:5: 36:21}`
  --> library/core/src/iter/adapters/copied.rs:35:65
   |
35 | fn copy_fold<T: Copy, Acc>(mut f: impl FnMut(Acc, T) -> Acc) -> impl FnMut(Acc, &T) -> Acc {
   |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `FnMut(Acc, &T)` signature, found `{closure@library/core/src/iter/adapters/copied.rs:36:5: 36:21}`
   |
help: the trait `for<'a> FnMut(Acc, &'a T)` is not implemented for closure `{closure@library/core/src/iter/adapters/copied.rs:36:5: 36:21}`
  --> library/core/src/iter/adapters/copied.rs:36:5
   |
36 |     move |acc, &elt| f(acc, elt)
   |     ^^^^^^^^^^^^^^^^
   = note: expected type with signature `for<'a> fn(_, &'a _)`
           found closure with signature `fn(_, &_)`

error[E0277]: expected `FnMut(Acc, &T)` signature, found `{closure@library/core/src/iter/adapters/copied.rs:40:5: 40:21}`
  --> library/core/src/iter/adapters/copied.rs:39:70
   |
39 | fn copy_try_fold<T: Copy, Acc, R>(mut f: impl FnMut(Acc, T) -> R) -> impl FnMut(Acc, &T) -> R {
   |                                                                      ^^^^^^^^^^^^^^^^^^^^^^^^ expected `FnMut(Acc, &T)` signature, found `{closure@library/core/src/iter/adapters/copied.rs:40:5: 40:21}`
   |
help: the trait `for<'a> FnMut(Acc, &'a T)` is not implemented for closure `{closure@library/core/src/iter/adapters/copied.rs:40:5: 40:21}`
  --> library/core/src/iter/adapters/copied.rs:40:5
   |
40 |     move |acc, &elt| f(acc, elt)
   |     ^^^^^^^^^^^^^^^^
   = note: expected type with signature `for<'a> fn(_, &'a _)`
           found closure with signature `fn(_, &_)`

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:391:24
    |
391 |             move |acc, iter| fold(acc, iter.into_iter())
    |                        ^^^^            ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
391 |             move |acc, iter: /* Type */| fold(acc, iter.into_iter())
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:423:24
    |
423 |             move |acc, iter| fold(acc, frontiter.insert(iter.into_iter()))
    |                        ^^^^                             ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
423 |             move |acc, iter: /* Type */| fold(acc, frontiter.insert(iter.into_iter()))
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:460:24
    |
460 |             move |acc, iter| fold(acc, iter.into_iter())
    |                        ^^^^            ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
460 |             move |acc, iter: /* Type */| fold(acc, iter.into_iter())
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:492:24
    |
492 |             move |acc, iter| fold(acc, backiter.insert(iter.into_iter()))
    |                        ^^^^                            ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
492 |             move |acc, iter: /* Type */| fold(acc, backiter.insert(iter.into_iter()))
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:566:24
    |
566 |             move |acc, iter| iter.try_fold(acc, &mut fold)
    |                        ^^^^  ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
566 |             move |acc, iter: /* Type */| iter.try_fold(acc, &mut fold)
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:581:24
    |
581 |             move |acc, iter| iter.fold(acc, &mut fold)
    |                        ^^^^  ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
581 |             move |acc, iter: /* Type */| iter.fold(acc, &mut fold)
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:657:24
    |
657 |             move |acc, iter| iter.try_rfold(acc, &mut fold)
    |                        ^^^^  ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
657 |             move |acc, iter: /* Type */| iter.try_rfold(acc, &mut fold)
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:672:24
    |
672 |             move |acc, iter| iter.rfold(acc, &mut fold)
    |                        ^^^^  ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
672 |             move |acc, iter: /* Type */| iter.rfold(acc, &mut fold)
    |                            ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:809:16
    |
809 |     move |acc, inner| match inner.into_iter().next() {
    |                ^^^^^        ----- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
809 |     move |acc, inner: /* Type */| match inner.into_iter().next() {
    |                     ++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:819:16
    |
819 |     move |acc, inner| match inner.into_iter().next() {
    |                ^^^^^        ----- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
819 |     move |acc, inner: /* Type */| match inner.into_iter().next() {
    |                     ++++++++++++

error[E0277]: expected `FnMut(&T)` signature, found `{closure@library/core/src/iter/adapters/skip_while.rs:49:13: 49:21}`
  --> library/core/src/iter/adapters/skip_while.rs:48:14
   |
48 |         ) -> impl FnMut(&T) -> bool + 'a {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `FnMut(&T)` signature, found `{closure@library/core/src/iter/adapters/skip_while.rs:49:13: 49:21}`
   |
help: the trait `for<'a> FnMut(&'a T)` is not implemented for closure `{closure@library/core/src/iter/adapters/skip_while.rs:49:13: 49:21}`
  --> library/core/src/iter/adapters/skip_while.rs:49:13
   |
49 |             move |x| {
   |             ^^^^^^^^
   = note: expected type with signature `for<'a> fn(&'a _)`
           found closure with signature `fn(&_)`

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/take.rs:293:19
    |
293 |             move |more, x| {
    |                   ^^^^
294 |                 action(x);
295 |                 more.checked_sub(1)
    |                 ---- type must be known at this point
    |
help: consider giving this closure parameter an explicit type
    |
293 |             move |more: /* Type */, x| {
    |                       ++++++++++++

error[E0282]: type annotations needed
    --> library/core/src/iter/traits/iterator.rs:2359:19
     |
2359 |             move |x| {
     |                   ^
2360 |                 let p = predicate(&**x);
     |                                     -- type must be known at this point
     |
help: consider giving this closure parameter an explicit type
     |
2359 |             move |x: /* Type */| {
     |                    ++++++++++++

error[E0282]: type annotations needed
    --> library/core/src/iter/traits/iterator.rs:2368:19
     |
2368 |             move |x| predicate(&**x)
     |                   ^              -- type must be known at this point
     |
help: consider giving this closure parameter an explicit type
     |
2368 |             move |x: /* Type */| predicate(&**x)
     |                    ++++++++++++

error[E0282]: type annotations needed
    --> library/core/src/iter/traits/iterator.rs:4233:42
     |
4233 |             Some(y) => f(x, y).map_break(ControlFlow::Break),
     |                                          ^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `C` declared on the enum `ControlFlow`
     |
help: consider specifying the generic arguments
     |
4233 |             Some(y) => f(x, y).map_break(ControlFlow::<T, C>::Break),
     |                                                     ++++++++

error[E0284]: type annotations needed: cannot satisfy `[_; 0]: '_`
   --> library/core/src/io/write.rs:377:59
    |
377 |     let buf = bufs.iter().find(|b| !b.is_empty()).map_or(&[][..], |b| &**b);
    |                                                           ^^^^^^ cannot satisfy `[_; 0]: '_`

error[E0282]: type annotations needed
  --> library/core/src/iter/adapters/array_chunks.rs:64:27
   |
64 |         self.try_for_each(ControlFlow::Break).break_value()
   |                           ^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `C` declared on the enum `ControlFlow`
   |
help: consider specifying the generic arguments
   |
64 |         self.try_for_each(ControlFlow::<[<I as iterator::Iterator>::Item; N], C>::Break).break_value()
   |                                      +++++++++++++++++++++++++++++++++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/array_chunks.rs:116:36
    |
116 |         self.try_rfold((), |(), x| ControlFlow::Break(x)).break_value()
    |                                    ^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `C` declared on the enum `ControlFlow`
    |
help: consider specifying the generic arguments
    |
116 |         self.try_rfold((), |(), x| ControlFlow::<[<I as iterator::Iterator>::Item; N], C>::Break(x)).break_value()
    |                                               +++++++++++++++++++++++++++++++++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/flatten.rs:544:23
    |
544 |                 try { fhi?.checked_add(bhi?)?.checked_add(fixed_size.checked_mul(upper?)?)? };
    |                       ^^^^ cannot infer type

error[E0284]: type annotations needed: cannot satisfy `Buffer<_, N>: '_`
   --> library/core/src/iter/adapters/map_windows.rs:208:9
    |
208 |         buffer.as_uninit_array_mut().write(self.as_array_ref().clone());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot satisfy `Buffer<_, N>: '_`

error[E0282]: type annotations needed
   --> library/core/src/iter/adapters/mod.rs:177:27
    |
177 |         self.try_for_each(ControlFlow::Break).break_value()
    |                           ^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `C` declared on the enum `ControlFlow`
    |
help: consider specifying the generic arguments
    |
177 |         self.try_for_each(ControlFlow::<<<I as iterator::Iterator>::Item as try_trait::Try>::Output, C>::Break).break_value()
    |                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/iter/sources/repeat_n.rs:142:52
    |
142 |             return NonZero::<usize>::new(skip).map(Err).unwrap_or(Ok(()));
    |                                                    ^^^ cannot infer type of the type parameter `T` declared on the enum `Result`
    |
help: consider specifying the generic arguments
    |
142 |             return NonZero::<usize>::new(skip).map(Err::<T, NonZero<usize>>).unwrap_or(Ok(()));
    |                                                       +++++++++++++++++++++

error[E0283]: type annotations needed
    --> library/core/src/iter/traits/accum.rs:237:39
     |
 237 |         iter::try_process(iter, |i| i.sum())
     |                                       ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
     |
     = note: the type must implement `Sum<U>`
     = help: the following types implement trait `Sum<A>`:
               `Duration` implements `Sum<&'a Duration>`
               `Duration` implements `Sum`
               `Option<T>` implements `Sum<Option<U>>`
               `Saturating<u128>` implements `Sum<&'a Saturating<u128>>`
               `Saturating<u128>` implements `Sum`
               `Saturating<u16>` implements `Sum<&'a Saturating<u16>>`
               `Saturating<u16>` implements `Sum`
               `Saturating<u32>` implements `Sum<&'a Saturating<u32>>`
             and 88 others
note: required by a bound in `iterator::Iterator::sum`
    --> library/core/src/iter/traits/iterator.rs:3692:12
     |
  42 | pub const trait Iterator {
...
3689 |     fn sum<S>(self) -> S
...
3692 |         S: [const] Sum<Self::Item>,
     |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Iterator::sum`
help: consider specifying a concrete type for the type parameter `S`
     |
 237 |         iter::try_process(iter, |i| i.sum::</* Type */>())
     |                                          ++++++++++++++

error[E0283]: type annotations needed
    --> library/core/src/iter/traits/accum.rs:267:39
     |
 267 |         iter::try_process(iter, |i| i.product())
     |                                       ^^^^^^^ cannot infer type of the type parameter `P` declared on the method `product`
     |
     = note: the type must implement `Product<U>`
     = help: the following types implement trait `Product<A>`:
               `Option<T>` implements `Product<Option<U>>`
               `Saturating<u128>` implements `Product<&'a Saturating<u128>>`
               `Saturating<u128>` implements `Product`
               `Saturating<u16>` implements `Product<&'a Saturating<u16>>`
               `Saturating<u16>` implements `Product`
               `Saturating<u32>` implements `Product<&'a Saturating<u32>>`
               `Saturating<u32>` implements `Product`
               `Saturating<u64>` implements `Product<&'a Saturating<u64>>`
             and 86 others
note: required by a bound in `iterator::Iterator::product`
    --> library/core/src/iter/traits/iterator.rs:3724:12
     |
  42 | pub const trait Iterator {
...
3721 |     fn product<P>(self) -> P
...
3724 |         P: [const] Product<Self::Item>,
     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Iterator::product`
help: consider specifying a concrete type for the type parameter `P`
     |
 267 |         iter::try_process(iter, |i| i.product::</* Type */>())
     |                                              ++++++++++++++

error[E0283]: type annotations needed
    --> library/core/src/iter/traits/accum.rs:297:39
     |
 297 |         iter::try_process(iter, |i| i.sum())
     |                                       ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
     |
     = note: the type must implement `Sum<U>`
     = help: the following types implement trait `Sum<A>`:
               `Duration` implements `Sum<&'a Duration>`
               `Duration` implements `Sum`
               `Option<T>` implements `Sum<Option<U>>`
               `Saturating<u128>` implements `Sum<&'a Saturating<u128>>`
               `Saturating<u128>` implements `Sum`
               `Saturating<u16>` implements `Sum<&'a Saturating<u16>>`
               `Saturating<u16>` implements `Sum`
               `Saturating<u32>` implements `Sum<&'a Saturating<u32>>`
             and 88 others
note: required by a bound in `iterator::Iterator::sum`
    --> library/core/src/iter/traits/iterator.rs:3692:12
     |
  42 | pub const trait Iterator {
...
3689 |     fn sum<S>(self) -> S
...
3692 |         S: [const] Sum<Self::Item>,
     |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Iterator::sum`
help: consider specifying a concrete type for the type parameter `S`
     |
 297 |         iter::try_process(iter, |i| i.sum::</* Type */>())
     |                                          ++++++++++++++

error[E0283]: type annotations needed
    --> library/core/src/iter/traits/accum.rs:327:39
     |
 327 |         iter::try_process(iter, |i| i.product())
     |                                       ^^^^^^^ cannot infer type of the type parameter `P` declared on the method `product`
     |
     = note: the type must implement `Product<U>`
     = help: the following types implement trait `Product<A>`:
               `Option<T>` implements `Product<Option<U>>`
               `Saturating<u128>` implements `Product<&'a Saturating<u128>>`
               `Saturating<u128>` implements `Product`
               `Saturating<u16>` implements `Product<&'a Saturating<u16>>`
               `Saturating<u16>` implements `Product`
               `Saturating<u32>` implements `Product<&'a Saturating<u32>>`
               `Saturating<u32>` implements `Product`
               `Saturating<u64>` implements `Product<&'a Saturating<u64>>`
             and 86 others
note: required by a bound in `iterator::Iterator::product`
    --> library/core/src/iter/traits/iterator.rs:3724:12
     |
  42 | pub const trait Iterator {
...
3721 |     fn product<P>(self) -> P
...
3724 |         P: [const] Product<Self::Item>,
     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Iterator::product`
help: consider specifying a concrete type for the type parameter `P`
     |
 327 |         iter::try_process(iter, |i| i.product::</* Type */>())
     |                                              ++++++++++++++

error[E0282]: type annotations needed
   --> library/core/src/net/parser.rs:22:55
    |
 17 | / macro_rules! impl_helper {
 18 | |     ($($t:ty)*) => ($(impl ReadNumberHelper for $t {
 19 | |         const ZERO: Self = 0;
 20 | |         #[inline]
 21 | |         fn checked_mul(&self, other: u32) -> Option<Self> {
 22 | |             Self::checked_mul(*self, other.try_into().ok()?)
    | |                                                       ^^ cannot infer type
...   |
 28 | |     })*)
 29 | | }
    | |_- in this expansion of `impl_helper!`
 30 |
 31 |   impl_helper! { u8 u16 u32 }
    |   --------------------------- in this macro invocation
    |
    = note: the type must also implement `marker::Destruct`
note: required by a bound in `result::Result::<T, E>::ok`
   --> library/core/src/result.rs:711:12
    |
574 | impl<T, E> Result<T, E> {
...
709 |     pub const fn ok(self) -> Option<T>
710 |     where
711 |         T: [const] Destruct,
    |            ^^^^^^^^^^^^^^^^ required by this bound in `Result::<T, E>::ok`

error[E0282]: type annotations needed
   --> library/core/src/net/parser.rs:26:55
    |
 17 | / macro_rules! impl_helper {
 18 | |     ($($t:ty)*) => ($(impl ReadNumberHelper for $t {
 19 | |         const ZERO: Self = 0;
 20 | |         #[inline]
...   |
 26 | |             Self::checked_add(*self, other.try_into().ok()?)
    | |                                                       ^^ cannot infer type
 27 | |         }
 28 | |     })*)
 29 | | }
    | |_- in this expansion of `impl_helper!`
 30 |
 31 |   impl_helper! { u8 u16 u32 }
    |   --------------------------- in this macro invocation
    |
    = note: the type must also implement `marker::Destruct`
note: required by a bound in `result::Result::<T, E>::ok`
   --> library/core/src/result.rs:711:12
    |
574 | impl<T, E> Result<T, E> {
...
709 |     pub const fn ok(self) -> Option<T>
710 |     where
711 |         T: [const] Destruct,
    |            ^^^^^^^^^^^^^^^^ required by this bound in `Result::<T, E>::ok`

error[E0283]: type annotations needed
   --> library/core/src/net/parser.rs:160:23
    |
160 |                     p.read_radix_max_digits(10, 3, false)
    |                       ^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the method `read_radix_max_digits`
    |
    = note: the type must implement `ReadNumberHelper`
help: the following types implement trait `ReadNumberHelper`
   --> library/core/src/net/parser.rs:18:23
    |
 17 | / macro_rules! impl_helper {
 18 | |     ($($t:ty)*) => ($(impl ReadNumberHelper for $t {
    | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    | |                       |
    | |                       `u16`
    | |                       `u32`
    | |                       `u8`
 19 | |         const ZERO: Self = 0;
 20 | |         #[inline]
...   |
 28 | |     })*)
 29 | | }
    | |_- in this expansion of `impl_helper!`
 30 |
 31 |   impl_helper! { u8 u16 u32 }
    |   --------------------------- in this macro invocation
    = note: the type must also implement `TryFrom<u32>`
note: required by a bound in `Parser::<'a>::read_radix_max_digits`
   --> library/core/src/net/parser.rs:104:33
    |
 38 | impl<'a> Parser<'a> {
...
104 |     fn read_radix_max_digits<T: ReadNumberHelper + TryFrom<u32>>(
    |                                 ^^^^^^^^^^^^^^^^ required by this bound in `Parser::<'a>::read_radix_max_digits`
note: required by a bound in `Parser::<'a>::read_radix_max_digits`
   --> library/core/src/net/parser.rs:104:52
    |
 38 | impl<'a> Parser<'a> {
...
104 |     fn read_radix_max_digits<T: ReadNumberHelper + TryFrom<u32>>(
    |                                                    ^^^^^^^^^^^^ required by this bound in `Parser::<'a>::read_radix_max_digits`
help: consider specifying a concrete type for the type parameter `T`
    |

Important

For more information how to resolve CI failures of this job, visit this link.

[jdonszelmann]

r? project-trait-system-refactor (lcnr has told me in-person they're not available for review for a while)

[jdonszelmann]

@rustbot review

[jdonszelmann]

@rustbot author