Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2025-01-11 12:48:47 +00:00
Code Issues Projects Releases Packages Wiki Activity
26081 commits 3 branches 274 tags 200 MiB
Commit graph

26081 commits

This branch
This branch
All branches
Author SHA1 Message Date
bors
63e56f0d99 Auto merge of #2938 - RalfJung:rustup, r=RalfJung 
Rustup
 2023-06-22 08:41:16 +00:00
Ralf Jung
36e88fb735 Merge from rustc 2023-06-22 10:39:19 +02:00
bors
e1492b1230 Auto merge of #106450 - albertlarsan68:fix-arc-ptr-eq, r=Amanieu 
Make `{Arc,Rc,Weak}::ptr_eq` ignore pointer metadata

FCP completed in https://github.com/rust-lang/rust/issues/103763#issuecomment-1362267967

Closes #103763
 2023-06-21 05:13:39 +00:00
bors
c72a5ce8e4 Auto merge of #2520 - saethlin:mmap-shim, r=RalfJung 
mmap/munmap/mremamp shims

This adds basic support for `mmap`/`mremap`/`munmap`, with the specific goal of testing allocators targeting Linux under Miri.

This supports `mmap` with `MAP_PRIVATE|MAP_ANONYMOUS`, and `PROT_READ|PROT_WRITE`, and explicitly does not support `MAP_SHARED` (because that's asking for MMIO) as well as any kind of file mapping (because it seems like nobody does `MAP_PRIVATE` on files even though that would be very sensible). And (officially) we don't support `MAP_FIXED`, so we always ignore the `addr` argument.

This supports `mremap` only when the implementation is allowed to move the mapping (so no `MREMAP_FIXED`, no `MREMAP_DONTUNMAP`, and required `MREMAP_MAYMOVE`), and also when the entirety of a region previously mapped by `mmap` is being remapped.

This supports `munmap` but only when the entirety of a region previously mapped by `mmap` is unmapped.
 2023-06-20 14:18:46 +00:00
bors
b4c7f2f5df Auto merge of #112320 - compiler-errors:do-not-impl-via-obj, r=lcnr 
Add `implement_via_object` to `rustc_deny_explicit_impl` to control object candidate assembly

Some built-in traits are special, since they are used to prove facts about the program that are important for later phases of compilation such as codegen and CTFE. For example, the `Unsize` trait is used to assert to the compiler that we are able to unsize a type into another type. It doesn't have any methods because it doesn't actually *instruct* the compiler how to do this unsizing, but this is later used (alongside an exhaustive match of combinations of unsizeable types) during codegen to generate unsize coercion code.

Due to this, these built-in traits are incompatible with the type erasure provided by object types. For example, the existence of `dyn Unsize<T>` does not mean that the compiler is able to unsize `Box<dyn Unsize<T>>` into `Box<T>`, since `Unsize` is a *witness* to the fact that a type can be unsized, and it doesn't actually encode that unsizing operation in its vtable as mentioned above.

The old trait solver gets around this fact by having complex control flow that never considers object bounds for certain built-in traits:
2f896da247/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs (L61-L132)

However, candidate assembly in the new solver is much more lovely, and I'd hate to add this list of opt-out cases into the new solver. Instead of maintaining this complex and hard-coded control flow, instead we can make this a property of the trait via a built-in attribute. We already have such a build attribute that's applied to every single trait that we care about: `rustc_deny_explicit_impl`. This PR adds `implement_via_object` as a meta-item to that attribute that allows us to opt a trait out of object-bound candidate assembly as well.

r? `@lcnr`
 2023-06-20 08:42:37 +00:00
bors
a6bdc607bc Auto merge of #112238 - scottmcm:mir-add-unchecked, r=cjgillot 
Promote unchecked integer math to MIR `BinOp`s

So slice indexing by a range gets down to one basic block, for example.

r? cjgillot
 2023-06-19 17:14:21 +00:00
bors
5772cb013f Auto merge of #112366 - lukas-code:test, r=Nilstrieb 
`#[test]` function signature verification improvements

This PR contains two improvements to the expansion of the `#[test]` macro.

The first one fixes https://github.com/rust-lang/rust/issues/112360 by correctly recovering item statements if the signature verification fails.

The second one forbids non-lifetime generics on `#[test]` functions. These were previously allowed if the function returned `()`, but always caused an inference error:

before:
```text
error[E0282]: type annotations needed
 --> src/lib.rs:2:1
  |
1 | #[test]
  | ------- in this procedural macro expansion
2 | fn foo<T>() {}
  | ^^^^^^^^^^^^^^ cannot infer type
```

after:
```text
error: functions used as tests can not have any non-lifetime generic parameters
 --> src/lib.rs:2:1
  |
2 | fn foo<T>() {}
  | ^^^^^^^^^^^^^^
```

Also includes some basic tests for test function signature verification, because I couldn't find any (???) in the test suite.
 2023-06-19 13:39:46 +00:00
bors
a6827c9ad0 Auto merge of #112351 - BoxyUwU:proof_tree_generation, r=lcnr 
new solver proof tree generation

Adds a new `-Z` flag `-Zdump-solver-proof-tree` which causes us to generate proof trees for each call to `infcx.evaluate_root_goal`. Currently these just get `debug!`'d out rather than put in a file.

Callers of `infcx.evaluate_root_goal` get the proof tree returned to them and can force one to be generated by passing in `GenerateProofTree::Yes`. Currently we do not disable the global cache or do anything about the provisional cache when generating proof trees is enabled, this is optimal for debugging but not so much for diagnostics.

Personally I think the exact formatting of proof trees here is not ideal but it's easy to change after this PR lands and would like to avoid bikeshedding the exact way we output this before we even have any of the logic merged to get all the information out of the solver.

This PR is best reviewed with whitespace changes hidden, there is also probably no point going commit by commit

r? `@lcnr`

Below is the proof tree output for the `AliasRelate(TAIT, sub, Alias)` case in rust-lang/trait-system-refactor-initiative#25 from the following command:
``RUSTC_LOG="rustc_trait_selection::solve::inspect::dump=debug" RUSTFLAGS="-Ztrait-solver=next -Zverbose -Zdump-solver-proof-tree" cargo +stage1 check``

<details><summary><strong>Proof tree</strong></summary>
<p>

```

DEBUG rustc_trait_selection::solve::inspect::dump tree=GOAL: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), [])), Subtype, Term::Ty(<?8t as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), [])), Subtype, Term::Ty(<^1_0 as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
    INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), [])), Subtype, Term::Ty(<?0t as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }
        CANDIDATE normalizes-to: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
            TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
            REVISION 0
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                    INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(<?0t as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }
                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                        REVISION 0
                            GOAL: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<^1_0 as std::iter::IntoIterator>::IntoIter as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                    NORMALIZING SELF TY FOR ASSEMBLY:
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                    REVISION 0
                                            RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                    CANDIDATE constituent tys: Err(NoSolution)
                                    CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                        REVISION 0
                            RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                            GOAL: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::iter::Iterator>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<^1_0 as std::iter::IntoIterator>::IntoIter as std::iter::Iterator>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::iter::Iterator>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                    NORMALIZING SELF TY FOR ASSEMBLY:
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                    CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                        REVISION 0
                            RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<^1_0 as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                    REVISION 0
                                        NORMALIZES-TO HACK GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<^1_0 as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, <^0 as std::iter::IntoIterator>::Item] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                                NORMALIZING SELF TY FOR ASSEMBLY:
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, <^0 as std::iter::IntoIterator>::Item] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                    REVISION 0
                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, <^0 as std::iter::IntoIterator>::Item] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        GOAL: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                                CANDIDATE normalizes-to: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                                REVISION 0
                                                                    GOAL: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::Item as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                                    CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<^1_0 as std::iter::IntoIterator>::Item as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                                    REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                        INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::Item as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                                                            NORMALIZING SELF TY FOR ASSEMBLY:
                                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                                                REVISION 0
                                                                                    GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                                                    CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                                                    REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                                        INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                                                                            TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                                                            REVISION 0
                                                                                    RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                                                REVISION 0
                                                                                    GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                                                    CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                                                    GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                            CANDIDATE constituent tys: Err(NoSolution)
                                                                            CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                                                REVISION 0
                                                                    RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                    GOAL: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::Item as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                                    CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<^1_0 as std::iter::IntoIterator>::Item as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                                    GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    REVISION 1
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                CANDIDATE normalizes-to: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                                REVISION 0
                                                                    NORMALIZES-TO HACK GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                                    CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                                    REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                                        INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }
                                                                            TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                                            REVISION 0
                                                                    RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                CANDIDATE substs relate: Err(NoSolution)
                                                CANDIDATE bidir normalizes-to: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                                REVISION 0
                                                                    NORMALIZES-TO HACK GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                                    CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                                    GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    REVISION 1
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7203 ~ core[b962]::iter::traits::collect::IntoIterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                    REVISION 1
                                        NORMALIZES-TO HACK GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<^1_0 as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, <^0 as std::iter::IntoIterator>::Item] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                                NORMALIZING SELF TY FOR ASSEMBLY:
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                            INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                                                TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                                REVISION 0
                                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                                    REVISION 0
                                                        GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, <^0 as std::iter::IntoIterator>::Item] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                                    TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                                    REVISION 0
                                        RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, <^0 as std::iter::IntoIterator>::Item] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        GOAL: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        GOAL: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<?0t as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                        CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(AliasRelate(Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), [])), Equate, Term::Ty(<^1_0 as std::iter::IntoIterator>::Item)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                        GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                            RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                        REVISION 1
                            GOAL: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<^1_0 as std::iter::IntoIterator>::IntoIter as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::marker::Sized>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                    NORMALIZING SELF TY FOR ASSEMBLY:
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                    CANDIDATE constituent tys: Err(NoSolution)
                                    CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                        REVISION 0
                            RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                            GOAL: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::iter::Iterator>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<^1_0 as std::iter::IntoIterator>::IntoIter as std::iter::Iterator>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(TraitPredicate(<<?0t as std::iter::IntoIterator>::IntoIter as std::iter::Iterator>, polarity:Positive), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                                    NORMALIZING SELF TY FOR ASSEMBLY:
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                                        REVISION 0
                                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                    CANDIDATE assumption: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                                        TRY_EVALUATE_ADDED_GOALS: Ok(Yes)
                                        REVISION 0
                            RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                            GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<?0t as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [<^1_0 as std::iter::IntoIterator>::IntoIter], def_id: DefId(2:7319 ~ core[b962]::iter::traits::iterator::Iterator::Item) }, Term::Ty(Opaque(DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
            REVISION 1
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
        CANDIDATE normalizes-to: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
            TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
            REVISION 0
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                    INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }
                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                        REVISION 0
                            NORMALIZES-TO HACK GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
        CANDIDATE substs relate: Err(NoSolution)
        CANDIDATE bidir normalizes-to: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
            TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
            REVISION 0
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                REVISION 0: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                    INSTANTIATED: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <?0t as std::iter::IntoIterator>::Item)] }, PrivateZst)) }
                        TRY_EVALUATE_ADDED_GOALS: Ok(Maybe(Ambiguity))
                        REVISION 0
                            NORMALIZES-TO HACK GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                            CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(^1_1)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] }
                            GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0, ^1] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }, CanonicalVarInfo { kind: Ty(General(U0)) }] })
                RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
            REVISION 1
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(?1t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [], def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}) }, Term::Ty(<^1_0 as std::iter::IntoIterator>::IntoIter)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
                GOAL: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [?0t], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(?2t)), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }
                CANONICALIZED: Canonical { value: QueryInput { goal: Goal { predicate: Binder(ProjectionPredicate(AliasTy { substs: [^1_0], def_id: DefId(2:7204 ~ core[b962]::iter::traits::collect::IntoIterator::IntoIter) }, Term::Ty(Opaque(DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), []))), []), param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst } }, anchor: Bind(DefId(0:6 ~ playground_proof_tree[b494]::a)), predefined_opaques_in_body: PredefinedOpaques(Interned(PredefinedOpaquesData { opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] }
                GLOBAL CACHE HIT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })
RESULT: Ok(Canonical { value: Response { certainty: Maybe(Ambiguity), var_values: CanonicalVarValues { var_values: [^0] }, external_constraints: ExternalConstraints(Interned(ExternalConstraintsData { region_constraints: QueryRegionConstraints { outlives: [], member_constraints: [] }, opaque_types: [(OpaqueTypeKey { def_id: DefId(0:8 ~ playground_proof_tree[b494]::Tait::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::IntoIter), (OpaqueTypeKey { def_id: DefId(0:9 ~ playground_proof_tree[b494]::Tait::{opaque#0}::{opaque#0}), substs: [] }, <^0 as std::iter::IntoIterator>::Item)] }, PrivateZst)) }, max_universe: U0, variables: [CanonicalVarInfo { kind: Ty(General(U0)) }] })

```

</p>
</details>
 2023-06-19 10:38:04 +00:00
bors
2713a1be1c Auto merge of #112784 - lnicola:sync-from-ra, r=lnicola 
⬆️ rust-analyzer

r? `@ghost`
 2023-06-19 07:31:30 +00:00
Laurențiu Nicola
004bdf9494 Merge commit 'cd3bf9fe51676b520c546460e6d8919b8c8ff99f' into sync-from-ra 2023-06-19 09:14:04 +03:00
bors
cd3bf9fe51 Auto merge of #15076 - Veykril:bindings, r=Veykril 
internal: Shrink size of hir::Binding
 2023-06-18 10:19:27 +00:00
Lukas Wirth
c3186202a2 Shrink size of hir::Binding 2023-06-18 12:03:04 +02:00
bors
5dccf3010b Auto merge of #15075 - Veykril:bindings, r=Veykril 
fix: Add binding definition for for-expr iterator desugared binding
 2023-06-18 09:45:49 +00:00
Lukas Wirth
83d7724629 fix: Add binding definition for for-expr iterator desugared binding 2023-06-18 11:44:01 +02:00
bors
a1b536ec6f Auto merge of #15054 - ponyii:fix/implement-missing-members-do-not-transform-const-params, r=lowr 
fix: implement missing members doesn't transform const params and default types

Fixes https://github.com/rust-lang/rust-analyzer/issues/13363
 2023-06-18 09:30:13 +00:00
bors
fcfc6afe05 Auto merge of #15069 - Veykril:analysis-stat-stuff, r=Veykril 
analysis-stats: Add body lowering step, track time of each step separtely
 2023-06-17 08:58:10 +00:00
Lukas Wirth
b5e0452c71 Lazy progress reporting 2023-06-17 10:34:44 +02:00
Lukas Wirth
64a8887a94 Add body lowering step, track time of each step separtely 2023-06-17 09:55:48 +02:00
bors
fdba1b6a5c Auto merge of #15066 - Veykril:analysis-stats, r=Veykril 
internal: Analyze all bodies in analysis-stats, not just functions
 2023-06-17 07:09:50 +00:00
bors
a5a71c75e6 Auto merge of #15067 - Veykril:loop-turn-msgh, r=Veykril 
internal: Add more context to overly long loop turn message
 2023-06-16 17:31:37 +00:00
Lukas Wirth
bd762e62df internal: Add more context to overly long loop turn message 2023-06-16 19:31:07 +02:00
Lukas Wirth
76acf3b992 internal: Analyze all bodies in analysis-stats, not just functions 2023-06-16 19:14:46 +02:00
bors
4143890316 Auto merge of #15065 - Veykril:remove-alloc, r=Veykril 
internal: Do not allocate unnecessarily when importing macros from parent modules
 2023-06-16 16:42:01 +00:00
Lukas Wirth
bd093d1ccd Sort methods in generate_delegate_methods listing 2023-06-16 18:41:25 +02:00
Lukas Wirth
3484b5a116 internal: Do not allocate unnecessarily when importing macros from parent modules 2023-06-16 18:41:06 +02:00
ponyii
7e08933a26 the "implement missing members" assist's const transformation patched 2023-06-16 20:34:44 +04:00
bors
d029f9c863 Auto merge of #110688 - GuillaumeGomez:result-search-type, r=notriddle,jsha 
rustdoc: Add search result item types after their name

Here what it looks like:

![Screenshot from 2023-04-22 15-16-58](https://user-images.githubusercontent.com/3050060/233789566-b5f3f625-3b78-4c56-a7ee-0a4f2d62e667.png)

The idea is to improve accessibility by providing this information directly in the text and not only in the text color. Currently we already use it for doc aliases and for primitive types, so I extended it to all types.

r? `@notriddle`
 2023-06-16 15:02:22 +00:00
bors
0cad484a94 Auto merge of #14693 - HKalbasi:pointee-trait, r=HKalbasi 
Support `Pointee` trait

fix #13992
 2023-06-16 14:34:11 +00:00
hkalbasi
527dfede48 Support Pointee trait 2023-06-16 16:43:43 +03:30
bors
689f964f5f Auto merge of #15062 - AlPha5130:master, r=lnicola 
doc: remove duplicated words
 2023-06-16 10:27:46 +00:00
MysticNebula70
8cc55bfee6 doc: remove duplicated words 2023-06-16 18:22:43 +08:00
ponyii
8a3c21442e refactoring 2023-06-15 17:56:08 +04:00
bors
2363fa087d Auto merge of #2661 - DrMeepster:deref_operand_as, r=oli-obk 
Dereference pointers in shims as correct types

Currently, shims will dereference pointers as the type written by the user. This can cause false positives, incorrect behavior such as #2136, and even ICEs if a field is not present.

This PR fixes this by having shims dereference pointers with types from `std` or `libc` that we can rely on the layout and field names of instead of with whatever the user passed in.

Fixes #1123
 2023-06-15 10:00:38 +00:00
bors
ff864fbb9f Auto merge of #15058 - HKalbasi:more-log, r=HKalbasi 
Add more log in "terminator is none" assert

cc #15029
 2023-06-15 08:36:08 +00:00
hkalbasi
922be8714d Add more log in "terminator is none" assert 2023-06-15 12:05:15 +03:30
bors
9c967d3809 Auto merge of #15053 - Veykril:crate-root-module-id, r=Veykril 
internal: Add a CrateRootModuleId that encodes a module id that is always a crate root
 2023-06-14 14:41:06 +00:00
Lukas Wirth
cf178cba8f internal: Add a CrateRootModuleId that encodes a module id that is always a crate root 2023-06-14 15:41:06 +02:00
ponyii
b07490ffe9 made the add_missing_impl_members and add_missing_default_members assists transform default generic types 2023-06-14 17:37:34 +04:00
bors
51939db8d3 Auto merge of #15052 - lnicola:fmt-arguments, r=Veykril 
minor: Rename minicore ArgumentV1 to match libcore
 2023-06-14 12:13:58 +00:00
bors
82201f2c06 Auto merge of #110662 - bryangarza:safe-transmute-reference-types, r=compiler-errors 
Safe Transmute: Enable handling references

This patch enables support for references in Safe Transmute, by generating nested obligations during trait selection. Specifically, when we call `confirm_transmutability_candidate(...)`, we now recursively traverse the `rustc_transmute::Answer` tree and create obligations for all the `Answer` variants, some of which include multiple nested `Answer`s.
 2023-06-14 08:26:22 +00:00
Laurențiu Nicola
6d6354e5b5 Rename minicore ArgumentV1 to match libcore 2023-06-14 07:33:37 +03:00
bors
c2bbfcb986 Auto merge of #112062 - lukas-code:unsized-layout, r=wesleywiser 
Make struct layout not depend on unsizeable tail

fixes (after backport) https://github.com/rust-lang/rust/issues/112048

Since unsizing `Ptr<Foo<T>>` -> `Ptr<Foo<U>` just copies the pointer and adds the metadata, the layout of `Foo` must not depend on niches in and alignment of the tail `T`.

Nominating for beta 1.71, because it will have this issue: `@rustbot` label beta-nominated
 2023-06-13 22:34:59 +00:00
bors
bfb3f185d7 Auto merge of #112314 - ferrocene:pa-core-alloc-abort, r=bjorn3 
Ignore `core`, `alloc` and `test` tests that require unwinding on `-C panic=abort`

Some of the tests for `core` and `alloc` require unwinding through their use of `catch_unwind`. These tests fail when testing using `-C panic=abort` (in my case through a target without unwinding support, and `-Z panic-abort-tests`), while they should be ignored as they don't indicate a failure.

This PR marks all of these tests with this attribute:

```rust
#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
```

I'm not aware of a way to test this on rust-lang/rust's CI, as we don't test any target with `-C panic=abort`, but I tested this locally on a Ferrocene target and it does indeed make the test suite pass.
 2023-06-13 19:03:27 +00:00
bors
6080b9c796 Auto merge of #112017 - Nemo157:unsafe-block-rustfix, r=eholk 
Add MVP suggestion for `unsafe_op_in_unsafe_fn`

Rebase of https://github.com/rust-lang/rust/pull/99827

cc tracking issue https://github.com/rust-lang/rust/issues/71668

No real changes since the original PR, just migrated the new suggestion to use fluent messages and added a couple more testcases, AFAICT from the discussion there were no outstanding changes requested.
 2023-06-13 15:57:59 +00:00
bors
f8dec25bd7 Auto merge of #15047 - Veykril:crate-graph-root-deps, r=Veykril 
internal: Record file dependencies in crate graph construction

Should fix the bug mentioned in https://github.com/rust-lang/rust-analyzer/issues/8623 where removing a crate root file will panic. I'm not too happy with the way this is done here but I can't think of a better way right now.
 2023-06-13 10:56:51 +00:00
Lukas Wirth
b322805918 internal: Record file dependencies in crate graph construction 2023-06-13 12:29:24 +02:00
bors
25f1c728b4 Auto merge of #15044 - lowr:fix/deduplicate-compl-fields, r=lnicola 
Deduplicate tuple indices for completion

Follow-up to #15026

A tuple struct may dereference to a primitive tuple (though unusual, which is why I previously overlooked this case). We should not show the same tuple index in completion in such cases.

Deduplication of indices among multiple tuple structs is already handled in the previous PR.
 2023-06-13 09:20:41 +00:00
Ryo Yoshida
d01283b1f7
Deduplicate tuple indices for completion 2023-06-13 18:01:54 +09:00
bors
07bc6cbcad Auto merge of #15040 - lnicola:hash-state-name, r=Veykril 
fix: Use a more obscure hasher name in derive expansion

Closes #15039
 2023-06-13 06:13:35 +00:00
Laurențiu Nicola
0b441ca6a5 Use a more obscure hasher name in derive expansion 2023-06-13 08:50:27 +03:00