nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 23:04:33 +00:00
Code Issues Packages Projects Releases Wiki Activity
227,345 Commits 7 Branches 139 Tags 1.9 GiB
a5561eb4d5
Commit Graph

227345 Commits

This Branch
This Branch
All Branches
Author SHA1 Message Date
Tom Martin
2027e989bc
Remove unreachable and untested suggestion for invalid span enum derive(Default) 2023-06-19 16:22:21 +01:00
Tom Martin
db613750a9
Reformatting 2023-06-19 16:21:33 +01:00
Yacin Tmimi
2c30fa5a82 Adjust enum variant spans to exclude any explicit discriminant 
Fixes 5686

For reference, explicit discriminants were proposed in [RFC-2363].

`ast::Variant` spans extend to include explicit discriminants when they
are present.

Now we'll adjust the span of enum variants to exclude any explicit
discriminant.

[RFC-2363]: https://rust-lang.github.io/rfcs/2363-arbitrary-enum-discriminant.html
 2023-06-19 10:12:19 -05:00
Guillaume Gomez
75e236375a Clean up "doc(hidden)" check 2023-06-19 17:09:13 +02:00
Yacin Tmimi
ac2ebd3a78 Prevent ICE when calling parse_attribute without an attribute 
Fixes 5729

`parse_attribute` will panic if the first token is not a `#`. To prevent
this we return early instead of trying to parse an invalid attribute.
 2023-06-19 09:58:12 -05:00
Michael Goulet
fca56a8d2c s/Clause/ClauseKind 2023-06-19 14:57:42 +00:00
Michael Goulet
2e8af07a8a Don't consider TAIT normalizable to hidden ty if it would result in impossible item bounds 2023-06-19 14:49:56 +00:00
Deadbeef
a463f231f5 remove derive_new dependency 2023-06-19 09:46:37 -05:00
Deadbeef
7d48be355a bump deps to new versions that use syn 2.0 2023-06-19 09:46:37 -05:00
Deadbeef
8d95c269ed update config_proc_macro to use syn 2.0 2023-06-19 09:46:37 -05:00
xxchan
c9ebd6ce26 doc: remove installing from source 
also add "run from source" in contributing.md
 2023-06-19 09:42:40 -05:00
Yacin Tmimi
0441cc21e3 Add release notes for closed PRs with release-notes label 2023-06-19 09:40:46 -05:00
lcnr
0ceb7d5690 update tests 2023-06-19 15:39:55 +02:00
bors
689511047a 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
Maybe Waffle
b967f5c30d Support ast::ExprKind::Become in clippy 2023-06-19 12:54:34 +00:00
Maybe Waffle
0355d41fd8 Implement become expression formatting in rustfmt 2023-06-19 12:54:34 +00:00
Maybe Waffle
d7713feb99 Syntatically accept become expressions 2023-06-19 12:54:34 +00:00
bors
18a6d911ca 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
lcnr
f2975810a5 change binders from tuple structs to named fields 2023-06-19 11:38:07 +02:00
Scott McMurray
c780e55995 Dedup some type checks in the MIR validator 2023-06-19 01:47:03 -07:00
Scott McMurray
3fd8501823 Remove unchecked_add/sub/mul/shl/shr from CTFE/cg_ssa/cg_clif 2023-06-19 01:47:03 -07:00
Scott McMurray
39788e07ba Promote unchecked_add/sub/mul/shl/shr to mir::BinOp 2023-06-19 01:47:03 -07:00
Boxy
3a6ce74c07 move to nested module 2023-06-19 09:08:03 +01:00
Boxy
9af7122b1d create module so that RUSTC_LOG can filter to just proof trees 2023-06-19 09:08:03 +01:00
Boxy
bb743f8635 allow caller to force proof tree generation 2023-06-19 09:08:03 +01:00
Boxy
51090b962f show normalizes-to hack and response instantiation goals 2023-06-19 09:06:16 +01:00
Boxy
e367c04dc6 introduce a separate set of types for finalized proof trees 2023-06-19 09:06:16 +01:00
Boxy
7a3665d016 dont use a trait 2023-06-19 09:01:37 +01:00
Boxy
3587d4ced8 say what kind of cache hit 2023-06-19 09:01:37 +01:00
Boxy
a2050ba12d add -Z flag 2023-06-19 09:01:37 +01:00
Boxy
3009b2c647 initial info dump 2023-06-19 09:01:37 +01:00
bors
3c9e0705ba 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
4004f5a2fb Merge commit 'cd3bf9fe51676b520c546460e6d8919b8c8ff99f' into sync-from-ra 2023-06-19 09:14:04 +03:00
bors
8d1fa473dd Auto merge of #112724 - scottmcm:simpler-unchecked-shifts, r=Mark-Simulacrum 
[libs] Simplify `unchecked_{shl,shr}`

There's no need for the `const_eval_select` dance here.  And while I originally wrote the `.try_into().unwrap_unchecked()` implementation here, it's kinda a mess in MIR -- this new one is substantially simpler, as shown by the old one being above the inlining threshold but the new one being below it in the `mir-opt/inline/unchecked_shifts` tests.

We don't need `u32::checked_shl` doing a dance through both `Result` *and* `Option` 🙃
 2023-06-19 04:48:35 +00:00
Deadbeef
446db517af fix doc 2023-06-19 03:47:27 +00:00
yukang
aba1cf159f fix sort 2023-06-19 11:03:48 +08:00
Michael Goulet
29c74d5619 Don't ICE on bound var in reject_fn_ptr_impls 2023-06-19 02:52:03 +00:00
bors
c911e08514 Auto merge of #112617 - lqd:dump-mir-dataflow, r=tmiasko 
make mir dataflow graphviz dumps opt-in

This should save some MIR traversals and allocations that are not really needed.

Small win but noticeable locally. Let's see what LTO/PGO say.

r? `@ghost`
 2023-06-19 01:17:40 +00:00
Michael Goulet
d43683f2e9 Treat TAIT equation as always ambiguous in coherence 2023-06-18 22:52:30 +00:00
bors
f217411bac Auto merge of #112774 - compiler-errors:rollup-z8oof6r, r=compiler-errors 
Rollup of 6 pull requests

Successful merges:

 - #112537 (Don't record adjustments twice in `note_source_of_type_mismatch_constraint`)
 - #112663 (cleanup azure leftovers)
 - #112668 (Test `x.ps1` in `msvc` CI job)
 - #112710 (Re-use the deref-pattern recursion instead of duplicating the logic)
 - #112753 (Don't try to auto-bless 32-bit `mir-opt` tests on ARM Mac hosts)
 - #112758 (refactor(resolve): delete update_resolution function)

r? `@ghost`
`@rustbot` modify labels: rollup
 2023-06-18 22:30:48 +00:00
Michael Goulet
493b18b653 Continue folding in query normalizer on weak aliases 2023-06-18 20:56:30 +00:00
Michael Goulet
3b059e0fdb
Rollup merge of #112758 - bvanjoi:clean-up-resolve, r=petrochenkov 
refactor(resolve): delete update_resolution function

The `{ resolution.single_imports.remove(); }` code block does not modify the `binding` of this `resolution`. Therefore, the result of `resolution.binding()` before and after `let t = f(self, resolution)` will remain the same, and it will always satisfy the result: `_ if old_binding.is_some() => return t` or `None => return t`.

And then we delete the `update_resolution` function because it only called once.

r? ``@petrochenkov``
 2023-06-18 13:17:08 -07:00
Michael Goulet
d70be67047
Rollup merge of #112753 - Zalathar:no-bless, r=clubby789 
Don't try to auto-bless 32-bit `mir-opt` tests on ARM Mac hosts

#112418 added special support for automatically blessing 32-bit output on 64-bit hosts, for the subset of `mir-opt` tests that are pointer-width-dependent.

This relies on the 64-bit host having some corresponding 32-bit target that can be built “easily”. For most 64-bit hosts this is fine, but ARM Macs don't have a corresponding 32-bit target. (There have never been 32-bit ARM Macs, and ARM Macs don't have the libraries needed for building `i686-apple-darwin`.)

There is an entry for `("i686-apple-darwin", "aarch64-apple-darwin")` in the list of corresponding 32-bit platforms, but this doesn't actually work on ARM Macs. Instead, the bootstrap invocation fails to build the necessary 32-bit target support, and nothing gets tested or blessed.

According to [this Zulip thread](https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/Can't.20bless.20any.20mir-opt.20tests.20on.20aarch64.20Mac/near/367109789), that mapping was only added because the author assumed it would work. But since it doesn't actually work on ARM Macs, the solution is to just remove that mapping.

With the mapping removed, ARM Macs still can't auto-bless 32-bit output (they will see a warning instead), but at least they can now bless the output of `mir-opt` tests that don't care about pointer width.
 2023-06-18 13:17:07 -07:00
Michael Goulet
b598ea101c
Rollup merge of #112710 - oli-obk:const_to_pat_cleanups2, r=cjgillot 
Re-use the deref-pattern recursion instead of duplicating the logic

This essentially just removes code duplication
 2023-06-18 13:17:07 -07:00
Michael Goulet
b0991731d4
Rollup merge of #112668 - Kobzol:ci-msvc-ps1, r=pietroalbini 
Test `x.ps1` in `msvc` CI job

Small adjustment to https://github.com/rust-lang/rust/pull/112633, to resolve [this comment](https://github.com/rust-lang/rust/pull/112633#issuecomment-1592973577).

r? `@pietroalbini`
 2023-06-18 13:17:06 -07:00
Michael Goulet
2a85e02428
Rollup merge of #112663 - klensy:dusk-and-dawn, r=pietroalbini 
cleanup azure leftovers

Continuation of #97756
 2023-06-18 13:17:06 -07:00
Michael Goulet
90e51f110c
Rollup merge of #112537 - compiler-errors:dont-record-adjustments-twice, r=cjgillot 
Don't record adjustments twice in `note_source_of_type_mismatch_constraint`

We call `lookup_method` a few times in `note_source_of_type_mismatch_constraint`, but that function has side-effects to the typeck results. Replace it with a less side-effect-y variant of the function for use in diagnostics.

Specifically the ICE in #112532 happens because we're recording deref adjustments twice for a call receiver, which causes `ExprUseVisitor` to be angry.

Fixes #112532
 2023-06-18 13:17:05 -07:00
bors
2d0aa57684 Auto merge of #112645 - Kobzol:ci-mingw-merge, r=pietroalbini 
CI: merge `mingw` test CI jobs

Same as https://github.com/rust-lang/rust/pull/112633, but for `mingw`. From the logs it looks like the runner spends 40 minutes compiling `rustc`, and then `10`/`20` minutes running tests. It seems wasteful to split that into two jobs.

CI run: https://github.com/rust-lang/rust/actions/runs/5275702134/jobs/9541479343?pr=112645

r? `@jyn514`
 2023-06-18 19:49:26 +00:00
bors
939786223f Auto merge of #112636 - clubby789:no-capture-array-ref, r=cjgillot 
Don't capture `&[T; N]` when contents isn't read

Fixes the check in #111831
Fixes #112607, although I decided to test the root cause rather than including the example in the issue as a test.
cc `@BoxyUwU`
 2023-06-18 15:48:08 +00:00
Tom Martin
c07b50a213
Fix tidy 2023-06-18 14:16:37 +01:00