From abdc57d028e4af6f433eb1023c4a25122d27f934 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 09:09:18 +0900 Subject: [PATCH 01/10] jit: name a virtualizable config whose array lengths were never patched in MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `to_optimizer_config` builds `VirtualizableConfig` with `array_lengths: vec![]` and relies on its caller to fill them in: `MetaInterp::current_virtualizable_optimizer_config` assigns `ctx.virtualizable_array_lengths()` one line later, beside the identical patch of `vable_input_offset`. That sibling field documents the convention on itself; `array_lengths` did not. A length is not a property of the shape — upstream reads `len(lst)` off the live object in every `virtualizable.py` accessor and stores it nowhere. `VirtualizableTracker::init` zips `array_field_offsets` with `array_lengths`, so a config that declares an array field and carries no length runs that loop zero times, leaves `state.arrays` empty, and turns every later `tracked_array_element` into a miss that reads as "this trace had no array elements". The `debug_assert!` names that state instead of absorbing it. Both escapes in the assertion are load-bearing: the state-field macro JIT sets `track_array_elements = false` and carries its elements through the live `virtualizable_boxes` shadow, and a virtualizable with no array field has nothing to seed. `array_tracking_config_without_lengths_is_named_not_absorbed` has to build the state by hand, which is itself the statement that no production path produces it: both writers of `TraceCtx::virtualizable_boxes` set the lengths in the same statement, `state.rs seed_virtualizable_boxes` passes `vec![array_len]` on the portal and bridge paths, and `optimizer_vable_config_matches_registered_virtualizable_when_boxes_active` already pins the patched result. Assisted-by: Claude --- .../src/optimizeopt/virtualize.rs | 73 +++++++++++++++++++ majit/majit-metainterp/src/virtualizable.rs | 11 +++ 2 files changed, 84 insertions(+) diff --git a/majit/majit-metainterp/src/optimizeopt/virtualize.rs b/majit/majit-metainterp/src/optimizeopt/virtualize.rs index 557ac86db9d..b9a6dcd790e 100644 --- a/majit/majit-metainterp/src/optimizeopt/virtualize.rs +++ b/majit/majit-metainterp/src/optimizeopt/virtualize.rs @@ -314,6 +314,20 @@ impl VirtualizableTracker { // at the loop boundary. Skip the per-element loop in that mode; the // empty `PtrInfo::Virtualizable` installed below still keeps the // identity base from being forced. + // The zip below is silent about a config that declares array + // fields but carries no lengths: it runs zero times, leaves + // `state.arrays` empty, and every later `tracked_array_element` + // misses. `to_optimizer_config` builds exactly that state and + // relies on its caller to patch the lengths in, so name the + // unpatched config here rather than letting it read as "this + // trace had no array elements". + debug_assert!( + !self.config.track_array_elements + || self.config.array_field_offsets.is_empty() + || !self.config.array_lengths.is_empty(), + "array-tracking config reached the optimizer with unseeded array_lengths; \ + see MetaInterp::current_virtualizable_optimizer_config", + ); if self.config.track_array_elements { for (array_idx, (&_offset, &length)) in self .config @@ -3730,6 +3744,65 @@ mod tests { assert!(matches!(result, OptimizationResult::PassOn)); } + /// A config that declares an array field but no length is the state + /// `to_optimizer_config` hands out before its caller patches the lengths + /// in. It has to be built by hand — no production path produces it, + /// because both writers of `TraceCtx::virtualizable_boxes` set the + /// lengths in the same statement — and the seeding loop would otherwise + /// absorb it silently, leaving every `tracked_array_element` a miss that + /// reads as "this trace had no array elements". + #[test] + #[should_panic(expected = "unseeded array_lengths")] + fn array_tracking_config_without_lengths_is_named_not_absorbed() { + let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); + let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { + static_field_offsets: vec![], + static_field_types: vec![], + static_field_descrs: vec![], + array_field_offsets: vec![48], + array_item_types: vec![Type::Ref], + array_field_descrs: vec![], + array_lengths: vec![], + vable_input_offset: 0, + identity_input_index: Some(0), + track_array_elements: true, + }); + pass.setup(); + if let Some(ref mut vt) = pass.vable { + vt.ensure_setup(&mut ctx); + } + } + + /// The same shape with `track_array_elements` off is the state-field + /// macro JIT's, which carries elements through the live + /// `virtualizable_boxes` shadow instead; and a config with no array field + /// at all has nothing to seed. Neither is the unpatched config, so + /// neither may trip the assertion above. + #[test] + fn a_shadow_carried_or_arrayless_config_without_lengths_is_accepted() { + for (array_field_offsets, array_item_types, track_array_elements) in + [(vec![48], vec![Type::Ref], false), (vec![], vec![], true)] + { + let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); + let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { + static_field_offsets: vec![], + static_field_types: vec![], + static_field_descrs: vec![], + array_field_offsets, + array_item_types, + array_field_descrs: vec![], + array_lengths: vec![], + vable_input_offset: 0, + identity_input_index: Some(0), + track_array_elements, + }); + pass.setup(); + if let Some(ref mut vt) = pass.vable { + vt.ensure_setup(&mut ctx); + } + } + } + #[test] fn test_standard_virtualizable_init_uses_parent_backed_field_descrs() { let mut info = crate::virtualizable::VirtualizableInfo::new(0); diff --git a/majit/majit-metainterp/src/virtualizable.rs b/majit/majit-metainterp/src/virtualizable.rs index 862c9363c69..352478b8292 100644 --- a/majit/majit-metainterp/src/virtualizable.rs +++ b/majit/majit-metainterp/src/virtualizable.rs @@ -946,6 +946,17 @@ impl VirtualizableInfo { array_field_offsets: self.array_fields.iter().map(|a| a.field_offset).collect(), array_item_types: self.array_fields.iter().map(|a| a.item_type).collect(), array_field_descrs: self.array_field_descrs().to_vec(), + // Placeholder, like `vable_input_offset` below, and patched by the + // same caller. A length is not a property of the shape: upstream + // reads `len(lst)` off the live object every time it needs one + // (`virtualizable.py` `read_boxes`, `get_array_length`), and stores + // it nowhere. `MetaInterp::current_virtualizable_optimizer_config` + // fills this from `TraceCtx::virtualizable_array_lengths`, which + // both writers of `virtualizable_boxes` populate in the same + // statement. Leaving it empty while `array_field_offsets` is not + // makes `VirtualizableTracker::init`'s zip run zero times, so no + // element state is seeded and `tracked_array_element` can never + // hit — a debug assertion there names that state. array_lengths: vec![], vable_input_offset: 0, // Same declaration the resume path reads From 4e8d4a6cf8dafa6cb87ae0032e9f825566c012eb Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 09:09:30 +0900 Subject: [PATCH 02/10] interpreter: record why _unpackiterable_known_length_jitlook carries no unroll_safe MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The doc comment quotes upstream's `@jit.unroll_safe` along with the body it ports, which reads as an unfinished port. It is not one. Upstream reaches that body two ways and hints only one of them: `unpackiterable` goes through `_unpackiterable_known_length`, which is `@jit.dont_look_inside` ("the JIT stopped looking inside already"), while `unpackiterable_unroll` calls it directly with an UNPACK_SEQUENCE oparg as `expected_length`. pyre has neither `unpackiterable_unroll` nor the shim, so `unpackiterable` is this body's only caller — the one upstream fences off. Being loopy and unhinted the graph is rejected by `look_inside_graph` and stays a residual call, which is the boundary the shim buys upstream. Carrying the attribute alone would open that path, with `expected_length` — a red argument on one graph ~40 callers share — as the unroll bound. Restoring the split needs more than the attribute: `#[majit_macros::dont_look_inside]` registers a helper call descriptor, and `helper_call_kind_for_type` answers `Unsupported` for this signature's `Result, PyError>`, so the shim needs an `extern "C" fn(..) -> i64` publication first. `test_unroll_safe_inventory` asserts the harvested `unroll_safe` set is a subset of a reviewed list, plus a named negative for this body. Subset rather than equality because a developer's `build/llbc` is routinely older than the source and can only under-report, which must not red; `builtins:: leading_non_null_count` is the positive control, and its absence skips the test loudly rather than passing on an artefact too old to say anything. Assisted-by: Claude --- .../tests/test_unroll_safe_inventory.rs | 139 ++++++++++++++++++ pyre/pyre-interpreter/src/baseobjspace.rs | 29 ++++ 2 files changed, 168 insertions(+) create mode 100644 majit/majit-translate/tests/test_unroll_safe_inventory.rs diff --git a/majit/majit-translate/tests/test_unroll_safe_inventory.rs b/majit/majit-translate/tests/test_unroll_safe_inventory.rs new file mode 100644 index 00000000000..02dc996649b --- /dev/null +++ b/majit/majit-translate/tests/test_unroll_safe_inventory.rs @@ -0,0 +1,139 @@ +//! Every `unroll_safe` in the shipped interpreter LLBC is one that was +//! reviewed. +//! +//! `unroll_safe` is not a loop annotation. `codewriter/policy.rs` +//! `look_inside_graph` cancels `contains_loop` for a hinted graph, so the +//! attribute changes *what the walker descends into*: the hinted graph and +//! its whole callee closure enter the candidate set. The tree's history +//! with that is why this file exists — the same three attributes were added, +//! reverted for a SIGBUS traced to an sret ABI mismatch in a callee the hint +//! newly reached, and only re-landed once that callee was published +//! correctly. +//! +//! So an addition here is a descent-scope change that needs its own +//! evidence, and this test makes adding one without saying so fail. It is +//! deliberately a *subset* check rather than an equality check: a developer's +//! `build/llbc` is routinely older than the source (a `pyre-interpreter` +//! edit is invisible until re-extraction), and a stale artefact must not +//! produce a false red. A stale artefact can only under-report, which +//! passes; a new hint can only over-report, which fails. + +use majit_charon_reader::Llbc; +use majit_translate::front::llbc_hints::harvest_hints_from_llbcs; + +const INTERPRETER_LLBC: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../build/llbc/pyre-interpreter.ullbc" +); + +/// The leaf name of every function reviewed as `unroll_safe`, with the +/// upstream decorator it mirrors. +/// +/// Matched on the leaf rather than the full path because the harvester +/// spells a method with its impl block (`pyframe::::fast2locals`) and +/// a free function without one (`builtins::leading_non_null_count`); the +/// leaves are unambiguous across the interpreter. +const REVIEWED_UNROLL_SAFE: &[(&str, &str)] = &[ + // `abstractinst.py` carries `@jit.unroll_safe` on all three. + ( + "isinstance", + "abstractinst.py p_recursive_isinstance_w caller", + ), + ("issubclass", "abstractinst.py abstract_issubclass_w caller"), + ( + "p_abstract_issubclass_w", + "abstractinst.py _abstract_issubclass_w", + ), + // `pyframe.py` `fast2locals`. + ("fast2locals", "pyframe.py fast2locals"), + // No upstream counterpart by name; the loop is a bounded scan of a + // fixed-size argument slice. + ("leading_non_null_count", "flat builtin-keyword ABI scan"), +]; + +/// `builtins::leading_non_null_count` has carried its own `unroll_safe` +/// since it was introduced and appears in every recorded cache snapshot, so +/// its absence means the artefact is too old to say anything — skip loudly +/// rather than pass on a read that proves nothing. +const CONTROL: &str = "leading_non_null_count"; + +fn harvested_unroll_safe() -> Option> { + if !std::path::Path::new(INTERPRETER_LLBC).is_file() { + eprintln!( + "skipping: {INTERPRETER_LLBC} is missing; run \ + `python3 scripts/extract-llbc.py pyre-interpreter`" + ); + return None; + } + let llbc = Llbc::load(INTERPRETER_LLBC).expect("load pyre-interpreter.ullbc"); + let hints = harvest_hints_from_llbcs(std::slice::from_ref(&llbc)); + let mut paths: Vec = hints + .iter() + .filter(|(_, values)| values.iter().any(|h| h == "unroll_safe")) + .map(|(path, _)| path.clone()) + .collect(); + paths.sort(); + if !paths.iter().any(|p| leaf(p) == CONTROL) { + eprintln!( + "skipping: {INTERPRETER_LLBC} carries no `unroll_safe` on {CONTROL}, \ + so it predates the hint inventory entirely; re-extract to exercise \ + this test (harvested: {paths:?})" + ); + return None; + } + Some(paths) +} + +fn leaf(path: &str) -> &str { + path.rsplit("::").next().unwrap_or(path) +} + +#[test] +fn every_unroll_safe_in_the_shipped_llbc_is_a_reviewed_one() { + let Some(paths) = harvested_unroll_safe() else { + return; + }; + for path in &paths { + assert!( + REVIEWED_UNROLL_SAFE + .iter() + .any(|(name, _)| *name == leaf(path)), + "{path} carries `unroll_safe` but is not in REVIEWED_UNROLL_SAFE. \ + The attribute admits this graph and its callee closure into the \ + candidate set, so it needs its own evidence — measure \ + `fbw_rolled_back_with_effects` (a rise is a correctness verdict, \ + not a statistic) and the per-fixture jitstats before adding it, \ + then list it here. Harvested: {paths:?}", + ); + } +} + +/// `_unpackiterable_known_length_jitlook` quotes upstream's +/// `@jit.unroll_safe` in its own doc comment, which reads as an unfinished +/// port and has been picked up as one. It is not. +/// +/// Upstream hints that body for `unpackiterable_unroll`, whose +/// `expected_length` is an UNPACK_SEQUENCE oparg; `unpackiterable` reaches +/// it through `_unpackiterable_known_length`, which is +/// `@jit.dont_look_inside` — "the JIT stopped looking inside already". pyre +/// has neither `unpackiterable_unroll` nor the shim, so `unpackiterable` is +/// the body's only caller: the hinted path upstream keeps closed. Carrying +/// the attribute alone inverts that decision instead of matching it. +#[test] +fn the_known_length_unpack_body_stays_unhinted_without_its_shim() { + let Some(paths) = harvested_unroll_safe() else { + return; + }; + assert!( + !paths + .iter() + .any(|p| leaf(p) == "_unpackiterable_known_length_jitlook"), + "`unroll_safe` on _unpackiterable_known_length_jitlook opens the path \ + upstream fences with the `@jit.dont_look_inside` shim \ + `_unpackiterable_known_length`, which pyre does not have. Port the \ + shim (and `unpackiterable_unroll`) with an ABI-correct publication \ + first — the signature returns `Result, PyError>`, \ + which `helper_call_kind_for_type` answers `Unsupported` for. \ + Harvested: {paths:?}", + ); +} diff --git a/pyre/pyre-interpreter/src/baseobjspace.rs b/pyre/pyre-interpreter/src/baseobjspace.rs index 0e30f67f5dd..6d6e3e32395 100644 --- a/pyre/pyre-interpreter/src/baseobjspace.rs +++ b/pyre/pyre-interpreter/src/baseobjspace.rs @@ -14049,6 +14049,35 @@ fn build_default_pick_builtin_module() -> PyObjectRef { /// expected_length, idx) /// return items /// ``` +/// +/// The quoted `@jit.unroll_safe` is deliberately **not** carried on this +/// function, and porting it alone would invert upstream's decision rather +/// than match it. Upstream reaches this body from two directions and hints +/// only one of them: +/// +/// * `unpackiterable` goes through `_unpackiterable_known_length`, which is +/// `@jit.dont_look_inside` — "the JIT stopped looking inside already". +/// * `unpackiterable_unroll` calls this body directly. That is the caller +/// the hint exists for, and its `expected_length` is an UNPACK_SEQUENCE +/// oparg, so the unroll is bounded by a constant. +/// +/// pyre has neither `unpackiterable_unroll` nor `fixedview_unroll`, so +/// [`unpackiterable`] is this body's only caller — the one upstream fences +/// off. Being loopy and unhinted, the graph is rejected by +/// `look_inside_graph` (`majit-translate` `codewriter/policy.rs`) and stays a +/// residual call, which is the same boundary the shim buys upstream. Adding +/// the attribute here would open the fenced path and make `expected_length` +/// — a plain red argument on a graph ~40 callers share — the unroll bound. +/// +/// Restoring the split is the orthodox fix, but it is a larger change than +/// the attribute: `#[majit_macros::dont_look_inside]` registers a helper +/// call descriptor, and `helper_call_kind_for_type` answers `Unsupported` +/// for this signature's `Result, PyError>` (>16 bytes, so +/// an sret aggregate). The shim needs an ABI-correct `extern "C" fn(..) -> +/// i64` publication first, the way `next` is published as +/// `runtime_ops::bh_next`. Port `_unpackiterable_known_length` and +/// `unpackiterable_unroll` together with that publication, and only then the +/// attribute. fn _unpackiterable_known_length_jitlook( w_iterator: PyObjectRef, expected_length: usize, From 57c118db01c9c48c0c33c5139db4cea56ce1cd00 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 09:09:42 +0900 Subject: [PATCH 03/10] jit: carry the iterator element type into the next fold MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `iter_next_item_type` answered `Int` for a container produced by `front::range_iter`'s `range()` builtin and `Ref` for every other one. The `iter` op carries the iterator, not the container's item type, and a slice of non-GC items is spelled exactly like a slice of references — `is_concrete_iter_constructor` collapses `Vec`, `[T; N]` and `Box<[T]>` onto the same `core::slice::…::iter`. So the container alone could not separate them. `charon-corpus`'s `branch_loop_sum(slice: &[i64], ..)` folds `for &v in slice`, and its `i64` element was typed as a GC reference. `result_ty` is not a hint the rtyper overrules: `resolve_call_result_kind` consults `concretetype` only when `result_ty` is `Unknown`, and `authoritative_result_types` stamps the derived kind back over it, so the answer here outranks the rtyper for every graph that gets a JitCode. The recording site already reads a callee's `Result` payload for `result_exc_call_results`; `next_call_results` now carries the `Option` payload the same way, with the `&` a slice iterator adds peeled off by `strip_ty_wrappers`. `Ref(Some(root))` normalises back to `Ref(None)` so every GC-element graph that folds today stamps a byte-identical `result_ty`, and the range arm answers before the recorded type is consulted, because `rrange.py ll_rangenext_*` returns `Signed` whatever the Rust range spells. An unreadable `Option` shape falls back to `Ref(None)`, the answer the fold assumed unconditionally before. `branch_loop_sum_next_yields_an_int_element` fails on the previous behaviour with `left: [Ref(None)], right: [Int]`. Assisted-by: Claude --- majit/majit-translate/src/front/iter_next.rs | 177 +++++++++++++++--- majit/majit-translate/src/front/mir.rs | 36 +++- majit/majit-translate/src/front/result_exc.rs | 27 +++ .../tests/test_mir_frontend.rs | 39 ++++ 4 files changed, 247 insertions(+), 32 deletions(-) diff --git a/majit/majit-translate/src/front/iter_next.rs b/majit/majit-translate/src/front/iter_next.rs index 704a319821f..f07e93c92fa 100644 --- a/majit/majit-translate/src/front/iter_next.rs +++ b/majit/majit-translate/src/front/iter_next.rs @@ -192,33 +192,52 @@ fn walk_back_to_source( /// list's item repr, while `RangeIteratorRepr::rtype_next` /// (`rrange.py ll_rangenext_*`) hands back a `Signed`. /// -/// The `Ref` answer is the fold's assumption about every other container, -/// not a decision: [`is_iter_op_segments`] admits any `core::slice::…::iter`, -/// including a slice whose items are not GC references (`&[usize]`, -/// `&[u8]`). Such a loop would type raw integers into the ref register -/// bank. No graph the codewriter looks inside iterates one today — the two -/// production `#[unroll_safe]` sites iterate a `range` and a -/// `&[PyObjectRef]` — so closing it needs the container's element type, -/// which the fold does not consult. `front::range_iter` reroutes an exclusive int `Range` -/// for-loop onto the `range()` builtin plus the same `iter` bridge, so both -/// reprs arrive here behind one `iter` op and only the container that op was -/// given tells them apart. +/// Two reprs arrive here behind one `iter` op, and the op does not tell +/// them apart. [`is_iter_op_segments`] admits any `core::slice::…::iter`, +/// and `front::range_iter` deliberately reroutes an exclusive int `Range` +/// for-loop onto the `range()` builtin plus that same bridge, so the +/// container the op was given is what separates them — hence the backward +/// walk rather than a test on the op. /// -/// Answering `Ref` for a range is not inert. The legacy type walker reads -/// `result_ty` straight off the op (`legacy_annotator`'s `Call` arm returns -/// it whenever it is not `Unknown`), so the loop's induction variable lands -/// in the ref register bank, and every `array[i]` in the loop body then -/// assembles as a `getarrayitem_gc` whose index is ref-kind — which -/// `assembler.rs` rejects outright. Graphs containing a loop are normally -/// residualized rather than looked inside, so this surfaces only on a graph -/// carrying `@jit.unroll_safe`. -fn iter_next_item_type(graph: &FunctionGraph, iterator: &Variable) -> ValueType { +/// Getting this wrong is not inert. `result_ty` is read straight off the +/// op: `resolve_call_result_kind` (`codewriter/jtransform.rs`) consults the +/// rtyper's `concretetype` *only* when `result_ty` is `Unknown`, and +/// `authoritative_result_types` (`codewriter/type_state.rs`) then stamps the +/// derived kind back over it. So a wrong answer here outranks the real +/// rtyper for every graph that gets a JitCode, not just the legacy tier: the +/// induction variable lands in the wrong register bank, and an `array[i]` in +/// the loop body assembles as a `getarrayitem_gc` with a ref-kind index, +/// which `assembler.rs` asserts on. +/// +/// And the container alone was never enough, because a slice of non-GC +/// items is spelled exactly like a slice of references — the same +/// `core::slice::…::iter` that `is_concrete_iter_constructor` collapses +/// `Vec` / `[T; N]` / `Box<[T]>` onto. `charon-corpus`'s +/// `branch_loop_sum(slice: &[i64], ..)` folds `for &v in slice` today, and +/// answering `Ref` for every non-range container typed its `i64` element as +/// a GC reference. Hence `recorded`: the element type read off the +/// `Option` at the recording site, which is the only place it survives. +fn iter_next_item_type( + graph: &FunctionGraph, + iterator: &Variable, + recorded: &ValueType, +) -> ValueType { + // `rrange.py ll_rangenext_*` hands back a `Signed` whatever the Rust + // range's own spelling is, so the range arm answers before the recorded + // element type is consulted — a `0..n` over `usize` records `Unsigned`. let over_a_range = iter_op_container(graph, iterator) .is_some_and(|container| produced_by_range_builtin(graph, &container)); if over_a_range { - ValueType::Int - } else { - ValueType::Ref(None) + return ValueType::Int; + } + match recorded { + // `rlist.py ll_listnext` hands back the list's item repr. The + // classdef is dropped: a `Ref(Some(root))` would seed a different + // `SomeInstance` shell in `valuetype_to_someshell`, so keeping the + // bare `Ref` is what leaves every GC-element graph that folds today + // stamping a byte-identical `result_ty`. + ValueType::Ref(_) => ValueType::Ref(None), + other => other.clone(), } } @@ -322,10 +341,13 @@ fn int_const(i: i64) -> LinkArg { /// `Option` match does not fit the for-loop shape is left as the residual /// call (Skip), so a mismatch never regresses a graph the legacy walker /// already handled. Returns the number of sites rewritten. -pub(crate) fn rewire_next_call_sites(graph: &mut FunctionGraph, sites: &[Variable]) -> usize { +pub(crate) fn rewire_next_call_sites( + graph: &mut FunctionGraph, + sites: &[(Variable, ValueType)], +) -> usize { let mut rewritten = 0; - for opt in sites { - match rewire_one_next_site(graph, opt) { + for (opt, recorded_item_ty) in sites { + match rewire_one_next_site(graph, opt, recorded_item_ty) { Ok(()) => rewritten += 1, Err(_decline) => { // Leave the residual `next` call; the unregistered callee @@ -429,7 +451,11 @@ pub(crate) fn peel_recast_chain( Ok(cur) } -fn rewire_one_next_site(graph: &mut FunctionGraph, opt: &Variable) -> Result<(), String> { +fn rewire_one_next_site( + graph: &mut FunctionGraph, + opt: &Variable, + recorded_item_ty: &ValueType, +) -> Result<(), String> { let name = graph.name.clone(); // Block A: the block whose op produces `opt` — the residual `next()` // call, closed by lower_call with a single forwarding exit. @@ -459,6 +485,12 @@ fn rewire_one_next_site(graph: &mut FunctionGraph, opt: &Variable) -> Result<(), } }; + // Read the element type off the still-unmutated graph: the backward + // walk to the `iter` op's container has to see the block structure the + // recording site saw, and the dead forwarded-slot removal below rewrites + // exactly that. + let item_ty = iter_next_item_type(graph, &iter_arg, recorded_item_ty); + // `lower_call` closes the block right after the raising call, so the // `next()` call is normally A's last op. An UNREGISTERED `next()` // returns an opaque `Ref` that the MIR immediately recasts to the @@ -675,7 +707,6 @@ fn rewire_one_next_site(graph: &mut FunctionGraph, opt: &Variable) -> Result<(), // call (peeled above) are dropped so the native `next` op — which // produces the scrutinised `opt` directly — is A's last op and thus the // block's `raising_op` under the `LastException` exitswitch below. - let item_ty = iter_next_item_type(graph, &iter_arg); graph.blocks[a].operations.truncate(next_idx + 1); graph.blocks[a].operations[next_idx] = SpaceOperation { result: Some(opt.clone()), @@ -725,3 +756,93 @@ fn rewire_one_next_site(graph: &mut FunctionGraph, opt: &Variable) -> Result<(), ]; Ok(()) } + +#[cfg(test)] +mod tests { + use super::*; + + /// A graph holding just the `iter` op the fold anchors on, over a + /// container that is either the `range()` builtin's result or an + /// unrelated call's. Returns the iterator variable. + fn graph_with_iter(over_a_range: bool) -> (FunctionGraph, Variable) { + let mut g = FunctionGraph::new("test_iter_next_item_type"); + let n = g.startblock; + let container_segments = if over_a_range { + vec!["__pyre_range".to_string()] + } else { + vec![ + "some".to_string(), + "container".to_string(), + "make".to_string(), + ] + }; + let container = g + .push_op_var( + n, + OpKind::Call { + target: CallTarget::FunctionPath { + segments: container_segments, + }, + args: Vec::new(), + result_ty: ValueType::Ref(None), + }, + true, + ) + .unwrap(); + let it = g + .push_op_var( + n, + OpKind::Call { + target: CallTarget::FunctionPath { + segments: vec!["core".to_string(), "slice".to_string(), "iter".to_string()], + }, + args: vec![container], + result_ty: ValueType::Ref(None), + }, + true, + ) + .unwrap(); + (g, it) + } + + /// `ll_rangenext_up` returns `Signed` whatever the Rust range spells, + /// so the range arm answers before the recorded element type — a + /// `for i in 0..n` over `usize` records `Unsigned` and must still come + /// back `Int`. This is the guard against "just use the recorded type". + #[test] + fn a_range_container_answers_int_over_its_recorded_element() { + let (g, it) = graph_with_iter(true); + assert_eq!( + iter_next_item_type(&g, &it, &ValueType::Unsigned), + ValueType::Int, + ); + } + + /// A GC-reference element keeps the bare `Ref`: the classdef is dropped + /// so every graph that folded before this element type was carried + /// still stamps the identical `result_ty`. + #[test] + fn a_gc_reference_element_answers_a_classdefless_ref() { + let (g, it) = graph_with_iter(false); + assert_eq!( + iter_next_item_type(&g, &it, &ValueType::Ref(Some("PyObject".into()))), + ValueType::Ref(None), + ); + } + + /// The arm this element type was carried for. `charon-corpus`'s + /// `branch_loop_sum(slice: &[i64], ..)` folds `for &v in slice` today and + /// stamped `Ref` on an `i64`; a non-GC element must come back as itself + /// so it lands in the int register bank. + #[test] + fn a_non_gc_slice_element_keeps_its_own_kind() { + let (g, it) = graph_with_iter(false); + for recorded in [ValueType::Int, ValueType::Unsigned, ValueType::Float] { + assert_eq!( + iter_next_item_type(&g, &it, &recorded), + recorded, + "{recorded:?} element must not be retyped as a GC reference", + ); + } + } +} diff --git a/majit/majit-translate/src/front/mir.rs b/majit/majit-translate/src/front/mir.rs index de5931e6b8f..2bf2d432603 100644 --- a/majit/majit-translate/src/front/mir.rs +++ b/majit/majit-translate/src/front/mir.rs @@ -2252,10 +2252,17 @@ fn lower_unstructured_with_static_addrs_and_attrs( // simplified graph; fail-safe — an unpaired / multi-consumer range // aggregate stays the ordinary ADT ctor (census Skip). if !lo.range_iter_new_sites.is_empty() && !lo.next_call_results.is_empty() { + // The range rewrite only locates the `next()` producer; the + // element kind recorded beside it belongs to the diamond fold. + let next_vars: Vec = lo + .next_call_results + .iter() + .map(|(var, _)| var.clone()) + .collect(); crate::front::range_iter::rewire_range_iter_sites( &mut lo.graph, &lo.range_iter_new_sites, - &lo.next_call_results, + &next_vars, ); } let next_rewritten = if lo.next_call_results.is_empty() { @@ -2945,8 +2952,11 @@ struct Lowering<'a> { result_exc_call_results: Vec<(Variable, Option, ValueType)>, /// `Iterator::next()` call results (`Option`-typed) recorded for /// the `next`-diamond rewiring pass (`front::iter_next`) that runs - /// after the body lowering completes. - next_call_results: Vec, + /// after the body lowering completes. The paired [`ValueType`] is the + /// element `T` with the `&` a slice iterator adds peeled off — the only + /// place the element's kind is still readable, since the fold's op + /// carries the iterator and not the container's item type. + next_call_results: Vec<(Variable, ValueType)>, /// `i64::checked_{add,sub,mul}()` call results (`Option`-typed) /// recorded for the checked-arith rewiring pass /// (`front::checked_arith`) that runs after the body lowering @@ -9200,7 +9210,25 @@ impl<'a> Lowering<'a> { && crate::front::iter_next::is_iterator_next_target(target) && crate::front::result_exc::tyref_is_option(&call.dest.ty, self.llbc) { - self.next_call_results.push(result_var.clone()); + // A slice iterator yields `Option<&T>`; peel the `&` so the + // recorded kind is the item's own, the way `ll_listnext` hands + // back the list's item repr rather than a pointer to it. An + // unreadable shape records `Ref(None)` — the answer the fold + // assumed unconditionally before this was carried, so an + // unreadable type keeps today's behaviour instead of inventing + // a new one. + let item_ty = crate::front::result_exc::tyref_option_payload(&call.dest.ty, self.llbc) + .and_then(|payload| { + let body = match &payload { + TyRef::Inline { value: (_, v) } | TyRef::Other(v) => v, + TyRef::Dedup { id } => self.llbc.dedup_body(*id)?, + }; + let item = strip_ty_wrappers(body, self.llbc)?; + serde_json::from_value::(item.clone()).ok() + }) + .map(|ty| tyref_to_value_type(&ty, self.llbc)) + .unwrap_or(ValueType::Ref(None)); + self.next_call_results.push((result_var.clone(), item_ty)); } // Capture `i64::checked_{add,sub,mul}()` results (`Option`- // typed) for the checked-arith rewiring pass diff --git a/majit/majit-translate/src/front/result_exc.rs b/majit/majit-translate/src/front/result_exc.rs index a68d39f574c..9ca413fc212 100644 --- a/majit/majit-translate/src/front/result_exc.rs +++ b/majit/majit-translate/src/front/result_exc.rs @@ -270,6 +270,33 @@ pub(crate) fn tyref_result_ok(ty: &TyRef, llbc: &Llbc) -> Option { result_ok_slot(ty, llbc).and_then(|slot| serde_json::from_value(slot.clone()).ok()) } +/// The `T` payload slot of an `Option` type value, or `None` when `ty` is +/// not an `Option`. Sibling of [`result_ok_slot`]. +fn option_payload_slot<'l>(ty: &'l TyRef, llbc: &'l Llbc) -> Option<&'l serde_json::Value> { + let body = match ty { + TyRef::Inline { value: (_, v) } => v, + TyRef::Other(v) => v, + TyRef::Dedup { id } => llbc.dedup_body(*id)?, + }; + if adt_path_of(body, llbc).as_deref() != Some("core::option::Option") { + return None; + } + body.get("Adt") + .and_then(|a| a.get("generics")) + .and_then(|g| g.get("types")) + .and_then(|t| t.get(0)) +} + +/// The `T` of an `Option` as its own [`TyRef`] — for an +/// `Iterator::next()` return, the element the iterator yields. Sibling of +/// [`tyref_result_ok`]. +/// +/// A slice iterator yields `Option<&T>`, so the answer still carries the +/// `&`; callers that want the item's own shape peel it (`strip_ty_wrappers`). +pub(crate) fn tyref_option_payload(ty: &TyRef, llbc: &Llbc) -> Option { + option_payload_slot(ty, llbc).and_then(|slot| serde_json::from_value(slot.clone()).ok()) +} + /// Collapse a scoped callee's returnblock to a genuine void return. /// /// A `Result<(), PyError>` callee carries the unit `Ok` payload as a diff --git a/majit/majit-translate/tests/test_mir_frontend.rs b/majit/majit-translate/tests/test_mir_frontend.rs index f751c19e9e9..9fde5affc56 100644 --- a/majit/majit-translate/tests/test_mir_frontend.rs +++ b/majit/majit-translate/tests/test_mir_frontend.rs @@ -444,6 +444,45 @@ fn front_graph_carries_no_synthesized_exception_edges() { ); } +/// `branch_loop_sum` iterates `&[i64]`, so the element `[__iter_next]` +/// yields is an `i64` — the list's item repr, the way +/// `rlist.py ll_listnext` hands one back. +/// +/// This is the corpus half of the element-type fix. The fold used to +/// answer `Ref` for every container that was not `front::range_iter`'s +/// `range()` builtin, because the `iter` op carries the iterator and not +/// the container's item type — so this graph typed a raw `i64` into the +/// ref register bank. `result_ty` is not a hint the rtyper can overrule: +/// `resolve_call_result_kind` consults `concretetype` only when +/// `result_ty` is `Unknown`, and `authoritative_result_types` stamps the +/// derived kind back over it. +#[test] +fn branch_loop_sum_next_yields_an_int_element() { + use majit_translate::model::{CallTarget, OpKind, ValueType}; + let llbc = load_corpus(); + let graph = lower_function(llbc, "branch_loop_sum").expect("lowering"); + + let element_types: Vec = graph + .blocks + .iter() + .flat_map(|b| &b.operations) + .filter_map(|op| match &op.kind { + OpKind::Call { + target: CallTarget::FunctionPath { segments }, + result_ty, + .. + } if segments.len() == 1 && segments[0] == "__iter_next" => Some(result_ty.clone()), + _ => None, + }) + .collect(); + + assert_eq!( + element_types, + vec![ValueType::Int], + "the `&[i64]` element must keep its own kind, not be typed as a GC reference", + ); +} + /// `branch_loop_sum`'s `for &v in slice` lifts to the native `iter` + /// `[__iter_next]` ops: Layer 3 of the iterator vertical replaces the /// residual `Iterator::next()` call (an unregistered callee that would From a82a8bc1c72d4cb2432e43d94958bf7ad7238128 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 09:34:47 +0900 Subject: [PATCH 04/10] jit: port arraylen_vable to the codewriter `rewrite_op_getarraysize` (`jtransform.py:808-817`) is the third consumer of `vable_array_vars`, alongside `rewrite_op_getarrayitem` and `rewrite_op_setarrayitem`. The codewriter had the other two and answered a `len()` over a virtualizable array with a plain `arraylen_gc` on the raw array pointer. Adds `OpKind::VableArrayLen`, the `rewrite_op_getarraysize` arm, and the assembler encoding for the `arraylen_vable/rdd>i` key that `insns.rs`, `blackhole.rs`, `opimpl_arraylen_vable` and `bhimpl_arraylen_vable` already carried. The macro lowering (`majit-macros` `lower_vable_array_len`) emitted the instruction; the codewriter path did not. Assisted-by: Claude --- .../src/codewriter/assembler.rs | 43 +++++ majit/majit-translate/src/codewriter/call.rs | 3 +- .../majit-translate/src/codewriter/format.rs | 1 + .../src/codewriter/jtransform.rs | 151 ++++++++++++++++++ .../src/codewriter/type_state.rs | 2 + majit/majit-translate/src/front/result_exc.rs | 1 + majit/majit-translate/src/inline.rs | 15 ++ majit/majit-translate/src/model.rs | 24 +++ .../translator/rtyper/flowspace_adapter.rs | 2 + .../src/translator/rtyper/legacy_annotator.rs | 3 + .../src/translator/rtyper/legacy_resolve.rs | 2 + 11 files changed, 246 insertions(+), 1 deletion(-) diff --git a/majit/majit-translate/src/codewriter/assembler.rs b/majit/majit-translate/src/codewriter/assembler.rs index f7963930e70..0dc34302edf 100644 --- a/majit/majit-translate/src/codewriter/assembler.rs +++ b/majit/majit-translate/src/codewriter/assembler.rs @@ -2317,6 +2317,45 @@ impl Assembler { let opnum = self.get_opnum(&key); state.code[startposition] = opnum; } + OpKind::VableArrayLen { + base, + array_index, + item_ty, + array_itemsize, + array_is_signed, + } => { + let (reg, kc) = self.lookup_reg_with_kind_var(base, regallocs); + state.code.push(reg); + argcodes.push(kc); + // The same descr pair its read and write siblings carry, in + // the same order: fielddescr (vable array field) + arraydescr. + // `arraylen_vable/rdd>i` reads only the first at run time, + // but `expect_matching_vable_array_descrs` checks the pair. + let descr_idx = self.emit_ready_descr(crate::jitcode::BhDescr::VableArray { + index: *array_index, + }); + state.code.push((descr_idx & 0xFF) as u8); + state.code.push((descr_idx >> 8) as u8); + argcodes.push('d'); + let descr_idx2 = self.emit_ready_descr(vable_arraydescrof( + item_ty, + *array_itemsize, + *array_is_signed, + )); + state.code.push((descr_idx2 & 0xFF) as u8); + state.code.push((descr_idx2 >> 8) as u8); + argcodes.push('d'); + if let Some(result) = op.result.as_ref() { + argcodes.push('>'); + let (reg, kc) = self.lookup_reg_with_kind_var(result, regallocs); + argcodes.push(kc); + state.code.push(reg); + } + let opname = op_kind_to_opname(&op.kind); + let key = format!("{opname}/{argcodes}"); + let opnum = self.get_opnum(&key); + state.code[startposition] = opnum; + } OpKind::VableForce { base } => { let (reg, kc) = self.lookup_reg_with_kind_var(base, regallocs); assert_eq!(kc, 'r', "hint_force_virtualizable expects a Ref base"); @@ -2788,6 +2827,7 @@ impl Assembler { OpKind::VableFieldWrite { .. } => "VableFieldWrite", OpKind::VableArrayRead { .. } => "VableArrayRead", OpKind::VableArrayWrite { .. } => "VableArrayWrite", + OpKind::VableArrayLen { .. } => "VableArrayLen", OpKind::BinOp { .. } => "BinOp", OpKind::UnaryOp { .. } => "UnaryOp", OpKind::VableForce { .. } => "VableForce", @@ -4673,6 +4713,9 @@ fn op_kind_to_opname(kind: &crate::model::OpKind) -> String { OpKind::VableArrayWrite { item_ty, .. } => { format!("setarrayitem_vable_{}", value_type_to_kind(item_ty)) } + // `jtransform.py:814-817` — one opname with no kind suffix: a + // length is a `Signed` whatever the element kind is. + OpKind::VableArrayLen { .. } => "arraylen_vable".into(), // RPython `blackhole.py:500` canonical opnames for bitwise ints are // `int_and` / `int_or` / `int_xor`. When an `OpKind::BinOp.op` // arrives spelled with Rust's `syn::BinOp` trait names diff --git a/majit/majit-translate/src/codewriter/call.rs b/majit/majit-translate/src/codewriter/call.rs index d2360e7a01a..cb4fc62ff5e 100644 --- a/majit/majit-translate/src/codewriter/call.rs +++ b/majit/majit-translate/src/codewriter/call.rs @@ -8589,7 +8589,8 @@ fn op_can_raise(op: &OpKind) -> RaiseClass { OpKind::VableFieldRead { .. } | OpKind::VableFieldWrite { .. } | OpKind::VableArrayRead { .. } - | OpKind::VableArrayWrite { .. } => RaiseClass::No, + | OpKind::VableArrayWrite { .. } +| OpKind::VableArrayLen { .. } => RaiseClass::No, // Post-jtransform call ops: raise is determined by their descriptor, // not by op_can_raise. These are not "simple operations" in RPython // terms — they're handled by analyze() → analyze_direct_call. diff --git a/majit/majit-translate/src/codewriter/format.rs b/majit/majit-translate/src/codewriter/format.rs index 53b55f7c922..bf73a94a0a0 100644 --- a/majit/majit-translate/src/codewriter/format.rs +++ b/majit/majit-translate/src/codewriter/format.rs @@ -807,6 +807,7 @@ fn op_result_kind(kind: &crate::model::OpKind) -> RegKind { | OpKind::InteriorFieldRead { item_ty, .. } | OpKind::VableArrayRead { item_ty, .. } => value_type_kind(item_ty), OpKind::IsConstant { .. } | OpKind::IsVirtual { .. } => RegKind::Int, + OpKind::VableArrayLen { .. } => RegKind::Int, // Result-less or pyre-only debug variants — `op_args_repr` // only reaches this fall-through when `op.result.is_some()`, // so any miss surfaces as a real coverage gap to extend. diff --git a/majit/majit-translate/src/codewriter/jtransform.rs b/majit/majit-translate/src/codewriter/jtransform.rs index b74019a6e87..b0d8f22204c 100644 --- a/majit/majit-translate/src/codewriter/jtransform.rs +++ b/majit/majit-translate/src/codewriter/jtransform.rs @@ -1447,6 +1447,10 @@ impl<'a> Transformer<'a> { } if self.config.lower_virtualizable => { self.rewrite_op_setarrayitem(op, base, index, value, item_ty, graph_name) } + // ── rewrite_op_getarraysize ── + OpKind::ArrayLen { base, .. } if self.config.lower_virtualizable => { + self.rewrite_op_getarraysize(op, base, graph_name) + } // ── rewrite_op_direct_call ── OpKind::Call { target, @@ -3362,6 +3366,66 @@ impl<'a> Transformer<'a> { RewriteResult::Keep } + /// `jtransform.py:808-817 rewrite_op_getarraysize` — the third and last + /// consumer of `vable_array_vars`. + /// + /// Without it a `len()` on a virtualizable array is the one route that + /// still reads the raw array pointer, so the field read that produced it + /// cannot be dropped the way `rewrite_op_getfield`'s + /// `except VirtualizableArrayField:` handler drops it (`return []`). + /// The other two consumers, `rewrite_op_getarrayitem` and + /// `rewrite_op_setarrayitem`, have answered against the vable base since + /// they were ported. + /// + /// The macro lowering has emitted this instruction all along + /// (`majit-macros` `lower_vable_array_len`), and the whole run-time side + /// — the `arraylen_vable/rdd>i` key, the assembler, `opimpl_arraylen_vable`, + /// `bhimpl_arraylen_vable` — was already in place; only the codewriter + /// path never reached it. + fn rewrite_op_getarraysize( + &mut self, + op: &SpaceOperation, + base: &crate::flowspace::model::Variable, + graph_name: &str, + ) -> RewriteResult { + let Some((vable_base, arr_idx, itemsize, is_signed)) = + self.vable_array_vars.get(base).cloned() + else { + return RewriteResult::Keep; + }; + self.notes.push(GraphTransformNote { + function: graph_name.to_string(), + detail: format!("rewrite: len(array) → VableArrayLen[{arr_idx}]"), + }); + self.vable_rewrites += 1; + // `jtransform.py:814` — `-live-` leads the virtualizable array + // length read, as it leads its read and write siblings. + RewriteResult::Replace(vec![ + SpaceOperation { + result: None, + kind: OpKind::Live, + }, + SpaceOperation { + result: op.result.clone(), + kind: OpKind::VableArrayLen { + base: vable_base, + array_index: arr_idx, + // Upstream passes the `arraydescr` off `vinfo` + // (`jtransform.py:816`), not one derived at the access — + // an `arraylen_gc` carries no element type to derive one + // from. `vable_arraydescrof` asserts the block behind a + // virtualizable array is a `FixedObjectArray` of + // word-wide `PyObjectRef`s, which is the one shape this + // mint accepts, so the element type is that and the pair + // `expect_matching_vable_array_descrs` cross-checks holds. + item_ty: ValueType::Ref(None), + array_itemsize: itemsize, + array_is_signed: is_signed, + }, + }, + ]) + } + /// RPython: rewrite_op_setarrayitem fn rewrite_op_setarrayitem( &mut self, @@ -6912,6 +6976,19 @@ fn remap_op( array_itemsize: *array_itemsize, array_is_signed: *array_is_signed, }, + OpKind::VableArrayLen { + base, + array_index, + item_ty, + array_itemsize, + array_is_signed, + } => OpKind::VableArrayLen { + base: remap_value(base, aliases), + array_index: *array_index, + item_ty: item_ty.clone(), + array_itemsize: *array_itemsize, + array_is_signed: *array_is_signed, + }, OpKind::VableArrayWrite { base, array_index, @@ -8469,6 +8546,80 @@ mod tests { assert_eq!(rewritten_base, &base_var_held); } + /// `jtransform.py:808-817 rewrite_op_getarraysize` — the third + /// consumer of `vable_array_vars`. + /// + /// A `len()` over a virtualizable array answers against the frame, not + /// the array pointer, so the field read that produced the pointer has + /// no consumer left and is dropped with the other two. + #[test] + fn transform_graph_rewrites_a_vable_array_len_against_the_frame() { + let mut graph = FunctionGraph::new("test"); + let base_var = graph.alloc_value_var(); + let base_var_held = base_var.clone(); + let array_var = graph + .push_op_var( + graph.startblock, + OpKind::FieldRead { + base: base_var, + field: crate::model::FieldDescriptor::new( + "locals_stack_w", + Some("Frame".into()), + ), + ty: ValueType::Ref(None), + pure: false, + }, + true, + ) + .unwrap(); + graph.push_op_var( + graph.startblock, + OpKind::ArrayLen { + base: array_var, + array_type_id: None, + nolength: false, + }, + true, + ); + graph.set_return(graph.startblock, None); + + let config = GraphTransformConfig { + vable_arrays: vec![VirtualizableFieldDescriptor::new_with_arraydescr( + "locals_stack_w", + Some("Frame".into()), + 0, + 8, + true, + )], + ..Default::default() + }; + let result = transform_graph(&graph, &config); + assert_eq!(result.vable_rewrites, 1); + let ops = &result.graph.block(graph.startblock).operations; + assert!( + !ops.iter() + .any(|op| matches!(op.kind, OpKind::ArrayLen { .. })), + "the raw arraylen must be gone, got {:?}", + ops.iter().map(|op| &op.kind).collect::>(), + ); + // `jtransform.py:814` — `-live-` leads the vable array length read. + assert!( + matches!(ops[1].kind, OpKind::Live), + "vable array length must be led by -live-, got {:?}", + ops[1].kind + ); + let OpKind::VableArrayLen { + base: rewritten_base, + array_index, + .. + } = &ops[2].kind + else { + panic!("expected VableArrayLen, got {:?}", ops[1].kind); + }; + assert_eq!(*array_index, 0); + assert_eq!(rewritten_base, &base_var_held); + } + /// `jtransform.py:126-127` + `:145-168 _check_no_vable_array` — the /// array a virtualizable field read produced may not leave the block /// along a link argument; the block that would consume it has no diff --git a/majit/majit-translate/src/codewriter/type_state.rs b/majit/majit-translate/src/codewriter/type_state.rs index 01d412b76c6..d86b85f8bb7 100644 --- a/majit/majit-translate/src/codewriter/type_state.rs +++ b/majit/majit-translate/src/codewriter/type_state.rs @@ -144,6 +144,8 @@ pub(crate) fn authoritative_result_type_from_op(kind: &OpKind) -> Option Some(ConcreteType::Signed), + // `arraylen_vable/rdd>i` answers a length, never the element kind. + OpKind::VableArrayLen { .. } => Some(ConcreteType::Signed), _ => None, } } diff --git a/majit/majit-translate/src/front/result_exc.rs b/majit/majit-translate/src/front/result_exc.rs index 9ca413fc212..274babe22c2 100644 --- a/majit/majit-translate/src/front/result_exc.rs +++ b/majit/majit-translate/src/front/result_exc.rs @@ -760,6 +760,7 @@ pub(crate) fn op_operand_vars(kind: &OpKind) -> Vec { OpKind::VableArrayRead { base, elem_index, .. } => vec![base.clone(), elem_index.clone()], + OpKind::VableArrayLen { base, .. } => vec![base.clone()], OpKind::VableArrayWrite { base, elem_index, diff --git a/majit/majit-translate/src/inline.rs b/majit/majit-translate/src/inline.rs index 8e6c167e824..cdabfa81e27 100644 --- a/majit/majit-translate/src/inline.rs +++ b/majit/majit-translate/src/inline.rs @@ -644,6 +644,19 @@ pub(crate) fn remap_op_kind( array_itemsize: *array_itemsize, array_is_signed: *array_is_signed, }, + OpKind::VableArrayLen { + base, + array_index, + item_ty, + array_itemsize, + array_is_signed, + } => OpKind::VableArrayLen { + base: remap_var(base), + array_index: *array_index, + item_ty: item_ty.clone(), + array_itemsize: *array_itemsize, + array_is_signed: *array_is_signed, + }, OpKind::VableArrayWrite { base, array_index, @@ -1019,6 +1032,7 @@ pub fn op_variable_refs(kind: &OpKind) -> Vec OpKind::VableArrayRead { base, elem_index, .. } => vec![clone_var(base), clone_var(elem_index)], + OpKind::VableArrayLen { base, .. } => vec![clone_var(base)], OpKind::VableArrayWrite { base, elem_index, @@ -1196,6 +1210,7 @@ pub fn is_pure_op(kind: &OpKind) -> bool { // Pure virtualizable reads — no heap mutation. | OpKind::VableFieldRead { .. } | OpKind::VableArrayRead { .. } + | OpKind::VableArrayLen { .. } // Pure vtable slot read — `cast_pointer + getfield` chain // collapsed into one op (see `OpKind::VtableMethodPtr` doc). | OpKind::VtableMethodPtr { .. } diff --git a/majit/majit-translate/src/model.rs b/majit/majit-translate/src/model.rs index 1c0593cd0aa..7d194aecbd2 100644 --- a/majit/majit-translate/src/model.rs +++ b/majit/majit-translate/src/model.rs @@ -1014,6 +1014,30 @@ pub enum OpKind { /// RPython: arraydescr.is_item_signed() from VirtualizableInfo.array_descrs. array_is_signed: bool, }, + /// Virtualizable array length → reads the length off the boxes. + /// RPython: `arraylen_vable`. + /// + /// Emitted by `jtransform.py:808-817 rewrite_op_getarraysize`, the third + /// consumer of `vable_array_vars` alongside [`OpKind::VableArrayRead`] + /// and [`OpKind::VableArrayWrite`]. Without it a `len()` over a + /// virtualizable array is the one route that still reads the raw array + /// pointer, so the field read producing that pointer cannot be dropped + /// the way `rewrite_op_getfield`'s `except VirtualizableArrayField:` + /// handler drops it. + /// + /// Carries the two descrs its siblings do even though only the + /// vable-array one is read at run time: the bytecode key is + /// `arraylen_vable/rdd>i` (`insns.rs`), and + /// `expect_matching_vable_array_descrs` cross-checks the pair. + VableArrayLen { + base: crate::flowspace::model::Variable, + array_index: usize, + item_ty: ValueType, + /// RPython: arraydescr.itemsize from VirtualizableInfo.array_descrs. + array_itemsize: usize, + /// RPython: arraydescr.is_item_signed() from VirtualizableInfo.array_descrs. + array_is_signed: bool, + }, /// Binary arithmetic/comparison operation. /// RPython: `int_add`, `int_lt`, etc. BinOp { diff --git a/majit/majit-translate/src/translator/rtyper/flowspace_adapter.rs b/majit/majit-translate/src/translator/rtyper/flowspace_adapter.rs index 115287968fd..e7a304b3099 100644 --- a/majit/majit-translate/src/translator/rtyper/flowspace_adapter.rs +++ b/majit/majit-translate/src/translator/rtyper/flowspace_adapter.rs @@ -2760,6 +2760,7 @@ fn opkind_variant_name(kind: &OpKind) -> &'static str { OpKind::VableFieldWrite { .. } => "VableFieldWrite", OpKind::VableArrayRead { .. } => "VableArrayRead", OpKind::VableArrayWrite { .. } => "VableArrayWrite", + OpKind::VableArrayLen { .. } => "VableArrayLen", OpKind::CallElidable { .. } => "CallElidable", OpKind::CallResidual { .. } => "CallResidual", OpKind::CallMayForce { .. } => "CallMayForce", @@ -2802,6 +2803,7 @@ fn post_rtyper_jtransform_variant_name(kind: &OpKind) -> Option<&'static str> { OpKind::VableFieldWrite { .. } => "VableFieldWrite (jtransform.py:651-927)", OpKind::VableArrayRead { .. } => "VableArrayRead (jtransform.py:651-927)", OpKind::VableArrayWrite { .. } => "VableArrayWrite (jtransform.py:651-927)", + OpKind::VableArrayLen { .. } => "VableArrayLen (jtransform.py:808-817)", OpKind::CallElidable { .. } => "CallElidable (jtransform.py:414-435 rewrite_call)", OpKind::CallResidual { .. } => "CallResidual (jtransform.py:414-435 rewrite_call)", OpKind::CallMayForce { .. } => "CallMayForce (jtransform.py:414-435 rewrite_call)", diff --git a/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs b/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs index 253cf48288c..a6e775fd3b1 100644 --- a/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs +++ b/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs @@ -317,6 +317,9 @@ fn infer_op_type(kind: &OpKind) -> ValueType { OpKind::VableFieldWrite { .. } => ValueType::Void, OpKind::VableArrayRead { item_ty, .. } => item_ty.clone(), OpKind::VableArrayWrite { .. } => ValueType::Void, +// `arraylen_vable/rdd>i` — a length is a `Signed`, never the +// element kind. +OpKind::VableArrayLen { .. } => ValueType::Int, OpKind::UnaryOp { op, operand, diff --git a/majit/majit-translate/src/translator/rtyper/legacy_resolve.rs b/majit/majit-translate/src/translator/rtyper/legacy_resolve.rs index 2af4705b0b0..d601cebe9ce 100644 --- a/majit/majit-translate/src/translator/rtyper/legacy_resolve.rs +++ b/majit/majit-translate/src/translator/rtyper/legacy_resolve.rs @@ -655,6 +655,8 @@ fn infer_concrete_from_op(kind: &OpKind) -> ConcreteType { c } } + // A length, not an element — no `Unknown`-to-`GcRef` fallback applies. + OpKind::VableArrayLen { .. } => ConcreteType::Signed, // `OpKind::Abort` for unsupported syntax — macros, unsupported // literals, fallback expressions. Fall back to GcRef so these values // still get a regalloc coloring and the assembler's From 0deb7a78acdabf4e06c2da88b3638bc6ee0356e4 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 09:37:09 +0900 Subject: [PATCH 05/10] jit: drop the getfield a virtualizable array field read produced `rewrite_op_getfield`'s `except VirtualizableArrayField:` handler ends in `return []` (`jtransform.py:848-857`): registering the base in `vable_array_vars` is the whole rewrite. The port kept the op, so a `getfield_gc_r` of the array pointer stayed in the jitcode and fell through to the immutability-rank rewrite below. All three consumers now answer against the vable base, so the read has no user left. Assisted-by: Claude --- .../src/codewriter/jtransform.rs | 37 ++++++++++++++----- 1 file changed, 28 insertions(+), 9 deletions(-) diff --git a/majit/majit-translate/src/codewriter/jtransform.rs b/majit/majit-translate/src/codewriter/jtransform.rs index b0d8f22204c..91aff42fbb7 100644 --- a/majit/majit-translate/src/codewriter/jtransform.rs +++ b/majit/majit-translate/src/codewriter/jtransform.rs @@ -3059,6 +3059,16 @@ impl<'a> Transformer<'a> { let is_signed = array_field.array_is_signed.unwrap_or(false); self.vable_array_vars .insert(result, (base_var, array_field.index, itemsize, is_signed)); + // `rewrite_op_getfield`'s `except VirtualizableArrayField:` handler + // ends in `return []` — registering the base is the whole rewrite + // and the read itself is dropped. `rewrite_op_getarrayitem` emits + // `VableArrayRead` against the *frame* variable, never against this + // result, and `check_no_vable_array` rejects every other consumer + // route, so the op is dead the moment its uses are rewritten. + // Keeping it left a `getfield_gc_r` of the array pointer in the + // jitcode and exposed it to the immutability-rank rewrite below, + // neither of which upstream reaches. + return RewriteResult::Replace(Vec::new()); } // Virtualizable scalar field → VableFieldRead if let Some(vable_field) = self @@ -8523,14 +8533,23 @@ mod tests { }; let result = transform_graph(&graph, &config); assert_eq!(result.vable_rewrites, 1); - // `jtransform.py:764-767` — `-live-` leads the vable array read. + // The field read that produced the array is gone: registering the + // base is the whole rewrite, and `rewrite_op_getfield`'s + // `except VirtualizableArrayField:` handler ends in `return []`. let ops = &result.graph.block(graph.startblock).operations; assert!( - matches!(ops[1].kind, OpKind::Live), + !ops.iter() + .any(|op| matches!(op.kind, OpKind::FieldRead { .. })), + "the virtualizable array field read must be dropped, got {:?}", + ops.iter().map(|op| &op.kind).collect::>(), + ); + // `jtransform.py:764-767` — `-live-` leads the vable array read. + assert!( + matches!(ops[0].kind, OpKind::Live), "virtualizable array read must be led by -live-, got {:?}", - ops[1].kind + ops[0].kind ); - let rewritten_op = &ops[2]; + let rewritten_op = &ops[1]; let OpKind::VableArrayRead { base: rewritten_base, array_index, @@ -8598,21 +8617,21 @@ mod tests { let ops = &result.graph.block(graph.startblock).operations; assert!( !ops.iter() - .any(|op| matches!(op.kind, OpKind::ArrayLen { .. })), - "the raw arraylen must be gone, got {:?}", + .any(|op| matches!(op.kind, OpKind::FieldRead { .. } | OpKind::ArrayLen { .. })), + "the array field read and the raw arraylen must both be gone, got {:?}", ops.iter().map(|op| &op.kind).collect::>(), ); // `jtransform.py:814` — `-live-` leads the vable array length read. assert!( - matches!(ops[1].kind, OpKind::Live), + matches!(ops[0].kind, OpKind::Live), "vable array length must be led by -live-, got {:?}", - ops[1].kind + ops[0].kind ); let OpKind::VableArrayLen { base: rewritten_base, array_index, .. - } = &ops[2].kind + } = &ops[1].kind else { panic!("expected VableArrayLen, got {:?}", ops[1].kind); }; From be646deb3b76b86356d55e0020a43f5e26582370 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 09:40:21 +0900 Subject: [PATCH 06/10] jit: fix indentation and the descr-pair citation on the arraylen_vable arms Two of the new match arms landed at the wrong column; `cargo fmt` leaves them alone because it bails on the enclosing `match` in both files. The descr-pair comments named `expect_matching_vable_array_descrs`, which is `pyre-jit`'s assembler. The runtime that decodes the emitted `arraylen_vable/rdd>i` is `MIFrame::vable_array_index_pair_at`. Assisted-by: Claude --- majit/majit-translate/src/codewriter/assembler.rs | 5 +++-- majit/majit-translate/src/codewriter/call.rs | 2 +- majit/majit-translate/src/codewriter/format.rs | 5 +++-- majit/majit-translate/src/codewriter/jtransform.rs | 2 +- majit/majit-translate/src/model.rs | 8 ++++---- .../src/translator/rtyper/legacy_annotator.rs | 6 +++--- 6 files changed, 15 insertions(+), 13 deletions(-) diff --git a/majit/majit-translate/src/codewriter/assembler.rs b/majit/majit-translate/src/codewriter/assembler.rs index 0dc34302edf..103aefd0f5f 100644 --- a/majit/majit-translate/src/codewriter/assembler.rs +++ b/majit/majit-translate/src/codewriter/assembler.rs @@ -2329,8 +2329,9 @@ impl Assembler { argcodes.push(kc); // The same descr pair its read and write siblings carry, in // the same order: fielddescr (vable array field) + arraydescr. - // `arraylen_vable/rdd>i` reads only the first at run time, - // but `expect_matching_vable_array_descrs` checks the pair. + // `arraylen_vable/rdd>i` takes the length off the first at + // run time, but `vable_array_index_pair_at` reads both and + // rejects anything that is not `(VableArray, Array)`. let descr_idx = self.emit_ready_descr(crate::jitcode::BhDescr::VableArray { index: *array_index, }); diff --git a/majit/majit-translate/src/codewriter/call.rs b/majit/majit-translate/src/codewriter/call.rs index cb4fc62ff5e..534e9f2413d 100644 --- a/majit/majit-translate/src/codewriter/call.rs +++ b/majit/majit-translate/src/codewriter/call.rs @@ -8590,7 +8590,7 @@ fn op_can_raise(op: &OpKind) -> RaiseClass { | OpKind::VableFieldWrite { .. } | OpKind::VableArrayRead { .. } | OpKind::VableArrayWrite { .. } -| OpKind::VableArrayLen { .. } => RaiseClass::No, + | OpKind::VableArrayLen { .. } => RaiseClass::No, // Post-jtransform call ops: raise is determined by their descriptor, // not by op_can_raise. These are not "simple operations" in RPython // terms — they're handled by analyze() → analyze_direct_call. diff --git a/majit/majit-translate/src/codewriter/format.rs b/majit/majit-translate/src/codewriter/format.rs index bf73a94a0a0..c7933a9a4df 100644 --- a/majit/majit-translate/src/codewriter/format.rs +++ b/majit/majit-translate/src/codewriter/format.rs @@ -806,8 +806,9 @@ fn op_result_kind(kind: &crate::model::OpKind) -> RegKind { OpKind::ArrayRead { item_ty, .. } | OpKind::InteriorFieldRead { item_ty, .. } | OpKind::VableArrayRead { item_ty, .. } => value_type_kind(item_ty), - OpKind::IsConstant { .. } | OpKind::IsVirtual { .. } => RegKind::Int, - OpKind::VableArrayLen { .. } => RegKind::Int, + OpKind::IsConstant { .. } | OpKind::IsVirtual { .. } | OpKind::VableArrayLen { .. } => { + RegKind::Int + } // Result-less or pyre-only debug variants — `op_args_repr` // only reaches this fall-through when `op.result.is_some()`, // so any miss surfaces as a real coverage gap to extend. diff --git a/majit/majit-translate/src/codewriter/jtransform.rs b/majit/majit-translate/src/codewriter/jtransform.rs index 91aff42fbb7..ae94ab5eda1 100644 --- a/majit/majit-translate/src/codewriter/jtransform.rs +++ b/majit/majit-translate/src/codewriter/jtransform.rs @@ -3427,7 +3427,7 @@ impl<'a> Transformer<'a> { // virtualizable array is a `FixedObjectArray` of // word-wide `PyObjectRef`s, which is the one shape this // mint accepts, so the element type is that and the pair - // `expect_matching_vable_array_descrs` cross-checks holds. + // `vable_array_index_pair_at` checks holds. item_ty: ValueType::Ref(None), array_itemsize: itemsize, array_is_signed: is_signed, diff --git a/majit/majit-translate/src/model.rs b/majit/majit-translate/src/model.rs index 7d194aecbd2..2301048dee0 100644 --- a/majit/majit-translate/src/model.rs +++ b/majit/majit-translate/src/model.rs @@ -1025,10 +1025,10 @@ pub enum OpKind { /// the way `rewrite_op_getfield`'s `except VirtualizableArrayField:` /// handler drops it. /// - /// Carries the two descrs its siblings do even though only the - /// vable-array one is read at run time: the bytecode key is - /// `arraylen_vable/rdd>i` (`insns.rs`), and - /// `expect_matching_vable_array_descrs` cross-checks the pair. + /// Carries the two descrs its siblings do even though the length comes + /// off the vable-array one alone: the bytecode key is + /// `arraylen_vable/rdd>i` (`insns.rs`), and `vable_array_index_pair_at` + /// rejects a pair that is not `(VableArray, Array)`. VableArrayLen { base: crate::flowspace::model::Variable, array_index: usize, diff --git a/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs b/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs index a6e775fd3b1..1e0bb91827b 100644 --- a/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs +++ b/majit/majit-translate/src/translator/rtyper/legacy_annotator.rs @@ -317,9 +317,9 @@ fn infer_op_type(kind: &OpKind) -> ValueType { OpKind::VableFieldWrite { .. } => ValueType::Void, OpKind::VableArrayRead { item_ty, .. } => item_ty.clone(), OpKind::VableArrayWrite { .. } => ValueType::Void, -// `arraylen_vable/rdd>i` — a length is a `Signed`, never the -// element kind. -OpKind::VableArrayLen { .. } => ValueType::Int, + // `arraylen_vable/rdd>i` — a length is a `Signed`, never the + // element kind. + OpKind::VableArrayLen { .. } => ValueType::Int, OpKind::UnaryOp { op, operand, From dad6db110d2650d2a9c9b254fb2cb884f24e0820 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 16:50:03 +0900 Subject: [PATCH 07/10] =?UTF-8?q?jit:=20address=20the=20#1374=20review=20?= =?UTF-8?q?=E2=80=94=20gate=20the=20vable=20arms,=20and=20peel=20one=20ref?= =?UTF-8?q?erence?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `rewrite_op_getfield` runs whether or not `lower_virtualizable` is set, because the quasi-immutable tail below it does not depend on virtualizable lowering. Its two virtualizable arms do. With `vable_arrays` set and the flag off, the array arm registered a base no consumer would read and dropped a read those consumers still referenced, leaving regalloc an undefined variable. `strip_ty_wrappers` peels `Ref` repeatedly, so an iterator over `&[&i64]` recorded its `Option<&&i64>` payload as `Int` and put a pointer in the integer register bank. `iterator_payload_element` peels the one reference the iterator adds and leaves the element's own. Also: require `array_lengths.len() == array_field_offsets.len()` rather than non-emptiness, since the zip truncates a short vector silently; pin the `arraylen_vable/rdd>i` wire shape and its descr pair; and fail the unroll_safe inventory when two harvested paths share a leaf, which is the assumption it matches on. Assisted-by: Claude --- .../src/optimizeopt/virtualize.rs | 49 +++++++- .../src/codewriter/assembler.rs | 115 ++++++++++++++++++ .../src/codewriter/jtransform.rs | 77 +++++++++++- majit/majit-translate/src/front/mir.rs | 67 ++++++++-- .../tests/test_unroll_safe_inventory.rs | 18 +++ 5 files changed, 312 insertions(+), 14 deletions(-) diff --git a/majit/majit-metainterp/src/optimizeopt/virtualize.rs b/majit/majit-metainterp/src/optimizeopt/virtualize.rs index b9a6dcd790e..32514c2b0bb 100644 --- a/majit/majit-metainterp/src/optimizeopt/virtualize.rs +++ b/majit/majit-metainterp/src/optimizeopt/virtualize.rs @@ -321,12 +321,24 @@ impl VirtualizableTracker { // relies on its caller to patch the lengths in, so name the // unpatched config here rather than letting it read as "this // trace had no array elements". + // The zip below pairs `array_field_offsets` with `array_lengths`, + // so a short `array_lengths` does not fail — it silently drops the + // tail, seeding some arrays and leaving the rest untracked. An + // empty vector is only the loudest case of that, so require the + // whole invariant rather than non-emptiness. debug_assert!( !self.config.track_array_elements - || self.config.array_field_offsets.is_empty() - || !self.config.array_lengths.is_empty(), - "array-tracking config reached the optimizer with unseeded array_lengths; \ - see MetaInterp::current_virtualizable_optimizer_config", + || self.config.array_lengths.len() == self.config.array_field_offsets.len(), + "array-tracking config reached the optimizer with {} array_lengths for {} \ + array fields; the zip below would pair only {} of them and leave the rest \ + unseeded, so `tracked_array_element` can never hit for those — see \ + MetaInterp::current_virtualizable_optimizer_config", + self.config.array_lengths.len(), + self.config.array_field_offsets.len(), + self.config + .array_lengths + .len() + .min(self.config.array_field_offsets.len()), ); if self.config.track_array_elements { for (array_idx, (&_offset, &length)) in self @@ -3752,7 +3764,7 @@ mod tests { /// absorb it silently, leaving every `tracked_array_element` a miss that /// reads as "this trace had no array elements". #[test] - #[should_panic(expected = "unseeded array_lengths")] + #[should_panic(expected = "array_lengths for")] fn array_tracking_config_without_lengths_is_named_not_absorbed() { let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { @@ -3773,6 +3785,33 @@ mod tests { } } + /// A length vector shorter than the field list is the case a + /// non-emptiness check cannot see: `zip` pairs what it can and drops the + /// rest, so the first array is seeded, the second is not, and + /// `tracked_array_element` misses for it exactly as if no config had + /// arrived at all. + #[test] + #[should_panic(expected = "array_lengths for")] + fn a_partial_array_lengths_vector_is_named_not_truncated() { + let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); + let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { + static_field_offsets: vec![], + static_field_types: vec![], + static_field_descrs: vec![], + array_field_offsets: vec![48, 56], + array_item_types: vec![Type::Ref, Type::Ref], + array_field_descrs: vec![], + array_lengths: vec![4], + vable_input_offset: 0, + identity_input_index: Some(0), + track_array_elements: true, + }); + pass.setup(); + if let Some(ref mut vt) = pass.vable { + vt.ensure_setup(&mut ctx); + } + } + /// The same shape with `track_array_elements` off is the state-field /// macro JIT's, which carries elements through the live /// `virtualizable_boxes` shadow instead; and a config with no array field diff --git a/majit/majit-translate/src/codewriter/assembler.rs b/majit/majit-translate/src/codewriter/assembler.rs index 103aefd0f5f..8eda7d49f92 100644 --- a/majit/majit-translate/src/codewriter/assembler.rs +++ b/majit/majit-translate/src/codewriter/assembler.rs @@ -6960,6 +6960,121 @@ mod tests { } } + /// `arraylen_vable` is a cross-layer contract: the codewriter picks the + /// key, `insns.rs` assigns its byte, and `MIFrame::read_vable_arraylen` + /// decodes `1B vable_reg + 2B fdescr + 2B adescr + 1B dest` and asserts + /// the descr pair is `(VableArray, Array)`. Three files have to agree on + /// one wire shape, so pin the whole shape here rather than the opname + /// alone. + #[test] + fn assemble_vable_arraylen_emits_the_rdd_to_i_wire_shape() { + use crate::flatten::flatten_graph; + use crate::jtransform::{GraphTransformConfig, Transformer, VirtualizableFieldDescriptor}; + use crate::model::{FieldDescriptor, FunctionGraph, OpKind, ValueType}; + + let mut graph = FunctionGraph::new("vable_arraylen"); + let base_var = push_input_var(&mut graph, "frame", ValueType::Ref(None)); + let array_var = graph + .push_op_var( + graph.startblock, + OpKind::FieldRead { + base: base_var.clone(), + field: FieldDescriptor::new("locals_stack_w", Some("Frame".into())), + ty: ValueType::Ref(None), + pure: false, + }, + true, + ) + .unwrap(); + let len_var = graph + .push_op_var( + graph.startblock, + OpKind::ArrayLen { + base: array_var, + array_type_id: None, + nolength: false, + }, + true, + ) + .unwrap(); + graph.set_return(graph.startblock, Some(len_var.clone())); + FunctionGraph::set_concretetype_of_inline( + &base_var, + crate::codewriter::type_state::ConcreteType::GcRef, + ); + // The driver that normally supplies this is + // `type_state::authoritative_result_types`, which answers `Signed` for + // `VableArrayLen`; this test drives `Transformer` directly, so state + // it here rather than depend on a pass it does not run. + FunctionGraph::set_concretetype_of_inline( + &len_var, + crate::codewriter::type_state::ConcreteType::Signed, + ); + + let config = GraphTransformConfig { + vable_arrays: vec![VirtualizableFieldDescriptor::new_with_arraydescr( + "locals_stack_w", + Some("Frame".into()), + 0, + crate::layout::target_word_size(), + false, + )], + ..Default::default() + }; + let mut rewritten = Transformer::new(&config).transform(&graph).graph; + regalloc::augment_canonical_exceptblock_on_graph(&mut rewritten); + let mut regallocs = regalloc::perform_all_register_allocations(&rewritten); + let mut flat = flatten_graph(&rewritten, &mut regallocs); + let mut asm = Assembler::new(); + let _ = asm.assemble(&mut flat, ®allocs); + + assert!( + asm.insns.contains_key("arraylen_vable/rdd>i"), + "a vable array length must assemble to `arraylen_vable/rdd>i`, got {:?}", + asm.insns.keys().collect::>() + ); + assert!( + !asm.insns.keys().any(|k| k.starts_with("arraylen_gc")), + "the raw `arraylen_gc` must be gone, got {:?}", + asm.insns.keys().collect::>() + ); + + // The two descrs, in the order the decoder reads them. + let ready: Vec<&crate::jitcode::BhDescr> = asm + .descrs + .iter() + .filter_map(|d| match d { + AssemblerDescr::Ready(b) => Some(&**b), + _ => None, + }) + .collect(); + let vable_at = ready + .iter() + .position(|d| matches!(d, crate::jitcode::BhDescr::VableArray { index: 0 })) + .unwrap_or_else(|| panic!("no VableArray descr minted, got {ready:?}")); + let array_at = ready + .iter() + .position(|d| matches!(d, crate::jitcode::BhDescr::Array { .. })) + .unwrap_or_else(|| panic!("no Array descr minted, got {ready:?}")); + assert!( + vable_at < array_at, + "the vable-array descr must precede the array descr, got {ready:?}" + ); + let crate::jitcode::BhDescr::Array { + base_size, + itemsize, + len_offset, + is_array_of_pointers, + .. + } = ready[array_at] + else { + unreachable!("checked by the position above"); + }; + let word = crate::layout::target_word_size(); + assert_eq!((*base_size, *itemsize, *len_offset), (word, word, Some(0))); + assert!(is_array_of_pointers); + } + #[test] fn assemble_typed_reads_use_canonical_non_v_opnames() { use crate::flatten::flatten_graph; diff --git a/majit/majit-translate/src/codewriter/jtransform.rs b/majit/majit-translate/src/codewriter/jtransform.rs index ae94ab5eda1..58736a536c1 100644 --- a/majit/majit-translate/src/codewriter/jtransform.rs +++ b/majit/majit-translate/src/codewriter/jtransform.rs @@ -3036,13 +3036,23 @@ impl<'a> Transformer<'a> { // of the field at all; tracking it would drop the op and leave the // address's consumer with an undefined operand. let fresh_virtualizable = fresh_virtualizable || field.suppresses_virtualizable(); + // `lower_virtualizable` guards the four sibling dispatch arms — + // `rewrite_op_setfield`, `rewrite_op_getarrayitem`, + // `rewrite_op_setarrayitem`, `rewrite_op_getarraysize`. This function + // runs whether or not the flag is set, because the quasi-immutable + // tail below is independent of virtualizable lowering; the two + // virtualizable arms here are not. With the flag off, the array arm + // would register a base no consumer will ever read and drop a read + // those consumers still reference, leaving regalloc an undefined + // variable. The field's own doc covers "field/array accesses" — both. + let lower_vable = self.config.lower_virtualizable && !fresh_virtualizable; // Track virtualizable array field reads if let Some(array_field) = self .config .vable_arrays .iter() .find(|c| c.matches(field)) - .filter(|_| !fresh_virtualizable) + .filter(|_| lower_vable) && let Some(result) = op.result.clone() { // RPython: vable_array_vars[result] = (v_base, arrayfielddescr, arraydescr) @@ -3076,7 +3086,7 @@ impl<'a> Transformer<'a> { .vable_fields .iter() .find(|c| c.matches(field)) - .filter(|_| !fresh_virtualizable) + .filter(|_| lower_vable) { self.notes.push(GraphTransformNote { function: graph_name.to_string(), @@ -8565,6 +8575,69 @@ mod tests { assert_eq!(rewritten_base, &base_var_held); } + /// With `lower_virtualizable` off, the array field read stays: the four + /// consumer arms are gated on that flag, so dropping the read would leave + /// them referencing a variable nothing defines. + /// + /// `rewrite_op_getfield` is the one member of the family that runs + /// ungated — the quasi-immutable tail below it does not depend on + /// virtualizable lowering — which is exactly why its two virtualizable + /// arms need the check the dispatch would otherwise have made. + #[test] + fn a_vable_array_read_is_kept_when_virtualizable_lowering_is_off() { + let mut graph = FunctionGraph::new("test"); + let base_var = graph.alloc_value_var(); + let index_var = graph.alloc_value_var(); + let array_var = graph + .push_op_var( + graph.startblock, + OpKind::FieldRead { + base: base_var, + field: crate::model::FieldDescriptor::new( + "locals_stack_w", + Some("Frame".into()), + ), + ty: ValueType::Ref(None), + pure: false, + }, + true, + ) + .unwrap(); + graph.push_op_var( + graph.startblock, + OpKind::ArrayRead { + base: array_var.clone(), + index: index_var, + item_ty: ValueType::Int, + array_type_id: None, + nolength: false, + pure: false, + }, + true, + ); + graph.set_return(graph.startblock, None); + + let config = GraphTransformConfig { + lower_virtualizable: false, + vable_arrays: vec![VirtualizableFieldDescriptor::new_with_arraydescr( + "locals_stack_w", + Some("Frame".into()), + 0, + 8, + true, + )], + ..Default::default() + }; + let result = transform_graph(&graph, &config); + assert_eq!(result.vable_rewrites, 0); + let ops = &result.graph.block(graph.startblock).operations; + assert!( + ops.iter().any(|op| op.result.as_ref() == Some(&array_var)), + "with lowering off the array read must still be defined, got {:?}", + ops.iter().map(|op| &op.kind).collect::>(), + ); + } + /// `jtransform.py:808-817 rewrite_op_getarraysize` — the third /// consumer of `vable_array_vars`. /// diff --git a/majit/majit-translate/src/front/mir.rs b/majit/majit-translate/src/front/mir.rs index 2bf2d432603..6948821084c 100644 --- a/majit/majit-translate/src/front/mir.rs +++ b/majit/majit-translate/src/front/mir.rs @@ -9210,20 +9210,21 @@ impl<'a> Lowering<'a> { && crate::front::iter_next::is_iterator_next_target(target) && crate::front::result_exc::tyref_is_option(&call.dest.ty, self.llbc) { - // A slice iterator yields `Option<&T>`; peel the `&` so the + // A slice iterator yields `Option<&T>`; peel that one `&` so the // recorded kind is the item's own, the way `ll_listnext` hands - // back the list's item repr rather than a pointer to it. An - // unreadable shape records `Ref(None)` — the answer the fold - // assumed unconditionally before this was carried, so an - // unreadable type keeps today's behaviour instead of inventing - // a new one. + // back the list's item repr rather than a pointer to it — and + // only that one, so an element that is itself a reference stays + // reference-typed. An unreadable shape records `Ref(None)` — the + // answer the fold assumed unconditionally before this was + // carried, so an unreadable type keeps today's behaviour instead + // of inventing a new one. let item_ty = crate::front::result_exc::tyref_option_payload(&call.dest.ty, self.llbc) .and_then(|payload| { let body = match &payload { TyRef::Inline { value: (_, v) } | TyRef::Other(v) => v, TyRef::Dedup { id } => self.llbc.dedup_body(*id)?, }; - let item = strip_ty_wrappers(body, self.llbc)?; + let item = iterator_payload_element(body, self.llbc)?; serde_json::from_value::(item.clone()).ok() }) .map(|ty| tyref_to_value_type(&ty, self.llbc)) @@ -16803,6 +16804,58 @@ fn strip_ty_wrappers<'l>( None } +/// Strip only the indirection wrappers — `{"Deduplicated": id}` and +/// `{"HashConsedValue": [id, ty]}` — leaving any `Ref` in place. +/// +/// [`strip_ty_wrappers`] peels `Ref` too, and peels it repeatedly. A caller +/// that must account for exactly one reference level cannot use it: over +/// `&&i64` it answers `i64`, which is the item type of neither. +fn strip_ty_indirections<'l>( + mut node: &'l serde_json::Value, + llbc: &'l Llbc, +) -> Option<&'l serde_json::Value> { + for _ in 0..24 { + let obj = node.as_object()?; + if let Some(id) = obj.get("Deduplicated").and_then(serde_json::Value::as_u64) { + node = llbc.dedup_body(id)?; + continue; + } + if let Some(arr) = obj + .get("HashConsedValue") + .and_then(serde_json::Value::as_array) + && arr.len() == 2 + { + node = &arr[1]; + continue; + } + return Some(node); + } + None +} + +/// The element type behind an iterator's `next()` payload. +/// +/// A slice iterator yields `Option<&T>`, so exactly one reference level +/// belongs to the iterator and the rest belongs to the element: over +/// `&[i64]` the payload is `&i64` and the element is `i64`, but over +/// `&[&i64]` it is `&&i64` and the element is `&i64` — a pointer, which +/// belongs in the Ref bank. Peeling every `Ref` would put that pointer in +/// the integer bank. +/// +/// A by-value iterator (`[i64; N]`, `Vec`) hands back the item itself +/// with no reference to peel, so a payload that is not a `Ref` is already +/// the element. +fn iterator_payload_element<'l>( + payload: &'l serde_json::Value, + llbc: &'l Llbc, +) -> Option<&'l serde_json::Value> { + let node = strip_ty_indirections(payload, llbc)?; + let Some(arr) = node.get("Ref").and_then(serde_json::Value::as_array) else { + return Some(node); + }; + strip_ty_indirections(arr.get(1)?, llbc) +} + /// De Bruijn *index* of a `{"TypeVar": {"Bound": [depth, index]}}` node. /// The binder depth differs between a parameter-type position and a /// trait-clause subject position (the clause subject sits one binder diff --git a/majit/majit-translate/tests/test_unroll_safe_inventory.rs b/majit/majit-translate/tests/test_unroll_safe_inventory.rs index 02dc996649b..6966632f71a 100644 --- a/majit/majit-translate/tests/test_unroll_safe_inventory.rs +++ b/majit/majit-translate/tests/test_unroll_safe_inventory.rs @@ -73,6 +73,24 @@ fn harvested_unroll_safe() -> Option> { .map(|(path, _)| path.clone()) .collect(); paths.sort(); + // `REVIEWED_UNROLL_SAFE` and the subset check below both match on the + // leaf, on the stated assumption that leaves are unambiguous across the + // interpreter. Nothing else verifies that. If an unreviewed function + // elsewhere later takes an already-reviewed leaf name and is hinted, the + // subset check would pass on the strength of the other function's review + // — the one outcome this file exists to prevent. + let mut leaves: std::collections::HashMap<&str, &str> = std::collections::HashMap::new(); + for path in &paths { + if let Some(previous) = leaves.insert(leaf(path), path.as_str()) { + panic!( + "leaf `{}` is ambiguous between {previous} and {path}. \ + REVIEWED_UNROLL_SAFE matches by leaf, so it cannot tell them \ + apart and one would ride on the other's review; key the \ + inventory by full path before adding either.", + leaf(path), + ); + } + } if !paths.iter().any(|p| leaf(p) == CONTROL) { eprintln!( "skipping: {INTERPRETER_LLBC} carries no `unroll_safe` on {CONTROL}, \ From 7bc36b508ec61a9d9c02495b66fede1c9feb3926 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 18:25:33 +0900 Subject: [PATCH 08/10] jit: read the iterator ADT before peeling, and catch vable array escapes by any route `iterator_payload_element` peeled one reference off every `next()` payload. A slice iterator adds that reference, but the by-value iterators `is_concrete_iter_constructor` admits do not: `alloc::vec::into_iter::IntoIter` and `core::array::iter::IntoIter` yield `Option`, so the payload is the element already. `Vec<&i64>` and `[&i64; N]` therefore recorded their `&i64` element as `Int` and put a pointer in the integer register bank -- the mirror image of the `&[&i64]` defect the peel was added for. The `next()` receiver names the iterator ADT; peel only for `core::slice::iter::Iter` / `IterMut`. `slice_of_refs_sum` and `array_of_refs_sum` carry both shapes in the corpus. Peeling unconditionally fails the first, never peeling fails `branch_loop_sum_next_yields_an_int_element`; no fixed answer passes both. `check_no_vable_array` enumerated four operand positions. Registering a variable in `vable_array_vars` drops the `getfield` that defined it, and nothing prunes dead operations between `transform` and regalloc, so any operand a kept operation still names is a variable used and never defined. A fifth route scans every operand of every operation the block kept; it reports last and least precisely, and it exists because the four are an enumeration. `_handle_list_call` carries no `vable_array_vars` check and is owed none: upstream splits on `resizable`, putting the check on the `do_fixed_list_*` arms whose receiver is a `GcArray`, and every spelling pyre ports is of the resizable family with a `W_ListObject` receiver. Also: decode the assembled bytes in the `arraylen_vable` wire-shape test rather than only the descr pool order; exercise `lower_virtualizable = false` on the scalar-field arm as well as the array arm; and run the unroll_safe leaf-collision check after the CONTROL guard, so a stale artefact is skipped rather than judged. Assisted-by: Claude --- majit/charon-corpus/corpus.ullbc | 2 +- majit/charon-corpus/src/lib.rs | 25 +++ majit/majit-charon-reader/tests/corpus.rs | 5 +- .../src/codewriter/assembler.rs | 35 +++- .../src/codewriter/jtransform.rs | 171 +++++++++++++++++- majit/majit-translate/src/front/mir.rs | 70 +++++-- .../tests/test_mir_frontend.rs | 41 +++++ .../tests/test_unroll_safe_inventory.rs | 17 +- 8 files changed, 332 insertions(+), 34 deletions(-) diff --git a/majit/charon-corpus/corpus.ullbc b/majit/charon-corpus/corpus.ullbc index 30eddb48f53..f9bb94f9c79 100644 --- a/majit/charon-corpus/corpus.ullbc +++ b/majit/charon-corpus/corpus.ullbc @@ -1 +1 @@ -{"charon_version":"0.1.201","translated":{"crate_name":"charon_corpus","options":{"ullbc":true,"precise_drops":false,"skip_borrowck":false,"mir":null,"rustc_args":[],"targets":[],"monomorphize":false,"monomorphize_mut":null,"start_from":[],"start_from_if_exists":[],"start_from_attribute":null,"start_from_pub":false,"include":[],"opaque":[],"exclude":[],"extract_opaque_bodies":false,"translate_all_methods":false,"lift_associated_types":[],"hide_marker_traits":false,"remove_adt_clauses":false,"hide_allocator":false,"remove_unused_self_clauses":false,"desugar_drops":false,"ops_to_function_calls":false,"index_to_function_calls":false,"treat_box_as_builtin":false,"raw_consts":false,"unsized_strings":false,"reconstruct_fallible_operations":false,"reconstruct_asserts":false,"unbind_item_vars":false,"print_original_ullbc":false,"print_ullbc":false,"print_built_llbc":false,"print_llbc":false,"dest_dir":null,"dest_file":"/Users/youknowone/Projects/pyre-majit-general/build/llbc/corpus.ullbc","no_dedup_serialized_ast":false,"format":null,"no_serialize":false,"no_typecheck":false,"no_normalize":false,"abort_on_error":false,"error_on_warnings":false,"preset":null},"target_information":[{"key":"aarch64-apple-darwin","value":{"target_pointer_size":8,"is_little_endian":true}}],"files":[{"id":0,"name":{"Local":"src/lib.rs"},"crate_name":"charon_corpus","contents":"//! Charon fixture corpus: representative shapes from issue #97.\n//!\n//! 1. `straight_line_add` — straight-line interpreter-shaped function.\n//! 2. `branch_loop_sum` — branch + loop, like opcode dispatch fragments.\n//! 3. `strategy_dispatch` — enum-as-strategy (dict-strategy stand-in).\n//! 4. `desugar_mix` — `?`, `match`, and iterator desugaring together.\n\n#![allow(dead_code)]\n\npub type PyResult = Result;\n\n// --- 1. Straight-line ---------------------------------------------------\n\n#[inline(never)]\npub fn straight_line_add(a: i64, b: i64, c: i64) -> i64 {\n let s = a + b;\n let t = s * 2;\n t + c\n}\n\n// --- 2. Branch + loop ---------------------------------------------------\n\n#[inline(never)]\npub fn branch_loop_sum(slice: &[i64], threshold: i64) -> i64 {\n let mut acc: i64 = 0;\n for &v in slice {\n if v > threshold {\n acc += v;\n } else {\n acc -= v;\n }\n }\n acc\n}\n\n// --- 3. Strategy dispatch (dict-strategy stand-in) ----------------------\n\npub enum Strategy {\n Empty,\n IntKeyed { len: usize },\n StrKeyed { len: usize, capacity: usize },\n}\n\n#[inline(never)]\npub fn strategy_len(s: &Strategy) -> usize {\n match s {\n Strategy::Empty => 0,\n Strategy::IntKeyed { len } => *len,\n Strategy::StrKeyed { len, capacity: _ } => *len,\n }\n}\n\n// --- 4. Desugar mix: ?, match, iterator --------------------------------\n\npub enum Token {\n Add(i64),\n Sub(i64),\n Halt,\n}\n\nfn parse_one(raw: i64) -> PyResult {\n match raw {\n i64::MIN => Ok(Token::Halt),\n 0 => Err(\"halt-zero forbidden\"),\n v if v > 0 => Ok(Token::Add(v)),\n v => Ok(Token::Sub(-v)),\n }\n}\n\n#[inline(never)]\npub fn desugar_mix(input: &[i64]) -> PyResult {\n let mut acc: i64 = 0;\n for &raw in input.iter() {\n let tok = parse_one(raw)?;\n match tok {\n Token::Add(v) => acc += v,\n Token::Sub(v) => acc -= v,\n Token::Halt => break,\n }\n }\n Ok(acc)\n}\n\n// --- 5. Tuple round-trip: construct a tuple, read .0/.1 in same fn ------\n//\n// Exercises `Rvalue::Aggregate` for a *non-Adt* (tuple) value paired\n// with `Field` projection reads of that same local. The lowering must\n// emit a `__pos_` `FieldRead` symmetric to the construction-side\n// `FieldWrite` chain rather than collapsing every `.N` to the base.\n\n#[inline(never)]\npub fn tuple_roundtrip(a: i64, b: i64) -> i64 {\n let pair = (a + b, a - b);\n pair.0 * pair.1\n}\n\n// --- 6. Closures --------------------------------------------------------\n//\n// `bool_then_closure` is the exact `core::bool::::then` census shape:\n// an opaque combinator taking a `FnOnce` closure that captures a value from\n// the enclosing scope. Charon extracts the closure's `call_once` body as a\n// transparent inherent method of the closure type.\n\n#[inline(never)]\npub fn bool_then_closure(c: bool, x: i64) -> Option {\n c.then(|| x + 1)\n}\n\n// `then_some` is the eager sibling of `then`: it takes an already-evaluated\n// value rather than a closure, so the diamond's `then` arm wraps it in `Some`\n// directly (no `call_once`). Same Opaque-core-combinator residual shape.\n#[inline(never)]\npub fn bool_then_some(c: bool, x: i64) -> Option {\n c.then_some(x + 1)\n}\n\n// --- 7. Option question mark -------------------------------------------\n//\n// Exercises `Try::branch` on `Option`: `Some(v)` continues with `v`, while\n// `None` returns `None` normally from the enclosing Option-returning function.\n\n#[inline(never)]\nfn option_source(keep: bool, value: i64) -> Option {\n if keep { Some(value) } else { None }\n}\n\n#[inline(never)]\npub fn option_question_mark(keep: bool, value: i64, addend: i64) -> Option {\n let v = option_source(keep, value)?;\n Some(v + addend)\n}\n\n// ---------------------------------------------------------------------------\n// A host-registered callback table.\n// ---------------------------------------------------------------------------\n\n/// The callback a host installs at run time. A bare `fn` pointer, so the set\n/// of addresses that can reach a call through it is not recoverable from this\n/// artifact — the shape used by host-settable callback hooks.\npub type HostCallback = fn(i64) -> i64;\n\npub struct HostRegistry {\n pub slot: HostCallback,\n pub maybe_slot: Option,\n}\n\n/// Call through the registered callback. `front::mir` lowers this to\n/// `OpKind::IndirectCall { graphs: None }` — `indirect_call` with an\n/// unknown PBC family, which `guess_call_kind` answers `residual` for\n/// (`call.py:105`/`137`, `jtransform.py:410-412`). The `__dyn_call`\n/// placeholder it used to reach is an unregistered synthetic path with no\n/// continuation.\n#[inline(never)]\npub fn host_registry_dispatch(reg: &HostRegistry, x: i64) -> i64 {\n (reg.slot)(x)\n}\n\n/// The one-hop `Option` spelling of the same shape.\n#[inline(never)]\npub fn host_registry_dispatch_optional(reg: &HostRegistry, x: i64) -> i64 {\n match reg.maybe_slot {\n Some(f) => f(x),\n None => 0,\n }\n}\n"},{"id":1,"name":{"Local":"/rustc/library/core/src/marker.rs"},"crate_name":"core","contents":null},{"id":2,"name":{"Local":"/rustc/library/core/src/lib.rs"},"crate_name":"core","contents":null},{"id":3,"name":{"Local":"/rustc/library/core/src/result.rs"},"crate_name":"core","contents":null},{"id":4,"name":{"Local":"/rustc/library/core/src/slice/iter.rs"},"crate_name":"core","contents":null},{"id":5,"name":{"Local":"/rustc/library/core/src/slice/mod.rs"},"crate_name":"core","contents":null},{"id":6,"name":{"Local":"/rustc/library/core/src/option.rs"},"crate_name":"core","contents":null},{"id":7,"name":{"Local":"/rustc/library/core/src/slice/iter/macros.rs"},"crate_name":"core","contents":null},{"id":8,"name":{"Local":"/rustc/library/core/src/ops/control_flow.rs"},"crate_name":"core","contents":null},{"id":9,"name":{"Local":"/rustc/library/core/src/ops/mod.rs"},"crate_name":"core","contents":null},{"id":10,"name":{"Local":"/rustc/library/core/src/convert/mod.rs"},"crate_name":"core","contents":null},{"id":11,"name":{"Local":"/rustc/library/core/src/iter/traits/collect.rs"},"crate_name":"core","contents":null},{"id":12,"name":{"Local":"/rustc/library/core/src/iter/traits/mod.rs"},"crate_name":"core","contents":null},{"id":13,"name":{"Local":"/rustc/library/core/src/iter/mod.rs"},"crate_name":"core","contents":null},{"id":14,"name":{"Local":"/rustc/library/core/src/iter/traits/iterator.rs"},"crate_name":"core","contents":null},{"id":15,"name":{"Local":"/rustc/library/core/src/bool.rs"},"crate_name":"core","contents":null},{"id":16,"name":{"Local":"/rustc/library/core/src/ops/function.rs"},"crate_name":"core","contents":null},{"id":17,"name":{"Local":"/rustc/library/core/src/array/iter.rs"},"crate_name":"core","contents":null},{"id":18,"name":{"Local":"/rustc/library/core/src/array/mod.rs"},"crate_name":"core","contents":null},{"id":19,"name":{"Local":"/rustc/library/core/src/num/nonzero.rs"},"crate_name":"core","contents":null},{"id":20,"name":{"Local":"/rustc/library/core/src/num/mod.rs"},"crate_name":"core","contents":null},{"id":21,"name":{"Local":"/rustc/library/core/src/iter/adapters/step_by.rs"},"crate_name":"core","contents":null},{"id":22,"name":{"Local":"/rustc/library/core/src/iter/adapters/mod.rs"},"crate_name":"core","contents":null},{"id":23,"name":{"Local":"/rustc/library/core/src/iter/adapters/chain.rs"},"crate_name":"core","contents":null},{"id":24,"name":{"Local":"/rustc/library/core/src/iter/adapters/zip.rs"},"crate_name":"core","contents":null},{"id":25,"name":{"Local":"/rustc/library/core/src/clone.rs"},"crate_name":"core","contents":null},{"id":26,"name":{"Local":"/rustc/library/core/src/iter/adapters/intersperse.rs"},"crate_name":"core","contents":null},{"id":27,"name":{"Local":"/rustc/library/core/src/iter/adapters/map.rs"},"crate_name":"core","contents":null},{"id":28,"name":{"Local":"/rustc/library/core/src/iter/adapters/filter.rs"},"crate_name":"core","contents":null},{"id":29,"name":{"Local":"/rustc/library/core/src/iter/adapters/filter_map.rs"},"crate_name":"core","contents":null},{"id":30,"name":{"Local":"/rustc/library/core/src/iter/adapters/enumerate.rs"},"crate_name":"core","contents":null},{"id":31,"name":{"Local":"/rustc/library/core/src/iter/adapters/peekable.rs"},"crate_name":"core","contents":null},{"id":32,"name":{"Local":"/rustc/library/core/src/iter/adapters/skip_while.rs"},"crate_name":"core","contents":null},{"id":33,"name":{"Local":"/rustc/library/core/src/iter/adapters/take_while.rs"},"crate_name":"core","contents":null},{"id":34,"name":{"Local":"/rustc/library/core/src/iter/adapters/map_while.rs"},"crate_name":"core","contents":null},{"id":35,"name":{"Local":"/rustc/library/core/src/iter/adapters/skip.rs"},"crate_name":"core","contents":null},{"id":36,"name":{"Local":"/rustc/library/core/src/iter/adapters/take.rs"},"crate_name":"core","contents":null},{"id":37,"name":{"Local":"/rustc/library/core/src/iter/adapters/scan.rs"},"crate_name":"core","contents":null},{"id":38,"name":{"Local":"/rustc/library/core/src/iter/adapters/flatten.rs"},"crate_name":"core","contents":null},{"id":39,"name":{"Local":"/rustc/library/core/src/iter/adapters/map_windows.rs"},"crate_name":"core","contents":null},{"id":40,"name":{"Local":"/rustc/library/core/src/iter/adapters/fuse.rs"},"crate_name":"core","contents":null},{"id":41,"name":{"Local":"/rustc/library/core/src/iter/adapters/inspect.rs"},"crate_name":"core","contents":null},{"id":42,"name":{"Local":"/rustc/library/core/src/ops/try_trait.rs"},"crate_name":"core","contents":null},{"id":43,"name":{"Local":"/rustc/library/core/src/default.rs"},"crate_name":"core","contents":null},{"id":44,"name":{"Local":"/rustc/library/core/src/iter/traits/double_ended.rs"},"crate_name":"core","contents":null},{"id":45,"name":{"Local":"/rustc/library/core/src/iter/traits/exact_size.rs"},"crate_name":"core","contents":null},{"id":46,"name":{"Local":"/rustc/library/core/src/cmp.rs"},"crate_name":"core","contents":null},{"id":47,"name":{"Local":"/rustc/library/core/src/iter/adapters/rev.rs"},"crate_name":"core","contents":null},{"id":48,"name":{"Local":"/rustc/library/core/src/iter/adapters/copied.rs"},"crate_name":"core","contents":null},{"id":49,"name":{"Local":"/rustc/library/core/src/iter/adapters/cloned.rs"},"crate_name":"core","contents":null},{"id":50,"name":{"Local":"/rustc/library/core/src/iter/adapters/cycle.rs"},"crate_name":"core","contents":null},{"id":51,"name":{"Local":"/rustc/library/core/src/iter/adapters/array_chunks.rs"},"crate_name":"core","contents":null},{"id":52,"name":{"Local":"/rustc/library/core/src/iter/traits/accum.rs"},"crate_name":"core","contents":null},{"id":53,"name":{"Local":"/rustc/library/core/src/num/niche_types.rs"},"crate_name":"core","contents":null}],"item_names":[{"key":{"Type":0},"value":[{"Ident":["charon_corpus",0]},{"Ident":["PyResult",0]}]},{"key":{"Fun":0},"value":[{"Ident":["charon_corpus",0]},{"Ident":["straight_line_add",0]}]},{"key":{"Fun":1},"value":[{"Ident":["charon_corpus",0]},{"Ident":["branch_loop_sum",0]}]},{"key":{"Type":1},"value":[{"Ident":["charon_corpus",0]},{"Ident":["Strategy",0]}]},{"key":{"Fun":2},"value":[{"Ident":["charon_corpus",0]},{"Ident":["strategy_len",0]}]},{"key":{"Type":2},"value":[{"Ident":["charon_corpus",0]},{"Ident":["Token",0]}]},{"key":{"Fun":3},"value":[{"Ident":["charon_corpus",0]},{"Ident":["parse_one",0]}]},{"key":{"Fun":4},"value":[{"Ident":["charon_corpus",0]},{"Ident":["desugar_mix",0]}]},{"key":{"Fun":5},"value":[{"Ident":["charon_corpus",0]},{"Ident":["tuple_roundtrip",0]}]},{"key":{"Fun":6},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]}]},{"key":{"Fun":7},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_some",0]}]},{"key":{"Fun":8},"value":[{"Ident":["charon_corpus",0]},{"Ident":["option_source",0]}]},{"key":{"Fun":9},"value":[{"Ident":["charon_corpus",0]},{"Ident":["option_question_mark",0]}]},{"key":{"Type":3},"value":[{"Ident":["charon_corpus",0]},{"Ident":["HostCallback",0]}]},{"key":{"Type":4},"value":[{"Ident":["charon_corpus",0]},{"Ident":["HostRegistry",0]}]},{"key":{"Fun":10},"value":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch",0]}]},{"key":{"Fun":11},"value":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch_optional",0]}]},{"key":{"TraitDecl":0},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Sized",0]}]},{"key":{"Type":5},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Ident":["Result",0]}]},{"key":{"TraitDecl":1},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["MetaSized",0]}]},{"key":{"Type":6},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Ident":["Iter",0]}]},{"key":{"Type":7},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Ident":["Option",0]}]},{"key":{"TraitImpl":0},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}}]},{"key":{"Fun":12},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":1},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}}]},{"key":{"Fun":13},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["next",0]}]},{"key":{"Type":8},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["control_flow",0]},{"Ident":["ControlFlow",0]}]},{"key":{"Type":9},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["Infallible",0]}]},{"key":{"Fun":14},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":5,"beg":{"line":101,"col":5},"end":{"line":101,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[164,{"TypeVar":{"Bound":[1,0]}}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"HashConsedValue":[1063,{"Slice":{"HashConsedValue":[196,{"TypeVar":{"Bound":[0,0]}}]}}]},"kind":"InherentImplBlock"}}},{"Ident":["iter",0]}]},{"key":{"TraitImpl":2},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":2}}]},{"key":{"Fun":15},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":2}},{"Ident":["into_iter",0]}]},{"key":{"TraitDecl":2},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]}]},{"key":{"TraitImpl":3},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":3}}]},{"key":{"Fun":16},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":3}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":4},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":4}}]},{"key":{"Fun":17},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":4}},{"Ident":["from_residual",0]}]},{"key":{"TraitDecl":3},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]}]},{"key":{"TraitImpl":5},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":5}}]},{"key":{"Type":10},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]}]},{"key":{"TraitImpl":6},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":6}}]},{"key":{"Fun":18},"value":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"HashConsedValue":[211,{"Literal":"Bool"}]},"kind":"InherentImplBlock"}}},{"Ident":["then",0]}]},{"key":{"TraitDecl":4},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]}]},{"key":{"TraitDecl":5},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]}]},{"key":{"TraitImpl":7},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":7}}]},{"key":{"Fun":19},"value":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":211},"kind":"InherentImplBlock"}}},{"Ident":["then_some",0]}]},{"key":{"TraitImpl":8},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":8}}]},{"key":{"Fun":20},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":8}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":9},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":9}}]},{"key":{"Fun":21},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":9}},{"Ident":["from_residual",0]}]},{"key":{"Type":11},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["MetaSized",0]},{"Ident":["{vtable}",0]}]},{"key":{"TraitDecl":6},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]}]},{"key":{"Global":0},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}},{"Ident":["{vtable}",0]}]},{"key":{"Global":1},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":22},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["next_chunk",0]}]},{"key":{"Fun":23},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["size_hint",0]}]},{"key":{"Fun":24},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["count",0]}]},{"key":{"Fun":25},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["last",0]}]},{"key":{"Fun":26},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["advance_by",0]}]},{"key":{"Fun":27},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["nth",0]}]},{"key":{"Fun":28},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["step_by",0]}]},{"key":{"Type":12},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":29},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["next",0]}]},{"key":{"Fun":30},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["next_chunk",0]}]},{"key":{"Type":13},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]}]},{"key":{"Fun":31},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["size_hint",0]}]},{"key":{"Fun":32},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["count",0]}]},{"key":{"Fun":33},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["last",0]}]},{"key":{"Fun":34},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["advance_by",0]}]},{"key":{"Type":14},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["NonZero",0]}]},{"key":{"TraitDecl":7},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["ZeroablePrimitive",0]}]},{"key":{"TraitImpl":10},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":10}}]},{"key":{"Fun":35},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["nth",0]}]},{"key":{"Fun":36},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["step_by",0]}]},{"key":{"Type":15},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["step_by",0]},{"Ident":["StepBy",0]}]},{"key":{"Fun":37},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["chain",0]}]},{"key":{"Type":16},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["chain",0]},{"Ident":["Chain",0]}]},{"key":{"Fun":38},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["zip",0]}]},{"key":{"Type":17},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["Zip",0]}]},{"key":{"Fun":39},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["intersperse",0]}]},{"key":{"TraitDecl":8},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]}]},{"key":{"Type":18},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["Intersperse",0]}]},{"key":{"Fun":40},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["intersperse_with",0]}]},{"key":{"TraitDecl":9},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]}]},{"key":{"Type":19},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["IntersperseWith",0]}]},{"key":{"Fun":41},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["map",0]}]},{"key":{"Type":20},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map",0]},{"Ident":["Map",0]}]},{"key":{"Fun":42},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["for_each",0]}]},{"key":{"Fun":43},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["filter",0]}]},{"key":{"Type":21},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter",0]},{"Ident":["Filter",0]}]},{"key":{"Fun":44},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["filter_map",0]}]},{"key":{"Type":22},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter_map",0]},{"Ident":["FilterMap",0]}]},{"key":{"Fun":45},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["enumerate",0]}]},{"key":{"Type":23},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["enumerate",0]},{"Ident":["Enumerate",0]}]},{"key":{"Fun":46},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["peekable",0]}]},{"key":{"Type":24},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["peekable",0]},{"Ident":["Peekable",0]}]},{"key":{"Fun":47},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["skip_while",0]}]},{"key":{"Type":25},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip_while",0]},{"Ident":["SkipWhile",0]}]},{"key":{"Fun":48},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["take_while",0]}]},{"key":{"Type":26},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take_while",0]},{"Ident":["TakeWhile",0]}]},{"key":{"Fun":49},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["map_while",0]}]},{"key":{"Type":27},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_while",0]},{"Ident":["MapWhile",0]}]},{"key":{"Fun":50},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["skip",0]}]},{"key":{"Type":28},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip",0]},{"Ident":["Skip",0]}]},{"key":{"Fun":51},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["take",0]}]},{"key":{"Type":29},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take",0]},{"Ident":["Take",0]}]},{"key":{"Fun":52},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["scan",0]}]},{"key":{"Type":30},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["scan",0]},{"Ident":["Scan",0]}]},{"key":{"Fun":53},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["flat_map",0]}]},{"key":{"Type":31},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["FlatMap",0]}]},{"key":{"Fun":54},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["flatten",0]}]},{"key":{"Type":32},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["Flatten",0]}]},{"key":{"Fun":55},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["map_windows",0]}]},{"key":{"Type":33},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_windows",0]},{"Ident":["MapWindows",0]}]},{"key":{"Fun":56},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["fuse",0]}]},{"key":{"Type":34},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["fuse",0]},{"Ident":["Fuse",0]}]},{"key":{"Fun":57},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["inspect",0]}]},{"key":{"Type":35},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["inspect",0]},{"Ident":["Inspect",0]}]},{"key":{"Fun":58},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["by_ref",0]}]},{"key":{"Fun":59},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["collect",0]}]},{"key":{"TraitDecl":10},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]}]},{"key":{"Fun":60},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_collect",0]}]},{"key":{"TraitDecl":11},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]}]},{"key":{"TraitDecl":12},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Residual",0]}]},{"key":{"Fun":61},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["collect_into",0]}]},{"key":{"TraitDecl":13},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]}]},{"key":{"Fun":62},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partition",0]}]},{"key":{"TraitDecl":14},"value":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]}]},{"key":{"Fun":63},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partition_in_place",0]}]},{"key":{"TraitDecl":15},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]}]},{"key":{"Fun":64},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":65},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_fold",0]}]},{"key":{"Fun":66},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_for_each",0]}]},{"key":{"Fun":67},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["fold",0]}]},{"key":{"Fun":68},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["reduce",0]}]},{"key":{"Fun":69},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_reduce",0]}]},{"key":{"Fun":70},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["all",0]}]},{"key":{"Fun":71},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["any",0]}]},{"key":{"Fun":72},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["find",0]}]},{"key":{"Fun":73},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["find_map",0]}]},{"key":{"Fun":74},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_find",0]}]},{"key":{"Fun":75},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["position",0]}]},{"key":{"Fun":76},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["rposition",0]}]},{"key":{"TraitDecl":16},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]}]},{"key":{"Fun":77},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["max",0]}]},{"key":{"TraitDecl":17},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]}]},{"key":{"Fun":78},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["min",0]}]},{"key":{"Fun":79},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["max_by_key",0]}]},{"key":{"Fun":80},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["max_by",0]}]},{"key":{"Type":36},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ordering",0]}]},{"key":{"Fun":81},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["min_by_key",0]}]},{"key":{"Fun":82},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["min_by",0]}]},{"key":{"Fun":83},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["rev",0]}]},{"key":{"Type":37},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["rev",0]},{"Ident":["Rev",0]}]},{"key":{"Fun":84},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["unzip",0]}]},{"key":{"Fun":85},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["copied",0]}]},{"key":{"TraitDecl":18},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Copy",0]}]},{"key":{"Type":38},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["copied",0]},{"Ident":["Copied",0]}]},{"key":{"Fun":86},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cloned",0]}]},{"key":{"Type":39},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cloned",0]},{"Ident":["Cloned",0]}]},{"key":{"Fun":87},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cycle",0]}]},{"key":{"Type":40},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cycle",0]},{"Ident":["Cycle",0]}]},{"key":{"Fun":88},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["array_chunks",0]}]},{"key":{"Type":41},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["array_chunks",0]},{"Ident":["ArrayChunks",0]}]},{"key":{"Fun":89},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["sum",0]}]},{"key":{"TraitDecl":19},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]}]},{"key":{"Fun":90},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["product",0]}]},{"key":{"TraitDecl":20},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]}]},{"key":{"Fun":91},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cmp",0]}]},{"key":{"Fun":92},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cmp_by",0]}]},{"key":{"Fun":93},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partial_cmp",0]}]},{"key":{"TraitDecl":21},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]}]},{"key":{"Fun":94},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":95},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["eq",0]}]},{"key":{"TraitDecl":22},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]}]},{"key":{"Fun":96},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["eq_by",0]}]},{"key":{"Fun":97},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["ne",0]}]},{"key":{"Fun":98},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["lt",0]}]},{"key":{"Fun":99},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["le",0]}]},{"key":{"Fun":100},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["gt",0]}]},{"key":{"Fun":101},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["ge",0]}]},{"key":{"Fun":102},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_sorted",0]}]},{"key":{"Fun":103},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":104},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":105},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"TraitDecl":23},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["TrustedRandomAccessNoCoerce",0]}]},{"key":{"Fun":106},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["chain",0]}]},{"key":{"Fun":107},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["zip",0]}]},{"key":{"Fun":108},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["intersperse",0]}]},{"key":{"Fun":109},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["intersperse_with",0]}]},{"key":{"Fun":110},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["map",0]}]},{"key":{"Fun":111},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["for_each",0]}]},{"key":{"Fun":112},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["filter",0]}]},{"key":{"Fun":113},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["filter_map",0]}]},{"key":{"Fun":114},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["enumerate",0]}]},{"key":{"Fun":115},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["peekable",0]}]},{"key":{"Fun":116},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["skip_while",0]}]},{"key":{"Fun":117},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["take_while",0]}]},{"key":{"Fun":118},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["map_while",0]}]},{"key":{"Fun":119},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["skip",0]}]},{"key":{"Fun":120},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["take",0]}]},{"key":{"Fun":121},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["scan",0]}]},{"key":{"Fun":122},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["flat_map",0]}]},{"key":{"Fun":123},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["flatten",0]}]},{"key":{"Fun":124},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["map_windows",0]}]},{"key":{"Fun":125},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["fuse",0]}]},{"key":{"Fun":126},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["inspect",0]}]},{"key":{"Fun":127},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["by_ref",0]}]},{"key":{"Fun":128},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["collect",0]}]},{"key":{"Fun":129},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_collect",0]}]},{"key":{"Fun":130},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["collect_into",0]}]},{"key":{"Fun":131},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partition",0]}]},{"key":{"Fun":132},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partition_in_place",0]}]},{"key":{"Fun":133},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":134},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_fold",0]}]},{"key":{"Fun":135},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_for_each",0]}]},{"key":{"Fun":136},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["fold",0]}]},{"key":{"Fun":137},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["reduce",0]}]},{"key":{"Fun":138},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_reduce",0]}]},{"key":{"Fun":139},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["all",0]}]},{"key":{"Fun":140},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["any",0]}]},{"key":{"Fun":141},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["find",0]}]},{"key":{"Fun":142},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["find_map",0]}]},{"key":{"Fun":143},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_find",0]}]},{"key":{"Fun":144},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["position",0]}]},{"key":{"Fun":145},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["rposition",0]}]},{"key":{"Fun":146},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["max",0]}]},{"key":{"Fun":147},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["min",0]}]},{"key":{"Fun":148},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["max_by_key",0]}]},{"key":{"Fun":149},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["max_by",0]}]},{"key":{"Fun":150},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["min_by_key",0]}]},{"key":{"Fun":151},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["min_by",0]}]},{"key":{"Fun":152},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["rev",0]}]},{"key":{"Fun":153},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["unzip",0]}]},{"key":{"Fun":154},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["copied",0]}]},{"key":{"Fun":155},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cloned",0]}]},{"key":{"Fun":156},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cycle",0]}]},{"key":{"Fun":157},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["array_chunks",0]}]},{"key":{"Fun":158},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["sum",0]}]},{"key":{"Fun":159},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["product",0]}]},{"key":{"Fun":160},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cmp",0]}]},{"key":{"Fun":161},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cmp_by",0]}]},{"key":{"Fun":162},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":163},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":164},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["eq",0]}]},{"key":{"Fun":165},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["eq_by",0]}]},{"key":{"Fun":166},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["ne",0]}]},{"key":{"Fun":167},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["lt",0]}]},{"key":{"Fun":168},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["le",0]}]},{"key":{"Fun":169},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["gt",0]}]},{"key":{"Fun":170},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["ge",0]}]},{"key":{"Fun":171},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_sorted",0]}]},{"key":{"Fun":172},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":173},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":174},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"Global":2},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":2}},{"Ident":["{vtable}",0]}]},{"key":{"TraitDecl":24},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]}]},{"key":{"Fun":175},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":3}},{"Ident":["from_output",0]}]},{"key":{"Fun":176},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]},{"Ident":["from",0]}]},{"key":{"Fun":177},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":5}},{"Ident":["from",0]}]},{"key":{"TraitDecl":25},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Tuple",0]}]},{"key":{"Fun":178},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":6}},{"Ident":["call_once",0]}]},{"key":{"Type":42},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":179},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]},{"Ident":["call_once",0]}]},{"key":{"Fun":180},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]},{"Ident":["drop_in_place",0]}]},{"key":{"Fun":181},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":7}},{"Ident":["drop_in_place",0]}]},{"key":{"Fun":182},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":8}},{"Ident":["from_output",0]}]},{"key":{"Type":43},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":183},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]},{"Ident":["into_iter",0]}]},{"key":{"TraitDecl":26},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["private",0]},{"Ident":["Sealed",0]}]},{"key":{"TraitImpl":11},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Impl":{"Trait":11}}]},{"key":{"TraitImpl":12},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":12}}]},{"key":{"Type":44},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Ident":["NonZeroUsizeInner",0]}]},{"key":{"TraitImpl":13},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":13}}]},{"key":{"Fun":184},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]},{"Ident":["clone",0]}]},{"key":{"Fun":185},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]},{"Ident":["clone_from",0]}]},{"key":{"Type":45},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":186},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]},{"Ident":["call_mut",0]}]},{"key":{"Fun":187},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]},{"Ident":["from_iter",0]}]},{"key":{"Fun":188},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["from_output",0]}]},{"key":{"Fun":189},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["branch",0]}]},{"key":{"Fun":190},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend",0]}]},{"key":{"Fun":191},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend_one",0]}]},{"key":{"Fun":192},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend_reserve",0]}]},{"key":{"Fun":193},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend_one_unchecked",0]}]},{"key":{"Fun":194},"value":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]},{"Ident":["default",0]}]},{"key":{"Type":46},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":195},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["next_back",0]}]},{"key":{"Fun":196},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["advance_back_by",0]}]},{"key":{"Fun":197},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["nth_back",0]}]},{"key":{"Fun":198},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["try_rfold",0]}]},{"key":{"Fun":199},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["rfold",0]}]},{"key":{"Fun":200},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["rfind",0]}]},{"key":{"Type":47},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":201},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]},{"Ident":["len",0]}]},{"key":{"Fun":202},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]},{"Ident":["is_empty",0]}]},{"key":{"TraitDecl":27},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Eq",0]}]},{"key":{"Fun":203},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["cmp",0]}]},{"key":{"Fun":204},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["max",0]}]},{"key":{"Fun":205},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["min",0]}]},{"key":{"Fun":206},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["clamp",0]}]},{"key":{"Fun":207},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]},{"Ident":["sum",0]}]},{"key":{"Fun":208},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]},{"Ident":["product",0]}]},{"key":{"Type":48},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":209},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":210},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["lt",0]}]},{"key":{"Fun":211},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["le",0]}]},{"key":{"Fun":212},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["gt",0]}]},{"key":{"Fun":213},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["ge",0]}]},{"key":{"Fun":214},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_lt",0]}]},{"key":{"Fun":215},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_le",0]}]},{"key":{"Fun":216},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_gt",0]}]},{"key":{"Fun":217},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_ge",0]}]},{"key":{"Type":49},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":218},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["eq",0]}]},{"key":{"Fun":219},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["ne",0]}]},{"key":{"Fun":220},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["TrustedRandomAccessNoCoerce",0]},{"Ident":["size",0]}]},{"key":{"Fun":221},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]},{"Ident":["from_residual",0]}]},{"key":{"Type":50},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["private",0]},{"Ident":["Sealed",0]},{"Ident":["{vtable}",0]}]},{"key":{"TraitImpl":14},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":14}}]},{"key":{"Global":3},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":12}},{"Ident":["{vtable}",0]}]},{"key":{"TraitImpl":15},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":15}}]},{"key":{"Fun":222},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Eq",0]},{"Ident":["assert_receiver_is_total_eq",0]}]},{"key":{"Fun":223},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":14}},{"Ident":["clone",0]}]},{"key":{"Fun":224},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":14}},{"Ident":["clone_from",0]}]},{"key":{"Fun":225},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":15}},{"Ident":["clone",0]}]},{"key":{"Fun":226},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":15}},{"Ident":["clone_from",0]}]}],"assoc_item_names":[{"types":[],"methods":[],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":["Item"],"methods":["next","next_chunk","size_hint","count","last","advance_by","nth","step_by","chain","zip","intersperse","intersperse_with","map","for_each","filter","filter_map","enumerate","peekable","skip_while","take_while","map_while","skip","take","scan","flat_map","flatten","map_windows","fuse","inspect","by_ref","collect","try_collect","collect_into","partition","partition_in_place","is_partitioned","try_fold","try_for_each","fold","reduce","try_reduce","all","any","find","find_map","try_find","position","rposition","max","min","max_by_key","max_by","min_by_key","min_by","rev","unzip","copied","cloned","cycle","array_chunks","sum","product","cmp","cmp_by","partial_cmp","partial_cmp_by","eq","eq_by","ne","lt","le","gt","ge","is_sorted","is_sorted_by","is_sorted_by_key","__iterator_get_unchecked"],"consts":[]},{"types":[],"methods":["from"],"consts":[]},{"types":["Output"],"methods":["call_once"],"consts":[]},{"types":[],"methods":["drop_in_place"],"consts":[]},{"types":["Item","IntoIter"],"methods":["into_iter"],"consts":[]},{"types":["NonZeroInner"],"methods":[],"consts":[]},{"types":[],"methods":["clone","clone_from"],"consts":[]},{"types":[],"methods":["call_mut"],"consts":[]},{"types":[],"methods":["from_iter"],"consts":[]},{"types":["Output","Residual"],"methods":["from_output","branch"],"consts":[]},{"types":["TryType"],"methods":[],"consts":[]},{"types":[],"methods":["extend","extend_one","extend_reserve","extend_one_unchecked"],"consts":[]},{"types":[],"methods":["default"],"consts":[]},{"types":[],"methods":["next_back","advance_back_by","nth_back","try_rfold","rfold","rfind"],"consts":[]},{"types":[],"methods":["len","is_empty"],"consts":[]},{"types":[],"methods":["cmp","max","min","clamp"],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":["sum"],"consts":[]},{"types":[],"methods":["product"],"consts":[]},{"types":[],"methods":["partial_cmp","lt","le","gt","ge","__chaining_lt","__chaining_le","__chaining_gt","__chaining_ge"],"consts":[]},{"types":[],"methods":["eq","ne"],"consts":[]},{"types":[],"methods":["size"],"consts":["MAY_HAVE_SIDE_EFFECT"]},{"types":[],"methods":["from_residual"],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":["assert_receiver_is_total_eq"],"consts":[]}],"short_names":[{"key":{"TraitImpl":0},"value":[{"Impl":{"Trait":0}}]},{"key":{"Fun":12},"value":[{"Impl":{"Trait":0}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":1},"value":[{"Impl":{"Trait":1}}]},{"key":{"Fun":13},"value":[{"Impl":{"Trait":1}},{"Ident":["next",0]}]},{"key":{"TraitImpl":2},"value":[{"Impl":{"Trait":2}}]},{"key":{"Fun":15},"value":[{"Impl":{"Trait":2}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":3},"value":[{"Impl":{"Trait":3}}]},{"key":{"Fun":16},"value":[{"Impl":{"Trait":3}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":4},"value":[{"Impl":{"Trait":4}}]},{"key":{"Fun":17},"value":[{"Impl":{"Trait":4}},{"Ident":["from_residual",0]}]},{"key":{"TraitImpl":5},"value":[{"Impl":{"Trait":5}}]},{"key":{"TraitImpl":6},"value":[{"Impl":{"Trait":6}}]},{"key":{"TraitImpl":7},"value":[{"Impl":{"Trait":7}}]},{"key":{"TraitImpl":8},"value":[{"Impl":{"Trait":8}}]},{"key":{"Fun":20},"value":[{"Impl":{"Trait":8}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":9},"value":[{"Impl":{"Trait":9}}]},{"key":{"Fun":21},"value":[{"Impl":{"Trait":9}},{"Ident":["from_residual",0]}]},{"key":{"Global":0},"value":[{"Impl":{"Trait":0}},{"Ident":["{vtable}",0]}]},{"key":{"Global":1},"value":[{"Impl":{"Trait":1}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":22},"value":[{"Impl":{"Trait":1}},{"Ident":["next_chunk",0]}]},{"key":{"Fun":23},"value":[{"Impl":{"Trait":1}},{"Ident":["size_hint",0]}]},{"key":{"Fun":24},"value":[{"Impl":{"Trait":1}},{"Ident":["count",0]}]},{"key":{"Fun":25},"value":[{"Impl":{"Trait":1}},{"Ident":["last",0]}]},{"key":{"Fun":26},"value":[{"Impl":{"Trait":1}},{"Ident":["advance_by",0]}]},{"key":{"Fun":27},"value":[{"Impl":{"Trait":1}},{"Ident":["nth",0]}]},{"key":{"Fun":28},"value":[{"Impl":{"Trait":1}},{"Ident":["step_by",0]}]},{"key":{"TraitImpl":10},"value":[{"Impl":{"Trait":10}}]},{"key":{"Fun":106},"value":[{"Impl":{"Trait":1}},{"Ident":["chain",0]}]},{"key":{"Fun":107},"value":[{"Impl":{"Trait":1}},{"Ident":["zip",0]}]},{"key":{"Fun":108},"value":[{"Impl":{"Trait":1}},{"Ident":["intersperse",0]}]},{"key":{"Fun":109},"value":[{"Impl":{"Trait":1}},{"Ident":["intersperse_with",0]}]},{"key":{"Fun":110},"value":[{"Impl":{"Trait":1}},{"Ident":["map",0]}]},{"key":{"Fun":111},"value":[{"Impl":{"Trait":1}},{"Ident":["for_each",0]}]},{"key":{"Fun":112},"value":[{"Impl":{"Trait":1}},{"Ident":["filter",0]}]},{"key":{"Fun":113},"value":[{"Impl":{"Trait":1}},{"Ident":["filter_map",0]}]},{"key":{"Fun":114},"value":[{"Impl":{"Trait":1}},{"Ident":["enumerate",0]}]},{"key":{"Fun":115},"value":[{"Impl":{"Trait":1}},{"Ident":["peekable",0]}]},{"key":{"Fun":116},"value":[{"Impl":{"Trait":1}},{"Ident":["skip_while",0]}]},{"key":{"Fun":117},"value":[{"Impl":{"Trait":1}},{"Ident":["take_while",0]}]},{"key":{"Fun":118},"value":[{"Impl":{"Trait":1}},{"Ident":["map_while",0]}]},{"key":{"Fun":119},"value":[{"Impl":{"Trait":1}},{"Ident":["skip",0]}]},{"key":{"Fun":120},"value":[{"Impl":{"Trait":1}},{"Ident":["take",0]}]},{"key":{"Fun":121},"value":[{"Impl":{"Trait":1}},{"Ident":["scan",0]}]},{"key":{"Fun":122},"value":[{"Impl":{"Trait":1}},{"Ident":["flat_map",0]}]},{"key":{"Fun":123},"value":[{"Impl":{"Trait":1}},{"Ident":["flatten",0]}]},{"key":{"Fun":124},"value":[{"Impl":{"Trait":1}},{"Ident":["map_windows",0]}]},{"key":{"Fun":125},"value":[{"Impl":{"Trait":1}},{"Ident":["fuse",0]}]},{"key":{"Fun":126},"value":[{"Impl":{"Trait":1}},{"Ident":["inspect",0]}]},{"key":{"Fun":127},"value":[{"Impl":{"Trait":1}},{"Ident":["by_ref",0]}]},{"key":{"Fun":128},"value":[{"Impl":{"Trait":1}},{"Ident":["collect",0]}]},{"key":{"Fun":129},"value":[{"Impl":{"Trait":1}},{"Ident":["try_collect",0]}]},{"key":{"Fun":130},"value":[{"Impl":{"Trait":1}},{"Ident":["collect_into",0]}]},{"key":{"Fun":131},"value":[{"Impl":{"Trait":1}},{"Ident":["partition",0]}]},{"key":{"Fun":132},"value":[{"Impl":{"Trait":1}},{"Ident":["partition_in_place",0]}]},{"key":{"Fun":133},"value":[{"Impl":{"Trait":1}},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":134},"value":[{"Impl":{"Trait":1}},{"Ident":["try_fold",0]}]},{"key":{"Fun":135},"value":[{"Impl":{"Trait":1}},{"Ident":["try_for_each",0]}]},{"key":{"Fun":136},"value":[{"Impl":{"Trait":1}},{"Ident":["fold",0]}]},{"key":{"Fun":137},"value":[{"Impl":{"Trait":1}},{"Ident":["reduce",0]}]},{"key":{"Fun":138},"value":[{"Impl":{"Trait":1}},{"Ident":["try_reduce",0]}]},{"key":{"Fun":139},"value":[{"Impl":{"Trait":1}},{"Ident":["all",0]}]},{"key":{"Fun":140},"value":[{"Impl":{"Trait":1}},{"Ident":["any",0]}]},{"key":{"Fun":141},"value":[{"Impl":{"Trait":1}},{"Ident":["find",0]}]},{"key":{"Fun":142},"value":[{"Impl":{"Trait":1}},{"Ident":["find_map",0]}]},{"key":{"Fun":143},"value":[{"Impl":{"Trait":1}},{"Ident":["try_find",0]}]},{"key":{"Fun":144},"value":[{"Impl":{"Trait":1}},{"Ident":["position",0]}]},{"key":{"Fun":145},"value":[{"Impl":{"Trait":1}},{"Ident":["rposition",0]}]},{"key":{"Fun":146},"value":[{"Impl":{"Trait":1}},{"Ident":["max",0]}]},{"key":{"Fun":147},"value":[{"Impl":{"Trait":1}},{"Ident":["min",0]}]},{"key":{"Fun":148},"value":[{"Impl":{"Trait":1}},{"Ident":["max_by_key",0]}]},{"key":{"Fun":149},"value":[{"Impl":{"Trait":1}},{"Ident":["max_by",0]}]},{"key":{"Fun":150},"value":[{"Impl":{"Trait":1}},{"Ident":["min_by_key",0]}]},{"key":{"Fun":151},"value":[{"Impl":{"Trait":1}},{"Ident":["min_by",0]}]},{"key":{"Fun":152},"value":[{"Impl":{"Trait":1}},{"Ident":["rev",0]}]},{"key":{"Fun":153},"value":[{"Impl":{"Trait":1}},{"Ident":["unzip",0]}]},{"key":{"Fun":154},"value":[{"Impl":{"Trait":1}},{"Ident":["copied",0]}]},{"key":{"Fun":155},"value":[{"Impl":{"Trait":1}},{"Ident":["cloned",0]}]},{"key":{"Fun":156},"value":[{"Impl":{"Trait":1}},{"Ident":["cycle",0]}]},{"key":{"Fun":157},"value":[{"Impl":{"Trait":1}},{"Ident":["array_chunks",0]}]},{"key":{"Fun":158},"value":[{"Impl":{"Trait":1}},{"Ident":["sum",0]}]},{"key":{"Fun":159},"value":[{"Impl":{"Trait":1}},{"Ident":["product",0]}]},{"key":{"Fun":160},"value":[{"Impl":{"Trait":1}},{"Ident":["cmp",0]}]},{"key":{"Fun":161},"value":[{"Impl":{"Trait":1}},{"Ident":["cmp_by",0]}]},{"key":{"Fun":162},"value":[{"Impl":{"Trait":1}},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":163},"value":[{"Impl":{"Trait":1}},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":164},"value":[{"Impl":{"Trait":1}},{"Ident":["eq",0]}]},{"key":{"Fun":165},"value":[{"Impl":{"Trait":1}},{"Ident":["eq_by",0]}]},{"key":{"Fun":166},"value":[{"Impl":{"Trait":1}},{"Ident":["ne",0]}]},{"key":{"Fun":167},"value":[{"Impl":{"Trait":1}},{"Ident":["lt",0]}]},{"key":{"Fun":168},"value":[{"Impl":{"Trait":1}},{"Ident":["le",0]}]},{"key":{"Fun":169},"value":[{"Impl":{"Trait":1}},{"Ident":["gt",0]}]},{"key":{"Fun":170},"value":[{"Impl":{"Trait":1}},{"Ident":["ge",0]}]},{"key":{"Fun":171},"value":[{"Impl":{"Trait":1}},{"Ident":["is_sorted",0]}]},{"key":{"Fun":172},"value":[{"Impl":{"Trait":1}},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":173},"value":[{"Impl":{"Trait":1}},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":174},"value":[{"Impl":{"Trait":1}},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"Global":2},"value":[{"Impl":{"Trait":2}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":175},"value":[{"Impl":{"Trait":3}},{"Ident":["from_output",0]}]},{"key":{"Fun":177},"value":[{"Impl":{"Trait":5}},{"Ident":["from",0]}]},{"key":{"Fun":178},"value":[{"Impl":{"Trait":6}},{"Ident":["call_once",0]}]},{"key":{"Fun":181},"value":[{"Impl":{"Trait":7}},{"Ident":["drop_in_place",0]}]},{"key":{"Fun":182},"value":[{"Impl":{"Trait":8}},{"Ident":["from_output",0]}]},{"key":{"TraitImpl":11},"value":[{"Impl":{"Trait":11}}]},{"key":{"TraitImpl":12},"value":[{"Impl":{"Trait":12}}]},{"key":{"TraitImpl":13},"value":[{"Impl":{"Trait":13}}]},{"key":{"TraitImpl":14},"value":[{"Impl":{"Trait":14}}]},{"key":{"Global":3},"value":[{"Impl":{"Trait":12}},{"Ident":["{vtable}",0]}]},{"key":{"TraitImpl":15},"value":[{"Impl":{"Trait":15}}]},{"key":{"Fun":223},"value":[{"Impl":{"Trait":14}},{"Ident":["clone",0]}]},{"key":{"Fun":224},"value":[{"Impl":{"Trait":14}},{"Ident":["clone_from",0]}]},{"key":{"Fun":225},"value":[{"Impl":{"Trait":15}},{"Ident":["clone",0]}]},{"key":{"Fun":226},"value":[{"Impl":{"Trait":15}},{"Ident":["clone_from",0]}]},{"key":{"Type":6},"value":[{"Ident":["Iter",0]}]},{"key":{"Type":5},"value":[{"Ident":["Result",0]}]},{"key":{"TraitDecl":9},"value":[{"Ident":["FnMut",0]}]},{"key":{"TraitDecl":19},"value":[{"Ident":["Sum",0]}]},{"key":{"Fun":192},"value":[{"Ident":["extend_reserve",0]}]},{"key":{"Fun":1},"value":[{"Ident":["branch_loop_sum",0]}]},{"key":{"Type":40},"value":[{"Ident":["Cycle",0]}]},{"key":{"TraitDecl":22},"value":[{"Ident":["PartialEq",0]}]},{"key":{"Type":31},"value":[{"Ident":["FlatMap",0]}]},{"key":{"Type":23},"value":[{"Ident":["Enumerate",0]}]},{"key":{"Fun":197},"value":[{"Ident":["nth_back",0]}]},{"key":{"Fun":222},"value":[{"Ident":["assert_receiver_is_total_eq",0]}]},{"key":{"Type":39},"value":[{"Ident":["Cloned",0]}]},{"key":{"TraitDecl":15},"value":[{"Ident":["DoubleEndedIterator",0]}]},{"key":{"TraitDecl":20},"value":[{"Ident":["Product",0]}]},{"key":{"Fun":18},"value":[{"Ident":["then",0]}]},{"key":{"Type":9},"value":[{"Ident":["Infallible",0]}]},{"key":{"Type":36},"value":[{"Ident":["Ordering",0]}]},{"key":{"Fun":6},"value":[{"Ident":["bool_then_closure",0]}]},{"key":{"TraitDecl":5},"value":[{"Ident":["Destruct",0]}]},{"key":{"Type":2},"value":[{"Ident":["Token",0]}]},{"key":{"Fun":11},"value":[{"Ident":["host_registry_dispatch_optional",0]}]},{"key":{"Type":20},"value":[{"Ident":["Map",0]}]},{"key":{"Type":18},"value":[{"Ident":["Intersperse",0]}]},{"key":{"Fun":196},"value":[{"Ident":["advance_back_by",0]}]},{"key":{"Type":17},"value":[{"Ident":["Zip",0]}]},{"key":{"Type":7},"value":[{"Ident":["Option",0]}]},{"key":{"Type":38},"value":[{"Ident":["Copied",0]}]},{"key":{"Type":35},"value":[{"Ident":["Inspect",0]}]},{"key":{"Type":41},"value":[{"Ident":["ArrayChunks",0]}]},{"key":{"Fun":206},"value":[{"Ident":["clamp",0]}]},{"key":{"Type":10},"value":[{"Ident":["closure",0]}]},{"key":{"Fun":198},"value":[{"Ident":["try_rfold",0]}]},{"key":{"Fun":214},"value":[{"Ident":["__chaining_lt",0]}]},{"key":{"Type":32},"value":[{"Ident":["Flatten",0]}]},{"key":{"TraitDecl":10},"value":[{"Ident":["FromIterator",0]}]},{"key":{"Type":13},"value":[{"Ident":["IntoIter",0]}]},{"key":{"Type":16},"value":[{"Ident":["Chain",0]}]},{"key":{"Fun":217},"value":[{"Ident":["__chaining_ge",0]}]},{"key":{"Type":21},"value":[{"Ident":["Filter",0]}]},{"key":{"Fun":10},"value":[{"Ident":["host_registry_dispatch",0]}]},{"key":{"Type":25},"value":[{"Ident":["SkipWhile",0]}]},{"key":{"Type":30},"value":[{"Ident":["Scan",0]}]},{"key":{"TraitDecl":23},"value":[{"Ident":["TrustedRandomAccessNoCoerce",0]}]},{"key":{"TraitDecl":24},"value":[{"Ident":["FromResidual",0]}]},{"key":{"Type":14},"value":[{"Ident":["NonZero",0]}]},{"key":{"Fun":9},"value":[{"Ident":["option_question_mark",0]}]},{"key":{"TraitDecl":7},"value":[{"Ident":["ZeroablePrimitive",0]}]},{"key":{"Type":24},"value":[{"Ident":["Peekable",0]}]},{"key":{"Fun":215},"value":[{"Ident":["__chaining_le",0]}]},{"key":{"Fun":2},"value":[{"Ident":["strategy_len",0]}]},{"key":{"TraitDecl":18},"value":[{"Ident":["Copy",0]}]},{"key":{"Fun":200},"value":[{"Ident":["rfind",0]}]},{"key":{"Fun":220},"value":[{"Ident":["size",0]}]},{"key":{"TraitDecl":17},"value":[{"Ident":["Ord",0]}]},{"key":{"TraitDecl":21},"value":[{"Ident":["PartialOrd",0]}]},{"key":{"Type":0},"value":[{"Ident":["PyResult",0]}]},{"key":{"Type":34},"value":[{"Ident":["Fuse",0]}]},{"key":{"Fun":4},"value":[{"Ident":["desugar_mix",0]}]},{"key":{"TraitDecl":12},"value":[{"Ident":["Residual",0]}]},{"key":{"TraitDecl":6},"value":[{"Ident":["IntoIterator",0]}]},{"key":{"Type":22},"value":[{"Ident":["FilterMap",0]}]},{"key":{"TraitDecl":14},"value":[{"Ident":["Default",0]}]},{"key":{"Fun":199},"value":[{"Ident":["rfold",0]}]},{"key":{"TraitDecl":8},"value":[{"Ident":["Clone",0]}]},{"key":{"Fun":19},"value":[{"Ident":["then_some",0]}]},{"key":{"TraitDecl":11},"value":[{"Ident":["Try",0]}]},{"key":{"TraitDecl":0},"value":[{"Ident":["Sized",0]}]},{"key":{"Type":33},"value":[{"Ident":["MapWindows",0]}]},{"key":{"Fun":193},"value":[{"Ident":["extend_one_unchecked",0]}]},{"key":{"Type":44},"value":[{"Ident":["NonZeroUsizeInner",0]}]},{"key":{"Fun":195},"value":[{"Ident":["next_back",0]}]},{"key":{"Fun":202},"value":[{"Ident":["is_empty",0]}]},{"key":{"TraitDecl":27},"value":[{"Ident":["Eq",0]}]},{"key":{"Type":1},"value":[{"Ident":["Strategy",0]}]},{"key":{"Type":27},"value":[{"Ident":["MapWhile",0]}]},{"key":{"TraitDecl":1},"value":[{"Ident":["MetaSized",0]}]},{"key":{"Type":8},"value":[{"Ident":["ControlFlow",0]}]},{"key":{"Fun":14},"value":[{"Ident":["iter",0]}]},{"key":{"TraitDecl":2},"value":[{"Ident":["Iterator",0]}]},{"key":{"TraitDecl":26},"value":[{"Ident":["Sealed",0]}]},{"key":{"Type":19},"value":[{"Ident":["IntersperseWith",0]}]},{"key":{"Fun":8},"value":[{"Ident":["option_source",0]}]},{"key":{"Type":28},"value":[{"Ident":["Skip",0]}]},{"key":{"Fun":186},"value":[{"Ident":["call_mut",0]}]},{"key":{"TraitDecl":16},"value":[{"Ident":["ExactSizeIterator",0]}]},{"key":{"TraitDecl":25},"value":[{"Ident":["Tuple",0]}]},{"key":{"Type":4},"value":[{"Ident":["HostRegistry",0]}]},{"key":{"TraitDecl":13},"value":[{"Ident":["Extend",0]}]},{"key":{"Fun":7},"value":[{"Ident":["bool_then_some",0]}]},{"key":{"TraitDecl":4},"value":[{"Ident":["FnOnce",0]}]},{"key":{"Fun":187},"value":[{"Ident":["from_iter",0]}]},{"key":{"Fun":190},"value":[{"Ident":["extend",0]}]},{"key":{"Type":15},"value":[{"Ident":["StepBy",0]}]},{"key":{"Fun":201},"value":[{"Ident":["len",0]}]},{"key":{"Type":3},"value":[{"Ident":["HostCallback",0]}]},{"key":{"Fun":191},"value":[{"Ident":["extend_one",0]}]},{"key":{"Fun":216},"value":[{"Ident":["__chaining_gt",0]}]},{"key":{"TraitDecl":3},"value":[{"Ident":["From",0]}]},{"key":{"Type":37},"value":[{"Ident":["Rev",0]}]},{"key":{"Fun":5},"value":[{"Ident":["tuple_roundtrip",0]}]},{"key":{"Fun":194},"value":[{"Ident":["default",0]}]},{"key":{"Fun":3},"value":[{"Ident":["parse_one",0]}]},{"key":{"Fun":0},"value":[{"Ident":["straight_line_add",0]}]},{"key":{"Type":26},"value":[{"Ident":["TakeWhile",0]}]},{"key":{"Type":29},"value":[{"Ident":["Take",0]}]}],"type_decls":[{"def_id":0,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["PyResult",0]}],"span":{"data":{"file_id":0,"beg":{"line":10,"col":0},"end":{"line":10,"col":47}},"generated_from_span":null},"source_text":"pub type PyResult = Result;","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":10,"col":18},"end":{"line":10,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Alias":{"HashConsedValue":[6165,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":196},{"HashConsedValue":[198,{"Ref":["Static",{"HashConsedValue":[197,{"Adt":{"id":{"Builtin":"Str"},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[199,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[205,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[204,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[203,{"Ref":["Erased",{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":198}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"layout":[],"ptr_metadata":"None"},{"def_id":1,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["Strategy",0]}],"span":{"data":{"file_id":0,"beg":{"line":38,"col":0},"end":{"line":42,"col":1}},"generated_from_span":null},"source_text":"pub enum Strategy {\n Empty,\n IntKeyed { len: usize },\n StrKeyed { len: usize, capacity: usize },\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":0,"beg":{"line":39,"col":4},"end":{"line":39,"col":9}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Empty","fields":[],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":0,"beg":{"line":40,"col":4},"end":{"line":40,"col":12}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"IntKeyed","fields":[{"span":{"data":{"file_id":0,"beg":{"line":40,"col":15},"end":{"line":40,"col":25}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"len","ty":{"HashConsedValue":[614,{"Literal":{"UInt":"Usize"}}]}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}},{"id":2,"span":{"data":{"file_id":0,"beg":{"line":41,"col":4},"end":{"line":41,"col":12}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"StrKeyed","fields":[{"span":{"data":{"file_id":0,"beg":{"line":41,"col":15},"end":{"line":41,"col":25}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"len","ty":{"Deduplicated":614}},{"span":{"data":{"file_id":0,"beg":{"line":41,"col":27},"end":{"line":41,"col":42}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"capacity","ty":{"Deduplicated":614}}],"discriminant":{"Scalar":{"Signed":["Isize","2"]}}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":24,"align":8,"discriminator":{"Branch":{"offset":0,"int_ty":{"Unsigned":"U64"},"children":[[{"start":{"Unsigned":["U64","0"]},"end":{"Unsigned":["U64","0"]}},{"Known":0}],[{"start":{"Unsigned":["U64","1"]},"end":{"Unsigned":["U64","1"]}},{"Known":1}],[{"start":{"Unsigned":["U64","2"]},"end":{"Unsigned":["U64","2"]}},{"Known":2}]],"fallback":"Invalid"}},"uninhabited":false,"variant_layouts":[{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","0"]}]]},{"field_offsets":[8],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","1"]}]]},{"field_offsets":[8,16],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","2"]}]]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":2,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["Token",0]}],"span":{"data":{"file_id":0,"beg":{"line":55,"col":0},"end":{"line":59,"col":1}},"generated_from_span":null},"source_text":"pub enum Token {\n Add(i64),\n Sub(i64),\n Halt,\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":0,"beg":{"line":56,"col":4},"end":{"line":56,"col":7}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Add","fields":[{"span":{"data":{"file_id":0,"beg":{"line":56,"col":8},"end":{"line":56,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"HashConsedValue":[207,{"Literal":{"Int":"I64"}}]}}],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":0,"beg":{"line":57,"col":4},"end":{"line":57,"col":7}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Sub","fields":[{"span":{"data":{"file_id":0,"beg":{"line":57,"col":8},"end":{"line":57,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":207}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}},{"id":2,"span":{"data":{"file_id":0,"beg":{"line":58,"col":4},"end":{"line":58,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Halt","fields":[],"discriminant":{"Scalar":{"Signed":["Isize","2"]}}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":16,"align":8,"discriminator":{"Branch":{"offset":0,"int_ty":{"Unsigned":"U64"},"children":[[{"start":{"Unsigned":["U64","0"]},"end":{"Unsigned":["U64","0"]}},{"Known":0}],[{"start":{"Unsigned":["U64","1"]},"end":{"Unsigned":["U64","1"]}},{"Known":1}],[{"start":{"Unsigned":["U64","2"]},"end":{"Unsigned":["U64","2"]}},{"Known":2}]],"fallback":"Invalid"}},"uninhabited":false,"variant_layouts":[{"field_offsets":[8],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","0"]}]]},{"field_offsets":[8],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","1"]}]]},{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","2"]}]]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":3,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["HostCallback",0]}],"span":{"data":{"file_id":0,"beg":{"line":140,"col":0},"end":{"line":140,"col":39}},"generated_from_span":null},"source_text":"pub type HostCallback = fn(i64) -> i64;","attr_info":{"attributes":[{"DocComment":" The callback a host installs at run time. A bare `fn` pointer, so the set"},{"DocComment":" of addresses that can reach a call through it is not recoverable from this"},{"DocComment":" artifact — the shape used by host-settable callback hooks."}],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Alias":{"HashConsedValue":[1573,{"FnPtr":{"regions":[],"skip_binder":{"is_unsafe":false,"inputs":[{"Deduplicated":207}],"output":{"Deduplicated":207}}}}]}},"layout":[{"key":"aarch64-apple-darwin","value":{"size":8,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":4,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["HostRegistry",0]}],"span":{"data":{"file_id":0,"beg":{"line":142,"col":0},"end":{"line":145,"col":1}},"generated_from_span":null},"source_text":"pub struct HostRegistry {\n pub slot: HostCallback,\n pub maybe_slot: Option,\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Struct":[{"span":{"data":{"file_id":0,"beg":{"line":143,"col":4},"end":{"line":143,"col":26}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"slot","ty":{"Deduplicated":1573}},{"span":{"data":{"file_id":0,"beg":{"line":144,"col":4},"end":{"line":144,"col":40}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"maybe_slot","ty":{"HashConsedValue":[1577,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":1573}],"const_generics":[],"trait_refs":[{"HashConsedValue":[1576,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1575,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1573}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1573}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":16,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0,8],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":5,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Ident":["Result",0]}],"span":{"data":{"file_id":3,"beg":{"line":557,"col":0},"end":{"line":557,"col":21}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" `Result` is a type that represents either success ([`Ok`]) or failure ([`Err`])."},{"DocComment":""},{"DocComment":" See the [module documentation](self) for details."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Result"},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":557,"col":16},"end":{"line":557,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":557,"col":19},"end":{"line":557,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[1585,{"TypeVar":{"Bound":[1,1]}}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":3,"beg":{"line":561,"col":4},"end":{"line":561,"col":6}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Contains the success value"}],"inline":null,"rename":null,"public":true},"name":"Ok","fields":[{"span":{"data":{"file_id":3,"beg":{"line":561,"col":53},"end":{"line":561,"col":54}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":196}}],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":3,"beg":{"line":566,"col":4},"end":{"line":566,"col":7}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Contains the error value"}],"inline":null,"rename":null,"public":true},"name":"Err","fields":[{"span":{"data":{"file_id":3,"beg":{"line":566,"col":54},"end":{"line":566,"col":55}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"HashConsedValue":[1589,{"TypeVar":{"Bound":[0,1]}}]}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}}]},"layout":[],"ptr_metadata":"None"},{"def_id":6,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Ident":["Iter",0]}],"span":{"data":{"file_id":4,"beg":{"line":69,"col":0},"end":{"line":69,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Immutable slice iterator"},{"DocComment":""},{"DocComment":" This struct is created by the [`iter`] method on [slices]."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // First, we need a slice to call the `iter` method on:"},{"DocComment":" let slice = &[1, 2, 3];"},{"DocComment":""},{"DocComment":" // Then we call `iter` on the slice to get the `Iter` iterator,"},{"DocComment":" // and iterate over it:"},{"DocComment":" for element in slice.iter() {"},{"DocComment":" println!(\"{element}\");"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // This for loop actually already works without calling `iter`:"},{"DocComment":" for element in slice {"},{"DocComment":" println!(\"{element}\");"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`iter`]: slice::iter"},{"DocComment":" [slices]: slice"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"SliceIter"},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Shared"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":4,"beg":{"line":69,"col":20},"end":{"line":69,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[{"regions":[],"skip_binder":[{"Deduplicated":164},{"Var":{"Bound":[1,0]}}]},{"regions":[],"skip_binder":[{"Deduplicated":164},{"Var":{"Bound":[1,0]}}]}],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[{"key":"aarch64-apple-darwin","value":{"size":16,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0,8,16],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":7,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Ident":["Option",0]}],"span":{"data":{"file_id":6,"beg":{"line":600,"col":0},"end":{"line":600,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The `Option` type. See [the module level documentation](self) for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Option"},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":600,"col":16},"end":{"line":600,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":6,"beg":{"line":604,"col":4},"end":{"line":604,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" No value."}],"inline":null,"rename":null,"public":true},"name":"None","fields":[],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":6,"beg":{"line":608,"col":4},"end":{"line":608,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Some value of type `T`."}],"inline":null,"rename":null,"public":true},"name":"Some","fields":[{"span":{"data":{"file_id":6,"beg":{"line":608,"col":55},"end":{"line":608,"col":56}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":196}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}}]},"layout":[],"ptr_metadata":"None"},{"def_id":8,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["control_flow",0]},{"Ident":["ControlFlow",0]}],"span":{"data":{"file_id":8,"beg":{"line":89,"col":0},"end":{"line":89,"col":31}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used to tell an operation whether it should exit early or go on as usual."},{"DocComment":""},{"DocComment":" This is used when exposing things (like graph traversals or visitors) where"},{"DocComment":" you want the user to be able to choose whether to exit early."},{"DocComment":" Having the enum makes it clearer -- no more wondering \"wait, what did `false`"},{"DocComment":" mean again?\" -- and allows including a value."},{"DocComment":""},{"DocComment":" Similar to [`Option`] and [`Result`], this enum can be used with the `?` operator"},{"DocComment":" to return immediately if the [`Break`] variant is present or otherwise continue normally"},{"DocComment":" with the value inside the [`Continue`] variant."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Early-exiting from [`Iterator::try_for_each`]:"},{"DocComment":" ```"},{"DocComment":" use std::ops::ControlFlow;"},{"DocComment":""},{"DocComment":" let r = (2..100).try_for_each(|x| {"},{"DocComment":" if 403 % x == 0 {"},{"DocComment":" return ControlFlow::Break(x)"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" ControlFlow::Continue(())"},{"DocComment":" });"},{"DocComment":" assert_eq!(r, ControlFlow::Break(13));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" A basic tree traversal:"},{"DocComment":" ```"},{"DocComment":" use std::ops::ControlFlow;"},{"DocComment":""},{"DocComment":" pub struct TreeNode {"},{"DocComment":" value: T,"},{"DocComment":" left: Option>>,"},{"DocComment":" right: Option>>,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl TreeNode {"},{"DocComment":" pub fn traverse_inorder(&self, f: &mut impl FnMut(&T) -> ControlFlow) -> ControlFlow {"},{"DocComment":" if let Some(left) = &self.left {"},{"DocComment":" left.traverse_inorder(f)?;"},{"DocComment":" }"},{"DocComment":" f(&self.value)?;"},{"DocComment":" if let Some(right) = &self.right {"},{"DocComment":" right.traverse_inorder(f)?;"},{"DocComment":" }"},{"DocComment":" ControlFlow::Continue(())"},{"DocComment":" }"},{"DocComment":" fn leaf(value: T) -> Option>> {"},{"DocComment":" Some(Box::new(Self { value, left: None, right: None }))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let node = TreeNode {"},{"DocComment":" value: 0,"},{"DocComment":" left: TreeNode::leaf(1),"},{"DocComment":" right: Some(Box::new(TreeNode {"},{"DocComment":" value: -1,"},{"DocComment":" left: TreeNode::leaf(5),"},{"DocComment":" right: TreeNode::leaf(2),"},{"DocComment":" }))"},{"DocComment":" };"},{"DocComment":" let mut sum = 0;"},{"DocComment":""},{"DocComment":" let res = node.traverse_inorder(&mut |val| {"},{"DocComment":" if *val < 0 {"},{"DocComment":" ControlFlow::Break(*val)"},{"DocComment":" } else {"},{"DocComment":" sum += *val;"},{"DocComment":" ControlFlow::Continue(())"},{"DocComment":" }"},{"DocComment":" });"},{"DocComment":" assert_eq!(res, ControlFlow::Break(-1));"},{"DocComment":" assert_eq!(sum, 6);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`Break`]: ControlFlow::Break"},{"DocComment":" [`Continue`]: ControlFlow::Continue"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"ControlFlow"},"generics":{"regions":[],"types":[{"index":0,"name":"B"},{"index":1,"name":"C"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":89,"col":21},"end":{"line":89,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":8,"beg":{"line":89,"col":24},"end":{"line":89,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":8,"beg":{"line":93,"col":4},"end":{"line":93,"col":12}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Move on to the next phase of the operation as normal."}],"inline":null,"rename":null,"public":true},"name":"Continue","fields":[{"span":{"data":{"file_id":8,"beg":{"line":93,"col":13},"end":{"line":93,"col":14}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":1589}}],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":8,"beg":{"line":97,"col":4},"end":{"line":97,"col":9}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Exit the operation without running subsequent phases."}],"inline":null,"rename":null,"public":true},"name":"Break","fields":[{"span":{"data":{"file_id":8,"beg":{"line":97,"col":10},"end":{"line":97,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":196}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}}]},"layout":[],"ptr_metadata":"None"},{"def_id":9,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["Infallible",0]}],"span":{"data":{"file_id":10,"beg":{"line":930,"col":0},"end":{"line":930,"col":19}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The error type for errors that can never happen."},{"DocComment":""},{"DocComment":" Since this enum has no variant, a value of this type can never actually exist."},{"DocComment":" This can be useful for generic APIs that use [`Result`] and parameterize the error type,"},{"DocComment":" to indicate that the result is always [`Ok`]."},{"DocComment":""},{"DocComment":" For example, the [`TryFrom`] trait (conversion that returns a [`Result`])"},{"DocComment":" has a blanket implementation for all types where a reverse [`Into`] implementation exists."},{"DocComment":""},{"DocComment":" ```ignore (illustrates std code, duplicating the impl in a doctest would be an error)"},{"DocComment":" impl TryFrom for T where U: Into {"},{"DocComment":" type Error = Infallible;"},{"DocComment":""},{"DocComment":" fn try_from(value: U) -> Result {"},{"DocComment":" Ok(U::into(value)) // Never returns `Err`"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Future compatibility"},{"DocComment":""},{"DocComment":" This enum has the same role as [the `!` “never” type][never],"},{"DocComment":" which is unstable in this version of Rust."},{"DocComment":" When `!` is stabilized, we plan to make `Infallible` a type alias to it:"},{"DocComment":""},{"DocComment":" ```ignore (illustrates future std change)"},{"DocComment":" pub type Infallible = !;"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" … and eventually deprecate `Infallible`."},{"DocComment":""},{"DocComment":" However there is one case where `!` syntax can be used"},{"DocComment":" before `!` is stabilized as a full-fledged type: in the position of a function’s return type."},{"DocComment":" Specifically, it is possible to have implementations for two different function pointer types:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" trait MyTrait {}"},{"DocComment":" impl MyTrait for fn() -> ! {}"},{"DocComment":" impl MyTrait for fn() -> std::convert::Infallible {}"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" With `Infallible` being an enum, this code is valid."},{"DocComment":" However when `Infallible` becomes an alias for the never type,"},{"DocComment":" the two `impl`s will start to overlap"},{"DocComment":" and therefore will be disallowed by the language’s trait coherence rules."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":0,"align":1,"discriminator":null,"uninhabited":true,"variant_layouts":[],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":10,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]}],"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":{"Closure":{"info":{"kind":"FnOnce","fn_once_impl":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}}},"fn_mut_impl":null,"fn_impl":null,"signature":{"regions":[],"skip_binder":{"is_unsafe":false,"inputs":[],"output":{"Deduplicated":207}}}}}},"kind":{"Struct":[{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"name":null,"ty":{"HashConsedValue":[6166,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":207},"Shared"]}]}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":8,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},null,null,{"def_id":13,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]}],"span":{"data":{"file_id":17,"beg":{"line":20,"col":0},"end":{"line":20,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A by-value [array] iterator."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"ArrayIntoIter"},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":614}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":17,"beg":{"line":20,"col":20},"end":{"line":20,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["NonZero",0]}],"span":{"data":{"file_id":19,"beg":{"line":127,"col":0},"end":{"line":127,"col":40}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A value that is known not to equal zero."},{"DocComment":""},{"DocComment":" This enables some memory layout optimization."},{"DocComment":" For example, `Option>` is the same size as `u32`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use core::{num::NonZero};"},{"DocComment":""},{"DocComment":" assert_eq!(size_of::>>(), size_of::());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Layout"},{"DocComment":""},{"DocComment":" `NonZero` is guaranteed to have the same layout and bit validity as `T`"},{"DocComment":" with the exception that the all-zero bit pattern is invalid."},{"DocComment":" `Option>` is guaranteed to be compatible with `T`, including in"},{"DocComment":" FFI."},{"DocComment":""},{"DocComment":" Thanks to the [null pointer optimization], `NonZero` and"},{"DocComment":" `Option>` are guaranteed to have the same size and alignment:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::num::NonZero;"},{"DocComment":""},{"DocComment":" assert_eq!(size_of::>(), size_of::>>());"},{"DocComment":" assert_eq!(align_of::>(), align_of::>>());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [null pointer optimization]: crate::option#representation"},{"DocComment":""},{"DocComment":" # Note on generic usage"},{"DocComment":""},{"DocComment":" `NonZero` can only be used with some standard library primitive types"},{"DocComment":" (such as `u8`, `i32`, and etc.). The type parameter `T` must implement the"},{"DocComment":" internal trait [`ZeroablePrimitive`], which is currently permanently unstable"},{"DocComment":" and cannot be implemented by users. Therefore, you cannot use `NonZero`"},{"DocComment":" with your own types, nor can you implement traits for all `NonZero`,"},{"DocComment":" only for concrete types."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"NonZero"},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":19,"beg":{"line":127,"col":19},"end":{"line":127,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":19,"beg":{"line":127,"col":22},"end":{"line":127,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["step_by",0]},{"Ident":["StepBy",0]}],"span":{"data":{"file_id":21,"beg":{"line":16,"col":0},"end":{"line":16,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator for stepping iterators by a custom amount."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`step_by`] method on [`Iterator`]. See"},{"DocComment":" its documentation for more."},{"DocComment":""},{"DocComment":" [`step_by`]: Iterator::step_by"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":21,"beg":{"line":16,"col":18},"end":{"line":16,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["chain",0]},{"Ident":["Chain",0]}],"span":{"data":{"file_id":23,"beg":{"line":23,"col":0},"end":{"line":23,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that links two iterators together, in a chain."},{"DocComment":""},{"DocComment":" This `struct` is created by [`chain`] or [`Iterator::chain`]. See their"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::iter::Chain;"},{"DocComment":" use std::slice::Iter;"},{"DocComment":""},{"DocComment":" let a1 = [1, 2, 3];"},{"DocComment":" let a2 = [4, 5, 6];"},{"DocComment":" let iter: Chain, Iter<'_, _>> = a1.iter().chain(a2.iter());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"A"},{"index":1,"name":"B"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":23,"beg":{"line":23,"col":17},"end":{"line":23,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":23,"beg":{"line":23,"col":20},"end":{"line":23,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["Zip",0]}],"span":{"data":{"file_id":24,"beg":{"line":15,"col":0},"end":{"line":15,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that iterates two other iterators simultaneously."},{"DocComment":""},{"DocComment":" This `struct` is created by [`zip`] or [`Iterator::zip`]."},{"DocComment":" See their documentation for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"A"},{"index":1,"name":"B"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":24,"beg":{"line":15,"col":15},"end":{"line":15,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":24,"beg":{"line":15,"col":18},"end":{"line":15,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["Intersperse",0]}],"span":{"data":{"file_id":26,"beg":{"line":10,"col":0},"end":{"line":10,"col":35}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator adapter that places a separator between all elements."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::intersperse`]. See its documentation"},{"DocComment":" for more information."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":26,"beg":{"line":10,"col":23},"end":{"line":10,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":26,"beg":{"line":10,"col":26},"end":{"line":10,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":26,"beg":{"line":12,"col":13},"end":{"line":12,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"HashConsedValue":[4568,{"TraitType":[{"HashConsedValue":[4567,{"kind":{"Clause":{"Bound":[1,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"HashConsedValue":[1611,{"TypeVar":{"Bound":[2,0]}}]}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":19,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["IntersperseWith",0]}],"span":{"data":{"file_id":26,"beg":{"line":91,"col":0},"end":{"line":91,"col":32}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator adapter that places a separator between all elements."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::intersperse_with`]. See its"},{"DocComment":" documentation for more information."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"G"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":26,"beg":{"line":91,"col":27},"end":{"line":91,"col":28}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":26,"beg":{"line":91,"col":30},"end":{"line":91,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":26,"beg":{"line":93,"col":7},"end":{"line":93,"col":15}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":20,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map",0]},{"Ident":["Map",0]}],"span":{"data":{"file_id":27,"beg":{"line":61,"col":0},"end":{"line":61,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that maps the values of `iter` with `f`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`map`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`map`]: Iterator::map"},{"DocComment":" [`Iterator`]: trait.Iterator.html"},{"DocComment":""},{"DocComment":" # Notes about side effects"},{"DocComment":""},{"DocComment":" The [`map`] iterator implements [`DoubleEndedIterator`], meaning that"},{"DocComment":" you can also [`map`] backwards:"},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" let v: Vec = [1, 2, 3].into_iter().map(|x| x + 1).rev().collect();"},{"DocComment":""},{"DocComment":" assert_eq!(v, [4, 3, 2]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html"},{"DocComment":""},{"DocComment":" But if your closure has state, iterating backwards may act in a way you do"},{"DocComment":" not expect. Let's go through an example. First, in the forward direction:"},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" let mut c = 0;"},{"DocComment":""},{"DocComment":" for pair in ['a', 'b', 'c'].into_iter()"},{"DocComment":" .map(|letter| { c += 1; (letter, c) }) {"},{"DocComment":" println!(\"{pair:?}\");"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" This will print `('a', 1), ('b', 2), ('c', 3)`."},{"DocComment":""},{"DocComment":" Now consider this twist where we add a call to `rev`. This version will"},{"DocComment":" print `('c', 1), ('b', 2), ('a', 3)`. Note that the letters are reversed,"},{"DocComment":" but the values of the counter still go in order. This is because `map()` is"},{"DocComment":" still being called lazily on each item, but we are popping items off the"},{"DocComment":" back of the vector now, instead of shifting them from the front."},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" let mut c = 0;"},{"DocComment":""},{"DocComment":" for pair in ['a', 'b', 'c'].into_iter()"},{"DocComment":" .map(|letter| { c += 1; (letter, c) })"},{"DocComment":" .rev() {"},{"DocComment":" println!(\"{pair:?}\");"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":27,"beg":{"line":61,"col":15},"end":{"line":61,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":27,"beg":{"line":61,"col":18},"end":{"line":61,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":21,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter",0]},{"Ident":["Filter",0]}],"span":{"data":{"file_id":28,"beg":{"line":21,"col":0},"end":{"line":21,"col":23}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that filters the elements of `iter` with `predicate`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`filter`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`filter`]: Iterator::filter"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":28,"beg":{"line":21,"col":18},"end":{"line":21,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":28,"beg":{"line":21,"col":21},"end":{"line":21,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":22,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter_map",0]},{"Ident":["FilterMap",0]}],"span":{"data":{"file_id":29,"beg":{"line":18,"col":0},"end":{"line":18,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that uses `f` to both filter and map elements from `iter`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`filter_map`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`filter_map`]: Iterator::filter_map"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":29,"beg":{"line":18,"col":21},"end":{"line":18,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":29,"beg":{"line":18,"col":24},"end":{"line":18,"col":25}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":23,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["enumerate",0]},{"Ident":["Enumerate",0]}],"span":{"data":{"file_id":30,"beg":{"line":18,"col":0},"end":{"line":18,"col":23}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that yields the current count and the element during iteration."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`enumerate`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`enumerate`]: Iterator::enumerate"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Enumerate"},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":30,"beg":{"line":18,"col":21},"end":{"line":18,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":24,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["peekable",0]},{"Ident":["Peekable",0]}],"span":{"data":{"file_id":31,"beg":{"line":17,"col":0},"end":{"line":17,"col":32}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator with a `peek()` that returns an optional reference to the next"},{"DocComment":" element."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`peekable`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`peekable`]: Iterator::peekable"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"IterPeekable"},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":31,"beg":{"line":17,"col":20},"end":{"line":17,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":31,"beg":{"line":17,"col":23},"end":{"line":17,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":25,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip_while",0]},{"Ident":["SkipWhile",0]}],"span":{"data":{"file_id":32,"beg":{"line":17,"col":0},"end":{"line":17,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that rejects elements while `predicate` returns `true`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`skip_while`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`skip_while`]: Iterator::skip_while"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":32,"beg":{"line":17,"col":21},"end":{"line":17,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":32,"beg":{"line":17,"col":24},"end":{"line":17,"col":25}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":26,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take_while",0]},{"Ident":["TakeWhile",0]}],"span":{"data":{"file_id":33,"beg":{"line":17,"col":0},"end":{"line":17,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that only accepts elements while `predicate` returns `true`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`take_while`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`take_while`]: Iterator::take_while"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":33,"beg":{"line":17,"col":21},"end":{"line":17,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":33,"beg":{"line":17,"col":24},"end":{"line":17,"col":25}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":27,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_while",0]},{"Ident":["MapWhile",0]}],"span":{"data":{"file_id":34,"beg":{"line":17,"col":0},"end":{"line":17,"col":25}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that only accepts elements while `predicate` returns `Some(_)`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`map_while`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`map_while`]: Iterator::map_while"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":34,"beg":{"line":17,"col":20},"end":{"line":17,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":34,"beg":{"line":17,"col":23},"end":{"line":17,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":28,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip",0]},{"Ident":["Skip",0]}],"span":{"data":{"file_id":35,"beg":{"line":21,"col":0},"end":{"line":21,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that skips over `n` elements of `iter`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`skip`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`skip`]: Iterator::skip"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":35,"beg":{"line":21,"col":16},"end":{"line":21,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":29,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take",0]},{"Ident":["Take",0]}],"span":{"data":{"file_id":36,"beg":{"line":17,"col":0},"end":{"line":17,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that only iterates over the first `n` iterations of `iter`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`take`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`take`]: Iterator::take"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":36,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":30,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["scan",0]},{"Ident":["Scan",0]}],"span":{"data":{"file_id":37,"beg":{"line":17,"col":0},"end":{"line":17,"col":25}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator to maintain state while iterating another iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`scan`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`scan`]: Iterator::scan"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"St"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":37,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":37,"beg":{"line":17,"col":19},"end":{"line":17,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":37,"beg":{"line":17,"col":23},"end":{"line":17,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2626,{"TypeVar":{"Bound":[1,2]}}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":31,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["FlatMap",0]}],"span":{"data":{"file_id":38,"beg":{"line":17,"col":0},"end":{"line":17,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that maps each element to an iterator, and yields the elements"},{"DocComment":" of the produced iterators."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::flat_map`]. See its documentation"},{"DocComment":" for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"U"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":38,"beg":{"line":17,"col":19},"end":{"line":17,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":38,"beg":{"line":17,"col":22},"end":{"line":17,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":38,"beg":{"line":17,"col":39},"end":{"line":17,"col":40}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":38,"beg":{"line":17,"col":25},"end":{"line":17,"col":37}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":32,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["Flatten",0]}],"span":{"data":{"file_id":38,"beg":{"line":184,"col":0},"end":{"line":184,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that flattens one level of nesting in an iterator of things"},{"DocComment":" that can be turned into iterators."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`flatten`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`flatten`]: Iterator::flatten()"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":38,"beg":{"line":184,"col":19},"end":{"line":184,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":38,"beg":{"line":184,"col":22},"end":{"line":184,"col":50}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":38,"beg":{"line":184,"col":37},"end":{"line":184,"col":49}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":4568}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":33,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_windows",0]},{"Ident":["MapWindows",0]}],"span":{"data":{"file_id":39,"beg":{"line":11,"col":0},"end":{"line":11,"col":53}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator over the mapped windows of another iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`Iterator::map_windows`]. See its"},{"DocComment":" documentation for more information."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":614}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":39,"beg":{"line":11,"col":22},"end":{"line":11,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":39,"beg":{"line":11,"col":35},"end":{"line":11,"col":36}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":39,"beg":{"line":11,"col":25},"end":{"line":11,"col":33}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":34,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["fuse",0]},{"Ident":["Fuse",0]}],"span":{"data":{"file_id":40,"beg":{"line":17,"col":0},"end":{"line":17,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that yields `None` forever after the underlying iterator"},{"DocComment":" yields `None` once."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::fuse`]. See its documentation"},{"DocComment":" for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":40,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":35,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["inspect",0]},{"Ident":["Inspect",0]}],"span":{"data":{"file_id":41,"beg":{"line":18,"col":0},"end":{"line":18,"col":24}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that calls a function with a reference to each element before"},{"DocComment":" yielding it."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`inspect`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`inspect`]: Iterator::inspect"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":41,"beg":{"line":18,"col":19},"end":{"line":18,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":41,"beg":{"line":18,"col":22},"end":{"line":18,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":36,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ordering",0]}],"span":{"data":{"file_id":46,"beg":{"line":396,"col":0},"end":{"line":396,"col":17}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An `Ordering` is the result of a comparison between two values."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" assert_eq!(1.cmp(&2), Ordering::Less);"},{"DocComment":""},{"DocComment":" assert_eq!(1.cmp(&1), Ordering::Equal);"},{"DocComment":""},{"DocComment":" assert_eq!(2.cmp(&1), Ordering::Greater);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Ordering"},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":46,"beg":{"line":399,"col":4},"end":{"line":399,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" An ordering where a compared value is less than another."}],"inline":null,"rename":null,"public":true},"name":"Less","fields":[],"discriminant":{"Scalar":{"Signed":["I8","-1"]}}},{"id":1,"span":{"data":{"file_id":46,"beg":{"line":402,"col":4},"end":{"line":402,"col":9}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" An ordering where a compared value is equal to another."}],"inline":null,"rename":null,"public":true},"name":"Equal","fields":[],"discriminant":{"Scalar":{"Signed":["I8","0"]}}},{"id":2,"span":{"data":{"file_id":46,"beg":{"line":405,"col":4},"end":{"line":405,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" An ordering where a compared value is greater than another."}],"inline":null,"rename":null,"public":true},"name":"Greater","fields":[],"discriminant":{"Scalar":{"Signed":["I8","1"]}}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":1,"align":1,"discriminator":{"Branch":{"offset":0,"int_ty":{"Signed":"I8"},"children":[[{"start":{"Signed":["I8","-1"]},"end":{"Signed":["I8","-1"]}},{"Known":0}],[{"start":{"Signed":["I8","0"]},"end":{"Signed":["I8","0"]}},{"Known":1}],[{"start":{"Signed":["I8","1"]},"end":{"Signed":["I8","1"]}},{"Known":2}]],"fallback":"Invalid"}},"uninhabited":false,"variant_layouts":[{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Signed":["I8","-1"]}]]},{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Signed":["I8","0"]}]]},{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Signed":["I8","1"]}]]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":true}}}],"ptr_metadata":"None"},{"def_id":37,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["rev",0]},{"Ident":["Rev",0]}],"span":{"data":{"file_id":47,"beg":{"line":15,"col":0},"end":{"line":15,"col":17}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A double-ended iterator with the direction inverted."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`rev`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`rev`]: Iterator::rev"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":47,"beg":{"line":15,"col":15},"end":{"line":15,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":38,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["copied",0]},{"Ident":["Copied",0]}],"span":{"data":{"file_id":48,"beg":{"line":19,"col":0},"end":{"line":19,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that copies the elements of an underlying iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`copied`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`copied`]: Iterator::copied"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":48,"beg":{"line":19,"col":18},"end":{"line":19,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":39,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cloned",0]},{"Ident":["Cloned",0]}],"span":{"data":{"file_id":49,"beg":{"line":18,"col":0},"end":{"line":18,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that clones the elements of an underlying iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`cloned`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`cloned`]: Iterator::cloned"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":49,"beg":{"line":18,"col":18},"end":{"line":18,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":40,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cycle",0]},{"Ident":["Cycle",0]}],"span":{"data":{"file_id":50,"beg":{"line":15,"col":0},"end":{"line":15,"col":19}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that repeats endlessly."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`cycle`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`cycle`]: Iterator::cycle"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":50,"beg":{"line":15,"col":17},"end":{"line":15,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":41,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["array_chunks",0]},{"Ident":["ArrayChunks",0]}],"span":{"data":{"file_id":51,"beg":{"line":19,"col":0},"end":{"line":19,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator over `N` elements of the iterator at a time."},{"DocComment":""},{"DocComment":" The chunks do not overlap. If `N` does not divide the length of the"},{"DocComment":" iterator, then the last up to `N-1` elements will be omitted."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`array_chunks`][Iterator::array_chunks]"},{"DocComment":" method on [`Iterator`]. See its documentation for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":614}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":51,"beg":{"line":19,"col":23},"end":{"line":19,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":51,"beg":{"line":19,"col":26},"end":{"line":19,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},null,null,{"def_id":44,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Ident":["NonZeroUsizeInner",0]}],"span":{"data":{"file_id":53,"beg":{"line":20,"col":8},"end":{"line":20,"col":55}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[{"key":"aarch64-apple-darwin","value":{"size":8,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":true,"explicit_discr_type":false}}}],"ptr_metadata":"None"},null,null,null,null,null,null],"fun_decls":[{"def_id":0,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["straight_line_add",0]}],"span":{"data":{"file_id":0,"beg":{"line":15,"col":0},"end":{"line":19,"col":1}},"generated_from_span":null},"source_text":"pub fn straight_line_add(a: i64, b: i64, c: i64) -> i64 {\n let s = a + b;\n let t = s * 2;\n t + c\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":207},{"Deduplicated":207},{"Deduplicated":207}],"output":{"Deduplicated":207}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":15,"col":0},"end":{"line":19,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":3,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":15,"col":52},"end":{"line":15,"col":55}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":1,"name":"a","span":{"data":{"file_id":0,"beg":{"line":15,"col":25},"end":{"line":15,"col":26}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":2,"name":"b","span":{"data":{"file_id":0,"beg":{"line":15,"col":33},"end":{"line":15,"col":34}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":"c","span":{"data":{"file_id":0,"beg":{"line":15,"col":41},"end":{"line":15,"col":42}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":4,"name":"s","span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":13}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":16,"col":16},"end":{"line":16,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[212,{"Adt":{"id":"Tuple","generics":{"regions":[],"types":[{"Deduplicated":207},{"Deduplicated":211}],"const_generics":[],"trait_refs":[]}}}]}},{"index":8,"name":"t","span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":13}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":212}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":18,"col":8},"end":{"line":18,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":212}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":13}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":13}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":16},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":16},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":5},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":6},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":207}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":15,"col":0},"end":{"line":19,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":16},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":16},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":13}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":13}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":4},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":212}},{"BinaryOp":["MulChecked",{"Copy":{"kind":{"Local":9},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","2"]}}},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":17}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":10},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Mul":"Wrap"},{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","2"]}}},"ty":{"Deduplicated":207}}}]}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":17,"col":12},"end":{"line":17,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":10},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":5}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":5}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":8},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":8},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":8},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":11},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":12},"ty":{"Deduplicated":207}}}]}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":18,"col":4},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":8},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":8},"end":{"line":18,"col":9}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":19,"col":0},"end":{"line":19,"col":1}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":19,"col":0},"end":{"line":19,"col":1}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":19,"col":1},"end":{"line":19,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":1,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["branch_loop_sum",0]}],"span":{"data":{"file_id":0,"beg":{"line":24,"col":0},"end":{"line":34,"col":1}},"generated_from_span":null},"source_text":"pub fn branch_loop_sum(slice: &[i64], threshold: i64) -> i64 {\n let mut acc: i64 = 0;\n for &v in slice {\n if v > threshold {\n acc += v;\n } else {\n acc -= v;\n }\n }\n acc\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[214,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[213,{"Slice":{"Deduplicated":207}}]},"Shared"]}]},{"Deduplicated":207}],"output":{"Deduplicated":207}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":0},"end":{"line":34,"col":1}},"generated_from_span":null},"bound_body_regions":30,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":57},"end":{"line":24,"col":60}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":1,"name":"slice","span":{"data":{"file_id":0,"beg":{"line":24,"col":23},"end":{"line":24,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[217,{"Ref":[{"Body":1},{"Deduplicated":213},"Shared"]}]}},{"index":2,"name":"threshold","span":{"data":{"file_id":0,"beg":{"line":24,"col":38},"end":{"line":24,"col":47}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":"acc","span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":25,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[334,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":3}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"HashConsedValue":[332,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[331,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[335,{"Ref":[{"Body":4},{"Deduplicated":213},"Shared"]}]}},{"index":6,"name":"iter","span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[336,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":5}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[5392,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[377,{"Ref":[{"Body":12},{"Deduplicated":207},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5391,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5390,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":377}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":377}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[387,{"Ref":[{"Body":17},{"HashConsedValue":[386,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":18}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]},"Mut"]}]}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[389,{"Ref":[{"Body":19},{"HashConsedValue":[388,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":20}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]},"Mut"]}]}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"ty":{"HashConsedValue":[390,{"Literal":{"Int":"Isize"}}]}},{"index":11,"name":"v","span":{"data":{"file_id":0,"beg":{"line":26,"col":9},"end":{"line":26,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":12}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":27,"col":15},"end":{"line":27,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":212}},{"index":17,"name":null,"span":{"data":{"file_id":0,"beg":{"line":30,"col":19},"end":{"line":30,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":18,"name":null,"span":{"data":{"file_id":0,"beg":{"line":30,"col":12},"end":{"line":30,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":212}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":25,"col":15}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":25,"col":15}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":25,"col":15}},"generated_from_span":null},"kind":{"StorageLive":18},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":25,"col":15}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":23},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":207}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":335}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":217}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":12}},"generics":{"regions":[{"Body":21}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"args":[{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":335}}}],"dest":{"kind":{"Local":4},"ty":{"Deduplicated":334}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":0},"end":{"line":34,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":26,"col":18},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":336}},{"Use":{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":334}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":389}},{"Ref":{"place":{"kind":{"Local":6},"ty":{"Deduplicated":336}},"kind":"Mut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"HashConsedValue":[221,{"Adt":{"id":"Tuple","generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":387}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":9},"ty":{"Deduplicated":389}},"Deref"]},"ty":{"HashConsedValue":[6236,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":22}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},"kind":"TwoPhaseMut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":13}},"generics":{"regions":[{"Body":23},{"Body":25}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"args":[{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":387}}}],"dest":{"kind":{"Local":7},"ty":{"Deduplicated":5392}}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":26,"col":18},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Local":7},"ty":{"Deduplicated":5392}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},5],[{"Scalar":{"Signed":["Isize","1"]}},6]],7]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":33,"col":4},"end":{"line":33,"col":7}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":34,"col":0},"end":{"line":34,"col":1}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":34,"col":1},"end":{"line":34,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":26,"col":9},"end":{"line":26,"col":10}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":9},"end":{"line":26,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":5392}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"HashConsedValue":[6237,{"Ref":[{"Body":29},{"Deduplicated":207},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":12}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":12}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":15},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":15},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":211}},{"BinaryOp":["Gt",{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":14},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":27,"col":11},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":12},"ty":{"Deduplicated":211}}},"targets":{"If":[8,9]}}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":14},"end":{"line":26,"col":19}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":27,"col":23},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":23},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":19},"ty":{"Deduplicated":207}}}]}},"target":10,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":27,"col":23},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":27,"col":23},"end":{"line":27,"col":24}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":19},"end":{"line":30,"col":20}},"generated_from_span":null},"kind":{"StorageLive":17},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":19},"end":{"line":30,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":17},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":12},"end":{"line":30,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":18},"ty":{"Deduplicated":212}},{"BinaryOp":["SubChecked",{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":17},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":30,"col":12},"end":{"line":30,"col":20}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":18},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Sub":"Wrap"},{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":21},"ty":{"Deduplicated":207}}}]}},"target":11,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":27,"col":8},"end":{"line":31,"col":9}},"generated_from_span":null},"kind":{"Goto":{"target":12}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":30,"col":12},"end":{"line":30,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":18},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":19},"end":{"line":30,"col":20}},"generated_from_span":null},"kind":{"StorageDead":17},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":27,"col":8},"end":{"line":31,"col":9}},"generated_from_span":null},"kind":{"Goto":{"target":12}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":31,"col":8},"end":{"line":31,"col":9}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":4},"end":{"line":32,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}}],"comments":[]}}},{"def_id":2,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["strategy_len",0]}],"span":{"data":{"file_id":0,"beg":{"line":45,"col":0},"end":{"line":51,"col":1}},"generated_from_span":null},"source_text":"pub fn strategy_len(s: &Strategy) -> usize {\n match s {\n Strategy::Empty => 0,\n Strategy::IntKeyed { len } => *len,\n Strategy::StrKeyed { len, capacity: _ } => *len,\n }\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[6238,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[620,{"Adt":{"id":{"Adt":1},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]}],"output":{"Deduplicated":614}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":45,"col":0},"end":{"line":51,"col":1}},"generated_from_span":null},"bound_body_regions":5,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":45,"col":37},"end":{"line":45,"col":42}},"generated_from_span":null},"ty":{"Deduplicated":614}},{"index":1,"name":"s","span":{"data":{"file_id":0,"beg":{"line":45,"col":20},"end":{"line":45,"col":21}},"generated_from_span":null},"ty":{"HashConsedValue":[624,{"Ref":[{"Body":1},{"Deduplicated":620},"Shared"]}]}},{"index":2,"name":null,"span":{"data":{"file_id":0,"beg":{"line":47,"col":8},"end":{"line":47,"col":23}},"generated_from_span":null},"ty":{"Deduplicated":390}},{"index":3,"name":"len","span":{"data":{"file_id":0,"beg":{"line":48,"col":29},"end":{"line":48,"col":32}},"generated_from_span":null},"ty":{"HashConsedValue":[627,{"Ref":[{"Body":3},{"Deduplicated":614},"Shared"]}]}},{"index":4,"name":"len","span":{"data":{"file_id":0,"beg":{"line":49,"col":29},"end":{"line":49,"col":32}},"generated_from_span":null},"ty":{"HashConsedValue":[628,{"Ref":[{"Body":4},{"Deduplicated":614},"Shared"]}]}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":46,"col":10},"end":{"line":46,"col":11}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":10},"end":{"line":46,"col":11}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":624}},"Deref"]},"ty":{"Deduplicated":620}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":11}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":2},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},1],[{"Scalar":{"Signed":["Isize","1"]}},2],[{"Scalar":{"Signed":["Isize","2"]}},3]],4]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":47,"col":27},"end":{"line":47,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":614}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","0"]}}},"ty":{"Deduplicated":614}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":51,"col":1},"end":{"line":51,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":48,"col":29},"end":{"line":48,"col":32}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":48,"col":29},"end":{"line":48,"col":32}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":627}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":624}},"Deref"]},"ty":{"Deduplicated":620}},{"Field":[{"Adt":[1,1]},0]}]},"ty":{"Deduplicated":614}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":48,"col":38},"end":{"line":48,"col":42}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":614}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":3},"ty":{"Deduplicated":627}},"Deref"]},"ty":{"Deduplicated":614}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":48,"col":41},"end":{"line":48,"col":42}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":51,"col":1},"end":{"line":51,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":49,"col":29},"end":{"line":49,"col":32}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":49,"col":29},"end":{"line":49,"col":32}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":628}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":624}},"Deref"]},"ty":{"Deduplicated":620}},{"Field":[{"Adt":[1,2]},0]}]},"ty":{"Deduplicated":614}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":49,"col":51},"end":{"line":49,"col":55}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":614}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":4},"ty":{"Deduplicated":628}},"Deref"]},"ty":{"Deduplicated":614}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":49,"col":54},"end":{"line":49,"col":55}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":51,"col":1},"end":{"line":51,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":46,"col":10},"end":{"line":46,"col":11}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}}],"comments":[]}}},{"def_id":3,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["parse_one",0]}],"span":{"data":{"file_id":0,"beg":{"line":61,"col":0},"end":{"line":68,"col":1}},"generated_from_span":null},"source_text":"fn parse_one(raw: i64) -> PyResult {\n match raw {\n i64::MIN => Ok(Token::Halt),\n 0 => Err(\"halt-zero forbidden\"),\n v if v > 0 => Ok(Token::Add(v)),\n v => Ok(Token::Sub(-v)),\n }\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":207}],"output":{"HashConsedValue":[6239,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"HashConsedValue":[634,{"Adt":{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},{"Deduplicated":198}],"const_generics":[],"trait_refs":[{"HashConsedValue":[636,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[635,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":634}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":634}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":205}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":61,"col":0},"end":{"line":68,"col":1}},"generated_from_span":null},"bound_body_regions":35,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":61,"col":26},"end":{"line":61,"col":41}},"generated_from_span":null},"ty":{"HashConsedValue":[5399,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[651,{"Ref":[{"Body":6},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[5398,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5397,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":651}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":651}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":1,"name":"raw","span":{"data":{"file_id":0,"beg":{"line":61,"col":13},"end":{"line":61,"col":16}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":2,"name":null,"span":{"data":{"file_id":0,"beg":{"line":62,"col":10},"end":{"line":62,"col":13}},"generated_from_span":null},"ty":{"HashConsedValue":[372,{"Ref":[{"Body":10},{"Deduplicated":207},"Shared"]}]}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":63,"col":23},"end":{"line":63,"col":34}},"generated_from_span":null},"ty":{"Deduplicated":634}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":64,"col":17},"end":{"line":64,"col":38}},"generated_from_span":null},"ty":{"HashConsedValue":[657,{"Ref":[{"Body":11},{"Deduplicated":197},"Shared"]}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":64,"col":17},"end":{"line":64,"col":38}},"generated_from_span":null},"ty":{"HashConsedValue":[658,{"Ref":[{"Body":12},{"Deduplicated":197},"Shared"]}]}},{"index":6,"name":"v","span":{"data":{"file_id":0,"beg":{"line":65,"col":8},"end":{"line":65,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":7,"name":"v","span":{"data":{"file_id":0,"beg":{"line":65,"col":8},"end":{"line":65,"col":9}},"generated_from_span":null},"ty":{"HashConsedValue":[378,{"Ref":[{"Body":13},{"Deduplicated":207},"Shared"]}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":18}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":14}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":65,"col":25},"end":{"line":65,"col":38}},"generated_from_span":null},"ty":{"Deduplicated":634}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":65,"col":36},"end":{"line":65,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":12,"name":"v","span":{"data":{"file_id":0,"beg":{"line":66,"col":8},"end":{"line":66,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":66,"col":16},"end":{"line":66,"col":30}},"generated_from_span":null},"ty":{"Deduplicated":634}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":66,"col":27},"end":{"line":66,"col":29}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":66,"col":28},"end":{"line":66,"col":29}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":66,"col":27},"end":{"line":66,"col":29}},"generated_from_span":null},"ty":{"Deduplicated":211}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":62,"col":4},"end":{"line":62,"col":13}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":62,"col":4},"end":{"line":62,"col":13}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":62,"col":4},"end":{"line":62,"col":13}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":207}}},"targets":{"SwitchInt":[{"Int":"I64"},[[{"Scalar":{"Signed":["I64","-9223372036854775808"]}},1],[{"Scalar":{"Signed":["I64","0"]}},2]],3]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":63,"col":23},"end":{"line":63,"col":34}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":63,"col":23},"end":{"line":63,"col":34}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":634}},{"Aggregate":[{"Adt":[{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},2,null]},[]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":63,"col":20},"end":{"line":63,"col":35}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":5399}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[6240,{"Ref":[{"Body":14},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[6244,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6242,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6241,{"Ref":[{"Body":18},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6243,{"Ref":[{"Body":16},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":634}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":63,"col":34},"end":{"line":63,"col":35}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":68,"col":1},"end":{"line":68,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":64,"col":17},"end":{"line":64,"col":38}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":64,"col":17},"end":{"line":64,"col":38}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":64,"col":17},"end":{"line":64,"col":38}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":658}},{"Use":{"Const":{"kind":{"Literal":{"Str":"halt-zero forbidden"}},"ty":{"HashConsedValue":[6245,{"Ref":[{"Body":19},{"Deduplicated":197},"Shared"]}]}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":64,"col":17},"end":{"line":64,"col":38}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":657}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":658}},"Deref"]},"ty":{"Deduplicated":197}},"kind":"Shared","ptr_metadata":{"Copy":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":658}},"PtrMetadata"]},"ty":{"Deduplicated":614}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":64,"col":13},"end":{"line":64,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":5399}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[6246,{"Ref":[{"Body":20},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[6250,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6248,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6247,{"Ref":[{"Body":24},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6249,{"Ref":[{"Body":22},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},1,null]},[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":657}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":64,"col":38},"end":{"line":64,"col":39}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":64,"col":38},"end":{"line":64,"col":39}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":68,"col":1},"end":{"line":68,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":65,"col":8},"end":{"line":65,"col":9}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":8},"end":{"line":65,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":378}},{"Ref":{"place":{"kind":{"Local":1},"ty":{"Deduplicated":207}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":62,"col":10},"end":{"line":62,"col":13}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":372}},{"Ref":{"place":{"kind":{"Local":1},"ty":{"Deduplicated":207}},"kind":"Shallow","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":14}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":14}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":378}},"Deref"]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":211}},{"BinaryOp":["Gt",{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":65,"col":13},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":211}}},"targets":{"If":[4,5]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":65,"col":17},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":17},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":8},"end":{"line":65,"col":9}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":8},"end":{"line":65,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":25},"end":{"line":65,"col":38}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":36},"end":{"line":65,"col":37}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":36},"end":{"line":65,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":6},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":25},"end":{"line":65,"col":38}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":634}},{"Aggregate":[{"Adt":[{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},0,null]},[{"Move":{"kind":{"Local":11},"ty":{"Deduplicated":207}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":37},"end":{"line":65,"col":38}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":22},"end":{"line":65,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":5399}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[6251,{"Ref":[{"Body":25},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[6255,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6253,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6252,{"Ref":[{"Body":29},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6254,{"Ref":[{"Body":27},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":634}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":38},"end":{"line":65,"col":39}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":38},"end":{"line":65,"col":39}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":38},"end":{"line":65,"col":39}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":68,"col":1},"end":{"line":68,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":65,"col":17},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":17},"end":{"line":65,"col":18}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":65,"col":38},"end":{"line":65,"col":39}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":8},"end":{"line":66,"col":9}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":8},"end":{"line":66,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":16},"end":{"line":66,"col":30}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":27},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":28},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":28},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":27},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":211}},{"BinaryOp":["Eq",{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","-9223372036854775808"]}}},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":66,"col":27},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Local":16},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"OverflowNeg":{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":207}}}}},"target":7,"on_unwind":6}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":61,"col":0},"end":{"line":68,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":66,"col":27},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":207}},{"UnaryOp":[{"Neg":"Wrap"},{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":28},"end":{"line":66,"col":29}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":16},"end":{"line":66,"col":30}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":634}},{"Aggregate":[{"Adt":[{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},1,null]},[{"Move":{"kind":{"Local":14},"ty":{"Deduplicated":207}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":29},"end":{"line":66,"col":30}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":13},"end":{"line":66,"col":31}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":5399}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[6256,{"Ref":[{"Body":30},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[6260,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6258,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6257,{"Ref":[{"Body":34},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6259,{"Ref":[{"Body":32},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":634}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":30},"end":{"line":66,"col":31}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":66,"col":30},"end":{"line":66,"col":31}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":68,"col":1},"end":{"line":68,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":4,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["desugar_mix",0]}],"span":{"data":{"file_id":0,"beg":{"line":71,"col":0},"end":{"line":82,"col":1}},"generated_from_span":null},"source_text":"pub fn desugar_mix(input: &[i64]) -> PyResult {\n let mut acc: i64 = 0;\n for &raw in input.iter() {\n let tok = parse_one(raw)?;\n match tok {\n Token::Add(v) => acc += v,\n Token::Sub(v) => acc -= v,\n Token::Halt => break,\n }\n }\n Ok(acc)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":214}],"output":{"HashConsedValue":[6261,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":207},{"Deduplicated":198}],"const_generics":[],"trait_refs":[{"Deduplicated":332},{"Deduplicated":205}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":71,"col":0},"end":{"line":82,"col":1}},"generated_from_span":null},"bound_body_regions":147,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":71,"col":37},"end":{"line":71,"col":50}},"generated_from_span":null},"ty":{"HashConsedValue":[5453,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":207},{"Deduplicated":651}],"const_generics":[],"trait_refs":[{"Deduplicated":332},{"Deduplicated":5398}]}}}]}},{"index":1,"name":"input","span":{"data":{"file_id":0,"beg":{"line":71,"col":19},"end":{"line":71,"col":24}},"generated_from_span":null},"ty":{"HashConsedValue":[694,{"Ref":[{"Body":10},{"Deduplicated":213},"Shared"]}]}},{"index":2,"name":"acc","span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[696,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":12}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[697,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":13}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":21}},"generated_from_span":null},"ty":{"HashConsedValue":[698,{"Ref":[{"Body":14},{"Deduplicated":213},"Shared"]}]}},{"index":6,"name":"iter","span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[699,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":15}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[5456,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[709,{"Ref":[{"Body":22},{"Deduplicated":207},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5455,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5454,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":709}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":709}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[718,{"Ref":[{"Body":27},{"HashConsedValue":[717,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":28}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]},"Mut"]}]}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[720,{"Ref":[{"Body":29},{"HashConsedValue":[719,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":30}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]},"Mut"]}]}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":73,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":390}},{"index":11,"name":"raw","span":{"data":{"file_id":0,"beg":{"line":73,"col":9},"end":{"line":73,"col":12}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":12,"name":"tok","span":{"data":{"file_id":0,"beg":{"line":74,"col":12},"end":{"line":74,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":634}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[5462,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[5459,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"HashConsedValue":[835,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},{"HashConsedValue":[881,{"Ref":[{"Body":57},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[837,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[836,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":835}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":835}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[5458,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5457,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":881}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":881}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]},{"Deduplicated":634}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5461,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5460,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":5459}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5459}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":636}]}}}]}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":32}},"generated_from_span":null},"ty":{"HashConsedValue":[5465,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[910,{"Ref":[{"Body":71},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[5464,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5463,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":910}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":910}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":74,"col":28},"end":{"line":74,"col":31}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"ty":{"Deduplicated":390}},{"index":17,"name":"residual","span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[5468,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":835},{"HashConsedValue":[916,{"Ref":[{"Body":74},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":837},{"HashConsedValue":[5467,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5466,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":916}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":916}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":18,"name":null,"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[5471,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":835},{"HashConsedValue":[922,{"Ref":[{"Body":77},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":837},{"HashConsedValue":[5470,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5469,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":922}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":922}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":19,"name":"val","span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"ty":{"Deduplicated":634}},{"index":20,"name":null,"span":{"data":{"file_id":0,"beg":{"line":76,"col":12},"end":{"line":76,"col":25}},"generated_from_span":null},"ty":{"Deduplicated":390}},{"index":21,"name":"v","span":{"data":{"file_id":0,"beg":{"line":76,"col":23},"end":{"line":76,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":22,"name":null,"span":{"data":{"file_id":0,"beg":{"line":76,"col":36},"end":{"line":76,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":23,"name":null,"span":{"data":{"file_id":0,"beg":{"line":76,"col":29},"end":{"line":76,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":212}},{"index":24,"name":"v","span":{"data":{"file_id":0,"beg":{"line":77,"col":23},"end":{"line":77,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":25,"name":null,"span":{"data":{"file_id":0,"beg":{"line":77,"col":36},"end":{"line":77,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":26,"name":null,"span":{"data":{"file_id":0,"beg":{"line":77,"col":29},"end":{"line":77,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":212}},{"index":27,"name":null,"span":{"data":{"file_id":0,"beg":{"line":81,"col":7},"end":{"line":81,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":207}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"kind":{"StorageLive":20},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"kind":{"StorageLive":23},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"kind":{"StorageLive":26},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":72,"col":8},"end":{"line":72,"col":15}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":72,"col":23},"end":{"line":72,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":207}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":21}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":698}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":694}},"Deref"]},"ty":{"Deduplicated":213}},"kind":"Shared","ptr_metadata":{"Copy":{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":694}},"PtrMetadata"]},"ty":{"Deduplicated":614}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":14}},"generics":{"regions":[{"Body":81}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"args":[{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":698}}}],"dest":{"kind":{"Local":4},"ty":{"Deduplicated":697}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":71,"col":0},"end":{"line":82,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":73,"col":27},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":15}},"generics":{"regions":[],"types":[{"HashConsedValue":[5472,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":82}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6269,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6268,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":5472}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5472}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6270,{"kind":{"TraitImpl":{"id":1,"generics":{"regions":[{"Body":82}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":5472}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":697}}}],"dest":{"kind":{"Local":3},"ty":{"Deduplicated":696}}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":73,"col":27},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":699}},{"Use":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":696}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":4}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":720}},{"Ref":{"place":{"kind":{"Local":6},"ty":{"Deduplicated":699}},"kind":"Mut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":718}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":9},"ty":{"Deduplicated":720}},"Deref"]},"ty":{"HashConsedValue":[6271,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":90}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},"kind":"TwoPhaseMut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":13}},"generics":{"regions":[{"Body":91},{"Body":93}],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"args":[{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":718}}}],"dest":{"kind":{"Local":7},"ty":{"Deduplicated":5456}}},"target":5,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":73,"col":27},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Local":7},"ty":{"Deduplicated":5456}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},9],[{"Scalar":{"Signed":["Isize","1"]}},6]],7]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":73,"col":9},"end":{"line":73,"col":12}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":73,"col":9},"end":{"line":73,"col":12}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":5456}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"HashConsedValue":[6272,{"Ref":[{"Body":97},{"Deduplicated":207},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":12},"end":{"line":74,"col":15}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":32}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":28},"end":{"line":74,"col":31}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":28},"end":{"line":74,"col":31}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":207}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":32}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":3}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"args":[{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":207}}}],"dest":{"kind":{"Local":14},"ty":{"Deduplicated":5465}}},"target":8,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":16},"end":{"line":73,"col":28}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":74,"col":31},"end":{"line":74,"col":32}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":16}},"generics":{"regions":[],"types":[{"Deduplicated":634},{"HashConsedValue":[5478,{"Ref":[{"Body":98},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":636},{"HashConsedValue":[6274,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6273,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":5478}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5478}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":14},"ty":{"Deduplicated":5465}}}],"dest":{"kind":{"Local":13},"ty":{"Deduplicated":5462}}},"target":10,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":81,"col":7},"end":{"line":81,"col":10}},"generated_from_span":null},"kind":{"StorageLive":27},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":81,"col":7},"end":{"line":81,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":27},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":81,"col":4},"end":{"line":81,"col":11}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":5453}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":207},{"HashConsedValue":[6275,{"Ref":[{"Body":103},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":332},{"HashConsedValue":[6279,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6277,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6276,{"Ref":[{"Body":107},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6278,{"Ref":[{"Body":105},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":27},"ty":{"Deduplicated":207}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":81,"col":10},"end":{"line":81,"col":11}},"generated_from_span":null},"kind":{"StorageDead":27},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":82,"col":0},"end":{"line":82,"col":1}},"generated_from_span":null},"kind":{"StorageDead":2},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":82,"col":1},"end":{"line":82,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Local":13},"ty":{"Deduplicated":5462}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":16},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},11],[{"Scalar":{"Signed":["Isize","1"]}},12]],13]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageLive":19},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":19},"ty":{"Deduplicated":634}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":5462}},{"Field":[{"Adt":[8,0]},0]}]},"ty":{"Deduplicated":634}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":634}},{"Use":{"Move":{"kind":{"Local":19},"ty":{"Deduplicated":634}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageDead":19},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":33},"end":{"line":74,"col":34}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":75,"col":14},"end":{"line":75,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":20},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Local":12},"ty":{"Deduplicated":634}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":75,"col":8},"end":{"line":75,"col":17}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":20},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},14],[{"Scalar":{"Signed":["Isize","1"]}},15],[{"Scalar":{"Signed":["Isize","2"]}},16]],17]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageLive":17},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":17},"ty":{"Deduplicated":5468}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":5462}},{"Field":[{"Adt":[8,1]},0]}]},"ty":{"HashConsedValue":[6285,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":835},{"HashConsedValue":[6280,{"Ref":[{"Body":126},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":837},{"HashConsedValue":[6284,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6282,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6281,{"Ref":[{"Body":127},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6283,{"Ref":[{"Body":128},{"Deduplicated":197},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageLive":18},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":18},"ty":{"Deduplicated":5471}},{"Use":{"Copy":{"kind":{"Local":17},"ty":{"Deduplicated":5468}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":17}},"generics":{"regions":[],"types":[{"Deduplicated":207},{"HashConsedValue":[5492,{"Ref":[{"Body":129},{"Deduplicated":197},"Shared"]}]},{"Deduplicated":5492}],"const_generics":[],"trait_refs":[{"Deduplicated":332},{"HashConsedValue":[5494,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5493,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":5492}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5492}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":5494},{"HashConsedValue":[6286,{"kind":{"TraitImpl":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":5492}],"const_generics":[],"trait_refs":[{"Deduplicated":5494}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":5492},{"Deduplicated":5492}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":18},"ty":{"Deduplicated":5471}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":5453}}},"target":18,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":74,"col":18},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":76,"col":23},"end":{"line":76,"col":24}},"generated_from_span":null},"kind":{"StorageLive":21},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":76,"col":23},"end":{"line":76,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":21},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":634}},{"Field":[{"Adt":[2,0]},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":76,"col":36},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"StorageLive":22},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":76,"col":36},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":22},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":21},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":76,"col":29},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":23},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":22},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":76,"col":29},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":23},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":27},"ty":{"Deduplicated":207}}}]}},"target":19,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":77,"col":23},"end":{"line":77,"col":24}},"generated_from_span":null},"kind":{"StorageLive":24},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":77,"col":23},"end":{"line":77,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":24},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":634}},{"Field":[{"Adt":[2,1]},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":77,"col":36},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"StorageLive":25},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":77,"col":36},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":25},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":24},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":77,"col":29},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":26},"ty":{"Deduplicated":212}},{"BinaryOp":["SubChecked",{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":25},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":77,"col":29},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":26},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Sub":"Wrap"},{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":30},"ty":{"Deduplicated":207}}}]}},"target":20,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"kind":{"Goto":{"target":9}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":75,"col":14},"end":{"line":75,"col":17}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageDead":18},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":32},"end":{"line":74,"col":33}},"generated_from_span":null},"kind":{"StorageDead":17},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":74,"col":33},"end":{"line":74,"col":34}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":82,"col":0},"end":{"line":82,"col":1}},"generated_from_span":null},"kind":{"StorageDead":2},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":82,"col":1},"end":{"line":82,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":76,"col":29},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":23},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":76,"col":36},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"StorageDead":22},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":76,"col":36},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"StorageDead":21},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":76,"col":36},"end":{"line":76,"col":37}},"generated_from_span":null},"kind":{"Goto":{"target":21}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":77,"col":29},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":26},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":77,"col":36},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"StorageDead":25},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":77,"col":36},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"StorageDead":24},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":77,"col":36},"end":{"line":77,"col":37}},"generated_from_span":null},"kind":{"Goto":{"target":21}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":80,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":4},"end":{"line":80,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":4}},"comments_before":[]}}],"comments":[]}}},{"def_id":5,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["tuple_roundtrip",0]}],"span":{"data":{"file_id":0,"beg":{"line":92,"col":0},"end":{"line":95,"col":1}},"generated_from_span":null},"source_text":"pub fn tuple_roundtrip(a: i64, b: i64) -> i64 {\n let pair = (a + b, a - b);\n pair.0 * pair.1\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":207},{"Deduplicated":207}],"output":{"Deduplicated":207}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":92,"col":0},"end":{"line":95,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":92,"col":42},"end":{"line":92,"col":45}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":1,"name":"a","span":{"data":{"file_id":0,"beg":{"line":92,"col":23},"end":{"line":92,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":2,"name":"b","span":{"data":{"file_id":0,"beg":{"line":92,"col":31},"end":{"line":92,"col":32}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":"pair","span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":12}},"generated_from_span":null},"ty":{"HashConsedValue":[1419,{"Adt":{"id":"Tuple","generics":{"regions":[],"types":[{"Deduplicated":207},{"Deduplicated":207}],"const_generics":[],"trait_refs":[]}}}]}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":20},"end":{"line":93,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":212}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":28}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":27},"end":{"line":93,"col":28}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":28}},"generated_from_span":null},"ty":{"Deduplicated":212}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":13},"end":{"line":94,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":212}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":12}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":12}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":12}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":12}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":17}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":20},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":20},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":5},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":6},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":207}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":92,"col":0},"end":{"line":95,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":93,"col":16},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":20},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":20},"end":{"line":93,"col":21}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":24}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":27},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":27},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":212}},{"BinaryOp":["SubChecked",{"Copy":{"kind":{"Local":9},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":10},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":11},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Sub":"Wrap"},{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":207}}}]}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":11},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":27},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":27},"end":{"line":93,"col":28}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":15},"end":{"line":93,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":1419}},{"Aggregate":[{"Adt":[{"id":"Tuple","generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},null,null]},[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":207}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":28},"end":{"line":93,"col":29}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":28},"end":{"line":93,"col":29}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":10}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":3},"ty":{"Deduplicated":1419}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":13},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":13},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":3},"ty":{"Deduplicated":1419}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":212}},{"BinaryOp":["MulChecked",{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":13},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":14},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Mul":"Wrap"},{"Move":{"kind":{"Local":12},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":207}}}]}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":14},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":18},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":18},"end":{"line":94,"col":19}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":0},"end":{"line":95,"col":1}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":95,"col":1},"end":{"line":95,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":6,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]}],"span":{"data":{"file_id":0,"beg":{"line":105,"col":0},"end":{"line":107,"col":1}},"generated_from_span":null},"source_text":"pub fn bool_then_closure(c: bool, x: i64) -> Option {\n c.then(|| x + 1)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":211},{"Deduplicated":207}],"output":{"HashConsedValue":[1420,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":105,"col":0},"end":{"line":107,"col":1}},"generated_from_span":null},"bound_body_regions":16,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":105,"col":45},"end":{"line":105,"col":56}},"generated_from_span":null},"ty":{"Deduplicated":1420}},{"index":1,"name":"c","span":{"data":{"file_id":0,"beg":{"line":105,"col":25},"end":{"line":105,"col":26}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":105,"col":34},"end":{"line":105,"col":35}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":4},"end":{"line":106,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[1438,{"Adt":{"id":{"Adt":10},"generics":{"regions":[{"Body":1}],"types":[],"const_generics":[],"trait_refs":[]}}}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[1440,{"Ref":[{"Body":3},{"Deduplicated":207},"Shared"]}]}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":106,"col":4},"end":{"line":106,"col":5}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":4},"end":{"line":106,"col":5}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":211}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":211}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":1440}},{"Ref":{"place":{"kind":{"Local":2},"ty":{"Deduplicated":207}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":221}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":1438}},{"Aggregate":[{"Adt":[{"id":{"Adt":10},"generics":{"regions":[{"Body":4}],"types":[],"const_generics":[],"trait_refs":[]}},null,null]},[{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":1440}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":12},"end":{"line":106,"col":13}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":106,"col":4},"end":{"line":106,"col":20}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":18}},"generics":{"regions":[],"types":[{"Deduplicated":207},{"HashConsedValue":[5507,{"Adt":{"id":{"Adt":10},"generics":{"regions":[{"Body":5}],"types":[],"const_generics":[],"trait_refs":[]}}}]}],"const_generics":[],"trait_refs":[{"Deduplicated":332},{"HashConsedValue":[6292,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6291,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":5507}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5507}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6293,{"kind":{"TraitImpl":{"id":6,"generics":{"regions":[{"Body":5}],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":5507},{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6294,{"kind":{"TraitImpl":{"id":7,"generics":{"regions":[{"Body":5}],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":5507}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":211}}},{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":1438}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":1420}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":105,"col":0},"end":{"line":107,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":106,"col":19},"end":{"line":106,"col":20}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":19},"end":{"line":106,"col":20}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":107,"col":1},"end":{"line":107,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":7,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_some",0]}],"span":{"data":{"file_id":0,"beg":{"line":113,"col":0},"end":{"line":115,"col":1}},"generated_from_span":null},"source_text":"pub fn bool_then_some(c: bool, x: i64) -> Option {\n c.then_some(x + 1)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":211},{"Deduplicated":207}],"output":{"Deduplicated":1420}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":113,"col":0},"end":{"line":115,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":113,"col":42},"end":{"line":113,"col":53}},"generated_from_span":null},"ty":{"Deduplicated":1420}},{"index":1,"name":"c","span":{"data":{"file_id":0,"beg":{"line":113,"col":22},"end":{"line":113,"col":23}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":113,"col":31},"end":{"line":113,"col":32}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":4},"end":{"line":114,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":212}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":114,"col":4},"end":{"line":114,"col":5}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":4},"end":{"line":114,"col":5}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":4},"end":{"line":114,"col":5}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":211}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":211}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":17}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":5},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":6},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":207}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":113,"col":0},"end":{"line":115,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":6},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":20},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":114,"col":4},"end":{"line":114,"col":22}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":19}},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332},{"HashConsedValue":[6296,{"kind":{"BuiltinOrAuto":{"builtin_data":"NoopDestruct","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":211}}},{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":207}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":1420}}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":114,"col":21},"end":{"line":114,"col":22}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":21},"end":{"line":114,"col":22}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":115,"col":1},"end":{"line":115,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":8,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["option_source",0]}],"span":{"data":{"file_id":0,"beg":{"line":123,"col":0},"end":{"line":125,"col":1}},"generated_from_span":null},"source_text":"fn option_source(keep: bool, value: i64) -> Option {\n if keep { Some(value) } else { None }\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":211},{"Deduplicated":207}],"output":{"Deduplicated":1420}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":123,"col":0},"end":{"line":125,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":123,"col":44},"end":{"line":123,"col":55}},"generated_from_span":null},"ty":{"Deduplicated":1420}},{"index":1,"name":"keep","span":{"data":{"file_id":0,"beg":{"line":123,"col":17},"end":{"line":123,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":2,"name":"value","span":{"data":{"file_id":0,"beg":{"line":123,"col":29},"end":{"line":123,"col":34}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":124,"col":7},"end":{"line":124,"col":11}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":124,"col":19},"end":{"line":124,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":207}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":124,"col":7},"end":{"line":124,"col":11}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":124,"col":7},"end":{"line":124,"col":11}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":211}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":211}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":124,"col":7},"end":{"line":124,"col":11}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":211}}},"targets":{"If":[1,2]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":124,"col":19},"end":{"line":124,"col":24}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":124,"col":19},"end":{"line":124,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":124,"col":14},"end":{"line":124,"col":25}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":1420}},{"Aggregate":[{"Adt":[{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}},1,null]},[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":207}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":124,"col":24},"end":{"line":124,"col":25}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":124,"col":4},"end":{"line":124,"col":41}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":124,"col":35},"end":{"line":124,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":1420}},{"Aggregate":[{"Adt":[{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}},0,null]},[]]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":124,"col":4},"end":{"line":124,"col":41}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":124,"col":40},"end":{"line":124,"col":41}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":125,"col":1},"end":{"line":125,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":9,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["option_question_mark",0]}],"span":{"data":{"file_id":0,"beg":{"line":128,"col":0},"end":{"line":131,"col":1}},"generated_from_span":null},"source_text":"pub fn option_question_mark(keep: bool, value: i64, addend: i64) -> Option {\n let v = option_source(keep, value)?;\n Some(v + addend)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":211},{"Deduplicated":207},{"Deduplicated":207}],"output":{"Deduplicated":1420}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":128,"col":0},"end":{"line":131,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":3,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":128,"col":68},"end":{"line":128,"col":79}},"generated_from_span":null},"ty":{"Deduplicated":1420}},{"index":1,"name":"keep","span":{"data":{"file_id":0,"beg":{"line":128,"col":28},"end":{"line":128,"col":32}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":2,"name":"value","span":{"data":{"file_id":0,"beg":{"line":128,"col":40},"end":{"line":128,"col":45}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":"addend","span":{"data":{"file_id":0,"beg":{"line":128,"col":52},"end":{"line":128,"col":58}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":4,"name":"v","span":{"data":{"file_id":0,"beg":{"line":129,"col":8},"end":{"line":129,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"ty":{"HashConsedValue":[1536,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[1533,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":835}],"const_generics":[],"trait_refs":[{"Deduplicated":837}]}}}]},{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"HashConsedValue":[1535,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1534,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1533}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1533}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":332}]}}}]}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":38}},"generated_from_span":null},"ty":{"Deduplicated":1420}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":129,"col":26},"end":{"line":129,"col":30}},"generated_from_span":null},"ty":{"Deduplicated":211}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":129,"col":32},"end":{"line":129,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":390}},{"index":10,"name":"residual","span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":1533}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":1533}},{"index":12,"name":"val","span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":130,"col":13},"end":{"line":130,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":212}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":129,"col":8},"end":{"line":129,"col":9}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":8},"end":{"line":129,"col":9}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":8},"end":{"line":129,"col":9}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":38}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":26},"end":{"line":129,"col":30}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":26},"end":{"line":129,"col":30}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":211}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":211}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":32},"end":{"line":129,"col":37}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":32},"end":{"line":129,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":38}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":8}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"args":[{"Move":{"kind":{"Local":7},"ty":{"Deduplicated":211}}},{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":207}}}],"dest":{"kind":{"Local":6},"ty":{"Deduplicated":1420}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":128,"col":0},"end":{"line":131,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":129,"col":37},"end":{"line":129,"col":38}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":37},"end":{"line":129,"col":38}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":20}},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"args":[{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":1420}}}],"dest":{"kind":{"Local":5},"ty":{"Deduplicated":1536}}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Local":5},"ty":{"Deduplicated":1536}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},4],[{"Scalar":{"Signed":["Isize","1"]}},5]],6]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":1536}},{"Field":[{"Adt":[8,0]},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":39},"end":{"line":129,"col":40}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":10}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":4},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":13},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":13},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":14},"ty":{"Deduplicated":207}}},{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":207}}},{"Move":{"kind":{"Local":16},"ty":{"Deduplicated":207}}}]}},"target":7,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":1533}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":1536}},{"Field":[{"Adt":[8,1]},0]}]},"ty":{"Deduplicated":1533}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":1533}},{"Use":{"Copy":{"kind":{"Local":10},"ty":{"Deduplicated":1533}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":21}},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}}},"args":[{"Move":{"kind":{"Local":11},"ty":{"Deduplicated":1533}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":1420}}},"target":8,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":129,"col":12},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":130,"col":9},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":18},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":18},"end":{"line":130,"col":19}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":4},"end":{"line":130,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":1420}},{"Aggregate":[{"Adt":[{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":207}],"const_generics":[],"trait_refs":[{"Deduplicated":332}]}},1,null]},[{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":207}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":130,"col":19},"end":{"line":130,"col":20}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":131,"col":0},"end":{"line":131,"col":1}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":131,"col":1},"end":{"line":131,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":38},"end":{"line":129,"col":39}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":129,"col":39},"end":{"line":129,"col":40}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":131,"col":0},"end":{"line":131,"col":1}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":131,"col":1},"end":{"line":131,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":10,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch",0]}],"span":{"data":{"file_id":0,"beg":{"line":154,"col":0},"end":{"line":156,"col":1}},"generated_from_span":null},"source_text":"pub fn host_registry_dispatch(reg: &HostRegistry, x: i64) -> i64 {\n (reg.slot)(x)\n}","attr_info":{"attributes":[{"DocComment":" Call through the registered callback. `front::mir` lowers this to"},{"DocComment":" `OpKind::IndirectCall { graphs: None }` — `indirect_call` with an"},{"DocComment":" unknown PBC family, which `guess_call_kind` answers `residual` for"},{"DocComment":" (`call.py:105`/`137`, `jtransform.py:410-412`). The `__dyn_call`"},{"DocComment":" placeholder it used to reach is an unregistered synthetic path with no"},{"DocComment":" continuation."}],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[1580,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[1579,{"Adt":{"id":{"Adt":4},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]},{"Deduplicated":207}],"output":{"Deduplicated":207}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":154,"col":0},"end":{"line":156,"col":1}},"generated_from_span":null},"bound_body_regions":2,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":154,"col":61},"end":{"line":154,"col":64}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":1,"name":"reg","span":{"data":{"file_id":0,"beg":{"line":154,"col":30},"end":{"line":154,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[1583,{"Ref":[{"Body":1},{"Deduplicated":1579},"Shared"]}]}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":154,"col":50},"end":{"line":154,"col":51}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":155,"col":4},"end":{"line":155,"col":14}},"generated_from_span":null},"ty":{"Deduplicated":1573}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":155,"col":15},"end":{"line":155,"col":16}},"generated_from_span":null},"ty":{"Deduplicated":207}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":155,"col":4},"end":{"line":155,"col":14}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":155,"col":4},"end":{"line":155,"col":14}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":1573}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1583}},"Deref"]},"ty":{"Deduplicated":1579}},{"Field":[{"Adt":[4,null]},0]}]},"ty":{"Deduplicated":1573}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":155,"col":15},"end":{"line":155,"col":16}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":155,"col":15},"end":{"line":155,"col":16}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":155,"col":4},"end":{"line":155,"col":17}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Dynamic":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":1573}}}},"args":[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":207}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":207}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":154,"col":0},"end":{"line":156,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":155,"col":16},"end":{"line":155,"col":17}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":155,"col":16},"end":{"line":155,"col":17}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":156,"col":1},"end":{"line":156,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":11,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch_optional",0]}],"span":{"data":{"file_id":0,"beg":{"line":160,"col":0},"end":{"line":165,"col":1}},"generated_from_span":null},"source_text":"pub fn host_registry_dispatch_optional(reg: &HostRegistry, x: i64) -> i64 {\n match reg.maybe_slot {\n Some(f) => f(x),\n None => 0,\n }\n}","attr_info":{"attributes":[{"DocComment":" The one-hop `Option` spelling of the same shape."}],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1580},{"Deduplicated":207}],"output":{"Deduplicated":207}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":160,"col":0},"end":{"line":165,"col":1}},"generated_from_span":null},"bound_body_regions":2,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":160,"col":70},"end":{"line":160,"col":73}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":1,"name":"reg","span":{"data":{"file_id":0,"beg":{"line":160,"col":39},"end":{"line":160,"col":42}},"generated_from_span":null},"ty":{"Deduplicated":1583}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":160,"col":59},"end":{"line":160,"col":60}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":162,"col":8},"end":{"line":162,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":390}},{"index":4,"name":"f","span":{"data":{"file_id":0,"beg":{"line":162,"col":13},"end":{"line":162,"col":14}},"generated_from_span":null},"ty":{"Deduplicated":1573}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":162,"col":19},"end":{"line":162,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":1573}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":162,"col":21},"end":{"line":162,"col":22}},"generated_from_span":null},"ty":{"Deduplicated":207}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":161,"col":10},"end":{"line":161,"col":24}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":161,"col":10},"end":{"line":161,"col":24}},"generated_from_span":null},"kind":{"PlaceMention":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1583}},"Deref"]},"ty":{"Deduplicated":1579}},{"Field":[{"Adt":[4,null]},1]}]},"ty":{"Deduplicated":1577}}},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":161,"col":10},"end":{"line":161,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":390}},{"Discriminant":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1583}},"Deref"]},"ty":{"Deduplicated":1579}},{"Field":[{"Adt":[4,null]},1]}]},"ty":{"Deduplicated":1577}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":161,"col":4},"end":{"line":161,"col":24}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":390}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},1],[{"Scalar":{"Signed":["Isize","1"]}},2]],3]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":163,"col":16},"end":{"line":163,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":207}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":207}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":165,"col":1},"end":{"line":165,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":162,"col":13},"end":{"line":162,"col":14}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":13},"end":{"line":162,"col":14}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":1573}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1583}},"Deref"]},"ty":{"Deduplicated":1579}},{"Field":[{"Adt":[4,null]},1]}]},"ty":{"Deduplicated":1577}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"Deduplicated":1573}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":19},"end":{"line":162,"col":20}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":19},"end":{"line":162,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":1573}},{"Use":{"Copy":{"kind":{"Local":4},"ty":{"Deduplicated":1573}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":21},"end":{"line":162,"col":22}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":21},"end":{"line":162,"col":22}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":207}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":162,"col":19},"end":{"line":162,"col":23}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Dynamic":{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":1573}}}},"args":[{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":207}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":207}}},"target":5,"on_unwind":4}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":161,"col":10},"end":{"line":161,"col":24}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":160,"col":0},"end":{"line":165,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":162,"col":22},"end":{"line":162,"col":23}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":22},"end":{"line":162,"col":23}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":162,"col":22},"end":{"line":162,"col":23}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":165,"col":1},"end":{"line":165,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":12,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":4,"beg":{"line":25,"col":4},"end":{"line":25,"col":37}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":4,"beg":{"line":21,"col":9},"end":{"line":21,"col":10}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[1602,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":1063},"Shared"]}]}],"output":{"HashConsedValue":[1625,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":0,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}},"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":1602}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":13,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["next",0]}],"span":{"data":{"file_id":7,"beg":{"line":157,"col":12},"end":{"line":157,"col":47}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":7,"beg":{"line":153,"col":17},"end":{"line":153,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[6297,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":1625},"Mut"]}]}],"output":{"HashConsedValue":[6299,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[4551,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":196},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6298,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5517,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5516,{"Ref":["Erased",{"Deduplicated":164},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[1610,{"Ref":[{"Var":{"Bound":[1,0]}},{"Deduplicated":164},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":1,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}},"trait_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1625}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":5,"beg":{"line":101,"col":5},"end":{"line":101,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":1063},"kind":"InherentImplBlock"}}},{"Ident":["iter",0]}],"span":{"data":{"file_id":5,"beg":{"line":1040,"col":4},"end":{"line":1040,"col":43}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns an iterator over the slice."},{"DocComment":""},{"DocComment":" The iterator yields all items from start to end."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let x = &[1, 2, 4];"},{"DocComment":" let mut iterator = x.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(iterator.next(), Some(&1));"},{"DocComment":" assert_eq!(iterator.next(), Some(&2));"},{"DocComment":" assert_eq!(iterator.next(), Some(&4));"},{"DocComment":" assert_eq!(iterator.next(), None);"},{"DocComment":" ```"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"slice_iter"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":5,"beg":{"line":101,"col":5},"end":{"line":101,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1602}],"output":{"Deduplicated":1625}},"src":"TopLevel","is_global_initializer":null,"body":"Opaque"},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":2}},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":11,"beg":{"line":322,"col":4},"end":{"line":322,"col":27}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":317,"col":5},"end":{"line":317,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":317,"col":8},"end":{"line":317,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":196}},"src":{"TraitImpl":{"impl_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"HashConsedValue":[4562,{"kind":{"Clause":{"Bound":[0,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]}]}},"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":3}},{"Ident":["branch",0]}],"span":{"data":{"file_id":3,"beg":{"line":2172,"col":4},"end":{"line":2172,"col":64}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":5},"end":{"line":2162,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":8},"end":{"line":2162,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[4574,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"HashConsedValue":[2275,{"kind":{"Clause":{"Bound":[0,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"output":{"HashConsedValue":[6300,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[4594,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":835},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[{"Deduplicated":837},{"Deduplicated":2275}]}}}]},{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"HashConsedValue":[4596,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[4595,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[4580,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":835},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"Deduplicated":837},{"HashConsedValue":[2664,{"kind":{"Clause":{"Bound":[1,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2246,{"TypeVar":{"Bound":[2,1]}}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":4580}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"Deduplicated":2275}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":4574}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":1},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":4}},{"Ident":["from_residual",0]}],"span":{"data":{"file_id":3,"beg":{"line":2187,"col":4},"end":{"line":2187,"col":70}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":5},"end":{"line":2182,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":8},"end":{"line":2182,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":11},"end":{"line":2182,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":14},"end":{"line":2182,"col":29}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2626},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4594}],"output":{"HashConsedValue":[4598,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":196},{"HashConsedValue":[2639,{"TypeVar":{"Bound":[0,2]}}]}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"HashConsedValue":[2667,{"kind":{"Clause":{"Bound":[0,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589},{"Deduplicated":2639}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"Deduplicated":2275},{"Deduplicated":2667},{"HashConsedValue":[4599,{"kind":{"Clause":{"Bound":[0,3]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2626},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]}]}},"trait_ref":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":4598},{"Deduplicated":4594}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":211},"kind":"InherentImplBlock"}}},{"Ident":["then",0]}],"span":{"data":{"file_id":15,"beg":{"line":65,"col":4},"end":{"line":65,"col":94}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns `Some(f())` if the `bool` is [`true`](../std/keyword.true.html),"},{"DocComment":" or `None` otherwise."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" assert_eq!(false.then(|| 0), None);"},{"DocComment":" assert_eq!(true.then(|| 0), Some(0));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let mut a = 0;"},{"DocComment":""},{"DocComment":" true.then(|| { a += 1; });"},{"DocComment":" false.then(|| { a += 1; });"},{"DocComment":""},{"DocComment":" // `a` is incremented once because the closure is evaluated lazily by"},{"DocComment":" // `then`."},{"DocComment":" assert_eq!(a, 1);"},{"DocComment":" ```"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"bool_then"},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":15,"beg":{"line":65,"col":22},"end":{"line":65,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":15,"beg":{"line":65,"col":25},"end":{"line":65,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":15,"beg":{"line":65,"col":28},"end":{"line":65,"col":49}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":1585},{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":15,"beg":{"line":65,"col":52},"end":{"line":65,"col":68}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[6137,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":2246},{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":164}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":211},{"Deduplicated":1589}],"output":{"HashConsedValue":[3361,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":"Opaque"},{"def_id":19,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":211},"kind":"InherentImplBlock"}}},{"Ident":["then_some",0]}],"span":{"data":{"file_id":15,"beg":{"line":36,"col":4},"end":{"line":36,"col":72}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns `Some(t)` if the `bool` is [`true`](../std/keyword.true.html),"},{"DocComment":" or `None` otherwise."},{"DocComment":""},{"DocComment":" Arguments passed to `then_some` are eagerly evaluated; if you are"},{"DocComment":" passing the result of a function call, it is recommended to use"},{"DocComment":" [`then`], which is lazily evaluated."},{"DocComment":""},{"DocComment":" [`then`]: bool::then"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" assert_eq!(false.then_some(0), None);"},{"DocComment":" assert_eq!(true.then_some(0), Some(0));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let mut a = 0;"},{"DocComment":" let mut function_with_side_effects = || { a += 1; };"},{"DocComment":""},{"DocComment":" true.then_some(function_with_side_effects());"},{"DocComment":" false.then_some(function_with_side_effects());"},{"DocComment":""},{"DocComment":" // `a` is incremented twice because the value passed to `then_some` is"},{"DocComment":" // evaluated eagerly."},{"DocComment":" assert_eq!(a, 2);"},{"DocComment":" ```"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":15,"beg":{"line":36,"col":27},"end":{"line":36,"col":28}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":15,"beg":{"line":36,"col":30},"end":{"line":36,"col":46}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":211},{"Deduplicated":196}],"output":{"Deduplicated":3361}},"src":"TopLevel","is_global_initializer":null,"body":"Opaque"},{"def_id":20,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":8}},{"Ident":["branch",0]}],"span":{"data":{"file_id":6,"beg":{"line":2765,"col":4},"end":{"line":2765,"col":64}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2755,"col":5},"end":{"line":2755,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3361}],"output":{"HashConsedValue":[6301,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"Deduplicated":1533},{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":1535},{"Deduplicated":199}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":3361}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":1},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":21,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":9}},{"Ident":["from_residual",0]}],"span":{"data":{"file_id":6,"beg":{"line":2779,"col":4},"end":{"line":2779,"col":67}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2777,"col":5},"end":{"line":2777,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1533}],"output":{"Deduplicated":3361}},"src":{"TraitImpl":{"impl_ref":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}},"trait_ref":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":3361},{"Deduplicated":1533}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,{"def_id":29,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["next",0]}],"span":{"data":{"file_id":14,"beg":{"line":77,"col":4},"end":{"line":77,"col":45}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Advances the iterator and returns the next value."},{"DocComment":""},{"DocComment":" Returns [`None`] when iteration is finished. Individual iterator"},{"DocComment":" implementations may choose to resume iteration, and so calling `next()`"},{"DocComment":" again may or may not eventually start returning [`Some(Item)`] again at some"},{"DocComment":" point."},{"DocComment":""},{"DocComment":" [`Some(Item)`]: Some"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let a = [1, 2, 3];"},{"DocComment":""},{"DocComment":" let mut iter = a.into_iter();"},{"DocComment":""},{"DocComment":" // A call to next() returns the next value..."},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":""},{"DocComment":" // ... and then None once it's over."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":""},{"DocComment":" // More calls may or may not return `None`. Here, they always will."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"next"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[2979,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":196},"Mut"]}]}],"output":{"HashConsedValue":[6305,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[6302,{"TraitType":[{"HashConsedValue":[4665,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6304,{"kind":{"ParentClause":[{"Deduplicated":4665},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6303,{"TraitType":[{"HashConsedValue":[5625,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,{"def_id":175,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":3}},{"Ident":["from_output",0]}],"span":{"data":{"file_id":3,"beg":{"line":2167,"col":4},"end":{"line":2167,"col":48}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":5},"end":{"line":2162,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":8},"end":{"line":2162,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":4574}},"src":{"TraitImpl":{"impl_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"Deduplicated":2275}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":4574}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":176,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]},{"Ident":["from",0]}],"span":{"data":{"file_id":10,"beg":{"line":592,"col":4},"end":{"line":592,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Converts to this type from the input type."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_fn"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1589}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":177,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":5}},{"Ident":["from",0]}],"span":{"data":{"file_id":10,"beg":{"line":788,"col":4},"end":{"line":788,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns the argument unchanged."}],"inline":"Always","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":10,"beg":{"line":785,"col":5},"end":{"line":785,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":196}},"src":{"TraitImpl":{"impl_ref":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}},"trait_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":178,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":6}},{"Ident":["call_once",0]}],"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[4614,{"Adt":{"id":{"Adt":10},"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}}}]},{"Deduplicated":221}],"output":{"Deduplicated":207}},"src":{"TraitImpl":{"impl_ref":{"id":6,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":4614},{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":false}},"is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"bound_body_regions":1,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":13},"end":{"line":106,"col":13}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":1,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":4614}},{"index":2,"name":"tupled_args","span":{"data":{"file_id":0,"beg":{"line":0,"col":0},"end":{"line":0,"col":0}},"generated_from_span":null},"ty":{"Deduplicated":221}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":207}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":212}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":15}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":15}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":15}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":207}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":4614}},{"Field":[{"Adt":[10,null]},0]}]},"ty":{"HashConsedValue":[6306,{"Ref":[{"Body":0},{"Deduplicated":207},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":212}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":207}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":4},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":211}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":207}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":207}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":106,"col":14},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":207}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":4},"ty":{"Deduplicated":212}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":207}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":106,"col":18},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":106,"col":19},"end":{"line":106,"col":19}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":179,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]},{"Ident":["call_once",0]}],"span":{"data":{"file_id":16,"beg":{"line":250,"col":4},"end":{"line":250,"col":70}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196},{"Deduplicated":1589}],"output":{"HashConsedValue":[6308,{"TraitType":[{"HashConsedValue":[6307,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}},"src":{"TraitDecl":{"trait_ref":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":180,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]},{"Ident":["drop_in_place",0]}],"span":{"data":{"file_id":1,"beg":{"line":1063,"col":0},"end":{"line":1063,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[6309,{"RawPtr":[{"Deduplicated":196},"Mut"]}]}],"output":{"Deduplicated":221}},"src":{"TraitDecl":{"trait_ref":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":181,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":7}},{"Ident":["drop_in_place",0]}],"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[6310,{"RawPtr":[{"Deduplicated":4614},"Mut"]}]}],"output":{"Deduplicated":221}},"src":{"TraitImpl":{"impl_ref":{"id":7,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":4614}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":false}},"is_global_initializer":null,"body":"Missing"},{"def_id":182,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":8}},{"Ident":["from_output",0]}],"span":{"data":{"file_id":6,"beg":{"line":2760,"col":4},"end":{"line":2760,"col":48}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2755,"col":5},"end":{"line":2755,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":3361}},"src":{"TraitImpl":{"impl_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":3361}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":183,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":11,"beg":{"line":312,"col":4},"end":{"line":312,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Creates an iterator from a value."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let v = [1, 2, 3];"},{"DocComment":" let mut iter = v.into_iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"into_iter"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"HashConsedValue":[6311,{"TraitType":[{"HashConsedValue":[5634,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}},"src":{"TraitDecl":{"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":184,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]},{"Ident":["clone",0]}],"span":{"data":{"file_id":25,"beg":{"line":236,"col":4},"end":{"line":236,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns a duplicate of the value."},{"DocComment":""},{"DocComment":" Note that what \"duplicate\" means varies by type:"},{"DocComment":" - For most types, this creates a deep, independent copy"},{"DocComment":" - For reference types like `&T`, this creates another reference to the same value"},{"DocComment":" - For smart pointers like [`Arc`] or [`Rc`], this increments the reference count"},{"DocComment":" but still points to the same underlying data"},{"DocComment":""},{"DocComment":" [`Arc`]: ../../std/sync/struct.Arc.html"},{"DocComment":" [`Rc`]: ../../std/rc/struct.Rc.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(noop_method_call)]"},{"DocComment":" let hello = \"Hello\"; // &str implements Clone"},{"DocComment":""},{"DocComment":" assert_eq!(\"Hello\", hello.clone());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Example with a reference-counted type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::sync::{Arc, Mutex};"},{"DocComment":""},{"DocComment":" let data = Arc::new(Mutex::new(vec![1, 2, 3]));"},{"DocComment":" let data_clone = data.clone(); // Creates another Arc pointing to the same Mutex"},{"DocComment":""},{"DocComment":" {"},{"DocComment":" let mut lock = data.lock().unwrap();"},{"DocComment":" lock.push(4);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Changes are visible through the clone because they share the same underlying data"},{"DocComment":" assert_eq!(*data_clone.lock().unwrap(), vec![1, 2, 3, 4]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"clone_fn"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4551}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,{"def_id":186,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]},{"Ident":["call_mut",0]}],"span":{"data":{"file_id":16,"beg":{"line":166,"col":4},"end":{"line":166,"col":74}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2979},{"Deduplicated":1589}],"output":{"HashConsedValue":[6314,{"TraitType":[{"HashConsedValue":[6313,{"kind":{"ParentClause":[{"HashConsedValue":[6312,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}},"src":{"TraitDecl":{"trait_ref":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":187,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]},{"Ident":["from_iter",0]}],"span":{"data":{"file_id":11,"beg":{"line":152,"col":4},"end":{"line":152,"col":61}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Creates a value from an iterator."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v = Vec::from_iter(five_fives);"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_iter_fn"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":10,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":152,"col":17},"end":{"line":152,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":11,"beg":{"line":152,"col":20},"end":{"line":152,"col":42}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[5264,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"HashConsedValue":[2630,{"TypeVar":{"Bound":[2,2]}}]}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":1585}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2639}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":10,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":188,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["from_output",0]}],"span":{"data":{"file_id":42,"beg":{"line":192,"col":4},"end":{"line":192,"col":49}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Constructs the type from its `Output` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method"},{"DocComment":" such that applying the `?` operator will get back the original value:"},{"DocComment":" `Try::from_output(x).branch() --> ControlFlow::Continue(x)`."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::Try;"},{"DocComment":""},{"DocComment":" assert_eq!( as Try>::from_output(3), Ok(3));"},{"DocComment":" assert_eq!( as Try>::from_output(4), Some(4));"},{"DocComment":" assert_eq!("},{"DocComment":" as Try>::from_output(5),"},{"DocComment":" std::ops::ControlFlow::Continue(5),"},{"DocComment":" );"},{"DocComment":""},{"DocComment":" # fn make_question_mark_work() -> Option<()> {"},{"DocComment":" assert_eq!(Option::from_output(4)?, 4);"},{"DocComment":" # None }"},{"DocComment":" # make_question_mark_work();"},{"DocComment":""},{"DocComment":" // This is used, for example, on the accumulator in `try_fold`:"},{"DocComment":" let r = std::iter::empty().try_fold(4, |_, ()| -> Option<_> { unreachable!() });"},{"DocComment":" assert_eq!(r, Some(4));"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_output"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[5266,{"TraitType":[{"HashConsedValue":[5265,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":189,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["branch",0]}],"span":{"data":{"file_id":42,"beg":{"line":219,"col":4},"end":{"line":219,"col":65}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used in `?` to decide whether the operator should produce a value"},{"DocComment":" (because this returned [`ControlFlow::Continue`])"},{"DocComment":" or propagate a value back to the caller"},{"DocComment":" (because this returned [`ControlFlow::Break`])."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, Try};"},{"DocComment":""},{"DocComment":" assert_eq!(Ok::<_, String>(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(Err::(3).branch(), ControlFlow::Break(Err(3)));"},{"DocComment":""},{"DocComment":" assert_eq!(Some(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(None::.branch(), ControlFlow::Break(None));"},{"DocComment":""},{"DocComment":" assert_eq!(ControlFlow::::Continue(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::Break(3).branch(),"},{"DocComment":" ControlFlow::Break(ControlFlow::Break(3)),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"branch"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"HashConsedValue":[6320,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[6315,{"TraitType":[{"Deduplicated":5265},1]}]},{"Deduplicated":5266}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6317,{"kind":{"ParentClause":[{"HashConsedValue":[6316,{"kind":{"ParentClause":[{"Deduplicated":5265},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":164},{"HashConsedValue":[5269,{"TraitType":[{"HashConsedValue":[5268,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5269}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6319,{"kind":{"ParentClause":[{"Deduplicated":5265},2]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6318,{"TraitType":[{"Deduplicated":5268},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":1},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":190,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend",0]}],"span":{"data":{"file_id":11,"beg":{"line":416,"col":4},"end":{"line":416,"col":61}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Extends a collection with the contents of an iterator."},{"DocComment":""},{"DocComment":" As this is the only required method for this trait, the [trait-level] docs"},{"DocComment":" contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: Extend"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // You can extend a String with some chars:"},{"DocComment":" let mut message = String::from(\"abc\");"},{"DocComment":""},{"DocComment":" message.extend(['d', 'e', 'f'].iter());"},{"DocComment":""},{"DocComment":" assert_eq!(\"abcdef\", &message);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":13,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":416,"col":14},"end":{"line":416,"col":15}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":11,"beg":{"line":416,"col":17},"end":{"line":416,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5264},"type_id":0,"ty":{"Deduplicated":1585}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2979},{"Deduplicated":2639}],"output":{"Deduplicated":221}},"src":{"TraitDecl":{"trait_ref":{"id":13,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,{"def_id":194,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]},{"Ident":["default",0]}],"span":{"data":{"file_id":43,"beg":{"line":139,"col":4},"end":{"line":139,"col":25}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns the \"default value\" for a type."},{"DocComment":""},{"DocComment":" Default values are often some kind of initial value, identity value, or anything else that"},{"DocComment":" may make sense as a default."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Using built-in default values:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let i: i8 = Default::default();"},{"DocComment":" let (x, y): (Option, f64) = Default::default();"},{"DocComment":" let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Making your own:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" enum Kind {"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Default for Kind {"},{"DocComment":" fn default() -> Self { Kind::A }"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"default_fn"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":14,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":14,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":195,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["next_back",0]}],"span":{"data":{"file_id":44,"beg":{"line":94,"col":4},"end":{"line":94,"col":50}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Removes and returns an element from the end of the iterator."},{"DocComment":""},{"DocComment":" Returns `None` when there are no more elements."},{"DocComment":""},{"DocComment":" The [trait-level] docs contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: DoubleEndedIterator"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let numbers = vec![1, 2, 3, 4, 5, 6];"},{"DocComment":""},{"DocComment":" let mut iter = numbers.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(&1), iter.next());"},{"DocComment":" assert_eq!(Some(&6), iter.next_back());"},{"DocComment":" assert_eq!(Some(&5), iter.next_back());"},{"DocComment":" assert_eq!(Some(&2), iter.next());"},{"DocComment":" assert_eq!(Some(&3), iter.next());"},{"DocComment":" assert_eq!(Some(&4), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next_back());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Remarks"},{"DocComment":""},{"DocComment":" The elements yielded by `DoubleEndedIterator`'s methods may differ from"},{"DocComment":" the ones yielded by [`Iterator`]'s methods:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let vec = vec![(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b')];"},{"DocComment":" let uniq_by_fst_comp = || {"},{"DocComment":" let mut seen = std::collections::HashSet::new();"},{"DocComment":" vec.iter().copied().filter(move |x| seen.insert(x.0))"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" assert_eq!(uniq_by_fst_comp().last(), Some((2, 'a')));"},{"DocComment":" assert_eq!(uniq_by_fst_comp().next_back(), Some((2, 'b')));"},{"DocComment":""},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().fold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(1, 'a'), (2, 'a')]"},{"DocComment":" );"},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().rfold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(2, 'b'), (1, 'c')]"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2979}],"output":{"HashConsedValue":[6324,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[6321,{"TraitType":[{"HashConsedValue":[5276,{"kind":{"ParentClause":[{"HashConsedValue":[5275,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6323,{"kind":{"ParentClause":[{"Deduplicated":5276},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6322,{"TraitType":[{"HashConsedValue":[5647,{"kind":{"ParentClause":[{"HashConsedValue":[5646,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,{"def_id":203,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["cmp",0]}],"span":{"data":{"file_id":46,"beg":{"line":991,"col":4},"end":{"line":991,"col":44}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" This method returns an [`Ordering`] between `self` and `other`."},{"DocComment":""},{"DocComment":" By convention, `self.cmp(&other)` returns the ordering matching the expression"},{"DocComment":" `self other` if true."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" assert_eq!(5.cmp(&10), Ordering::Less);"},{"DocComment":" assert_eq!(10.cmp(&5), Ordering::Greater);"},{"DocComment":" assert_eq!(5.cmp(&5), Ordering::Equal);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"ord_cmp_method"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4551},{"HashConsedValue":[6325,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":196},"Shared"]}]}],"output":{"HashConsedValue":[3603,{"Adt":{"id":{"Adt":36},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,{"def_id":207,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]},{"Ident":["sum",0]}],"span":{"data":{"file_id":52,"beg":{"line":21,"col":4},"end":{"line":21,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by \"summing up\""},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":19,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":21,"col":11},"end":{"line":21,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":52,"beg":{"line":21,"col":14},"end":{"line":21,"col":32}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[5291,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":2630}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":1585}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2639}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":19,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":208,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]},{"Ident":["product",0]}],"span":{"data":{"file_id":52,"beg":{"line":42,"col":4},"end":{"line":42,"col":55}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by multiplying"},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":42,"col":15},"end":{"line":42,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":52,"beg":{"line":42,"col":18},"end":{"line":42,"col":36}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5291},"type_id":0,"ty":{"Deduplicated":1585}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2639}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":209,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["partial_cmp",0]}],"span":{"data":{"file_id":46,"beg":{"line":1387,"col":4},"end":{"line":1387,"col":59}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" This method returns an ordering between `self` and `other` values if one exists."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&2.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Less));"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Equal));"},{"DocComment":""},{"DocComment":" let result = 2.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Greater));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" When comparison is impossible:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let result = f64::NAN.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, None);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"cmp_partialord_cmp"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4551},{"HashConsedValue":[5292,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":1589},"Shared"]}]}],"output":{"HashConsedValue":[3972,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":3603}],"const_generics":[],"trait_refs":[{"HashConsedValue":[3971,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[3970,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":3603}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3603}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,null,{"def_id":218,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["eq",0]}],"span":{"data":{"file_id":46,"beg":{"line":256,"col":4},"end":{"line":256,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Tests for `self` and `other` values to be equal, and is used by `==`."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"cmp_partialeq_eq"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4551},{"Deduplicated":5292}],"output":{"Deduplicated":211}},"src":{"TraitDecl":{"trait_ref":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,{"def_id":221,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]},{"Ident":["from_residual",0]}],"span":{"data":{"file_id":42,"beg":{"line":333,"col":4},"end":{"line":333,"col":42}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Constructs the type from a compatible `Residual` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method such"},{"DocComment":" that applying the `?` operator will get back an equivalent residual:"},{"DocComment":" `FromResidual::from_residual(r).branch() --> ControlFlow::Break(r)`."},{"DocComment":" (The residual is not mandated to be *identical* when interconversion is involved.)"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, FromResidual};"},{"DocComment":""},{"DocComment":" assert_eq!(Result::::from_residual(Err(3_u8)), Err(3));"},{"DocComment":" assert_eq!(Option::::from_residual(None), None);"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::from_residual(ControlFlow::Break(5)),"},{"DocComment":" ControlFlow::Break(5),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_residual"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"R"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1589}],"output":{"Deduplicated":196}},"src":{"TraitDecl":{"trait_ref":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,{"def_id":223,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":14}},{"Ident":["clone",0]}],"span":{"data":{"file_id":25,"beg":{"line":614,"col":20},"end":{"line":614,"col":43}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Always","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[6326,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":614},"Shared"]}]}],"output":{"Deduplicated":614}},"src":{"TraitImpl":{"impl_ref":{"id":14,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},null,{"def_id":225,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":15}},{"Ident":["clone",0]}],"span":{"data":{"file_id":53,"beg":{"line":17,"col":17},"end":{"line":17,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[6327,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[4740,{"Adt":{"id":{"Adt":44},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]}],"output":{"Deduplicated":4740}},"src":{"TraitImpl":{"impl_ref":{"id":15,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},null],"global_decls":[null,null,null,null],"trait_decls":[{"def_id":0,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Sized",0]}],"span":{"data":{"file_id":1,"beg":{"line":161,"col":0},"end":{"line":161,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Types with a constant size known at compile time."},{"DocComment":""},{"DocComment":" All type parameters have an implicit bound of `Sized`. The special syntax"},{"DocComment":" `?Sized` can be used to remove this bound if it's not appropriate."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" struct Foo(T);"},{"DocComment":" struct Bar(T);"},{"DocComment":""},{"DocComment":" // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]"},{"DocComment":" struct BarUse(Bar<[i32]>); // OK"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The one exception is the implicit `Self` type of a trait. A trait does not"},{"DocComment":" have an implicit `Sized` bound as this is incompatible with [trait object]s"},{"DocComment":" where, by definition, the trait needs to work with all possible implementors,"},{"DocComment":" and thus could be any size."},{"DocComment":""},{"DocComment":" Although Rust will let you bind `Sized` to a trait, you won't"},{"DocComment":" be able to use it to form a trait object later:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(unused_variables)]"},{"DocComment":" trait Foo { }"},{"DocComment":" trait Bar: Sized { }"},{"DocComment":""},{"DocComment":" struct Impl;"},{"DocComment":" impl Foo for Impl { }"},{"DocComment":" impl Bar for Impl { }"},{"DocComment":""},{"DocComment":" let x: &dyn Foo = &Impl; // OK"},{"DocComment":" // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot be made into an object"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [trait object]: ../../book/ch17-02-trait-objects.html"},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message =\n\"the size for values of type `{Self}` cannot be known at compilation time\",\nlabel = \"doesn't have a size known at compile-time\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"sized"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":1,"beg":{"line":161,"col":17},"end":{"line":161,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":1,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["MetaSized",0]}],"span":{"data":{"file_id":1,"beg":{"line":178,"col":0},"end":{"line":178,"col":33}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Types with a size that can be determined from pointer metadata."},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message = \"the size for values of type `{Self}` cannot be known\", label =\n\"doesn't have a known size\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"meta_sized"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[],"consts":[],"types":[],"methods":[],"vtable":{"id":{"Adt":11},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},{"def_id":2,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]}],"span":{"data":{"file_id":14,"beg":{"line":41,"col":0},"end":{"line":41,"col":24}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A trait for dealing with iterators."},{"DocComment":""},{"DocComment":" This is the main iterator trait. For more about the concept of iterators"},{"DocComment":" generally, please see the [module-level documentation]. In particular, you"},{"DocComment":" may want to know how to [implement `Iterator`][impl]."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":" [impl]: crate::iter#implementing-iterator"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Self = \"core::ops::range::RangeTo\", note =\n\"you might have meant to use a bounded `Range`\"),\non(Self = \"core::ops::range::RangeToInclusive\", note =\n\"you might have meant to use a bounded `RangeInclusive`\"), label =\n\"`{Self}` is not an iterator\", message = \"`{Self}` is not an iterator\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"iterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":14,"beg":{"line":41,"col":0},"end":{"line":4130,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":14,"beg":{"line":45,"col":4},"end":{"line":45,"col":14}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[1731,{"TraitType":[{"HashConsedValue":[1730,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Item","attr_info":{"attributes":[{"DocComment":" The type of the elements being iterated over."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[2,0]}}],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"next","attr_info":{"attributes":[{"DocComment":" Advances the iterator and returns the next value."},{"DocComment":""},{"DocComment":" Returns [`None`] when iteration is finished. Individual iterator"},{"DocComment":" implementations may choose to resume iteration, and so calling `next()`"},{"DocComment":" again may or may not eventually start returning [`Some(Item)`] again at some"},{"DocComment":" point."},{"DocComment":""},{"DocComment":" [`Some(Item)`]: Some"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let a = [1, 2, 3];"},{"DocComment":""},{"DocComment":" let mut iter = a.into_iter();"},{"DocComment":""},{"DocComment":" // A call to next() returns the next value..."},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":""},{"DocComment":" // ... and then None once it's over."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":""},{"DocComment":" // More calls may or may not return `None`. Here, they always will."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[1729,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":164},"Mut"]}]}],"output":{"HashConsedValue":[6168,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":1731}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6167,{"kind":{"ParentClause":[{"Deduplicated":1730},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[1709,{"TraitType":[{"HashConsedValue":[1708,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"HashConsedValue":[1619,{"TypeVar":{"Bound":[3,0]}}]}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"item":{"id":29,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1730}]}}},"kind":{"TraitMethod":[2,0]}},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"vtable":{"id":{"Adt":12},"generics":{"regions":[],"types":[{"HashConsedValue":[6170,{"TraitType":[{"HashConsedValue":[6169,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":3,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]}],"span":{"data":{"file_id":10,"beg":{"line":587,"col":0},"end":{"line":587,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used to do value-to-value conversions while consuming the input value. It is the reciprocal of"},{"DocComment":" [`Into`]."},{"DocComment":""},{"DocComment":" One should always prefer implementing `From` over [`Into`]"},{"DocComment":" because implementing `From` automatically provides one with an implementation of [`Into`]"},{"DocComment":" thanks to the blanket implementation in the standard library."},{"DocComment":""},{"DocComment":" Only implement [`Into`] when targeting a version prior to Rust 1.41 and converting to a type"},{"DocComment":" outside the current crate."},{"DocComment":" `From` was not able to do these types of conversions in earlier versions because of Rust's"},{"DocComment":" orphaning rules."},{"DocComment":" See [`Into`] for more details."},{"DocComment":""},{"DocComment":" Prefer using [`Into`] over [`From`] when specifying trait bounds on a generic function"},{"DocComment":" to ensure that types that only implement [`Into`] can be used as well."},{"DocComment":""},{"DocComment":" The `From` trait is also very useful when performing error handling. When constructing a function"},{"DocComment":" that is capable of failing, the return type will generally be of the form `Result`."},{"DocComment":" `From` simplifies error handling by allowing a function to return a single error type"},{"DocComment":" that encapsulates multiple error types. See the \"Examples\" section and [the book][book] for more"},{"DocComment":" details."},{"DocComment":""},{"DocComment":" **Note: This trait must not fail**. The `From` trait is intended for perfect conversions."},{"DocComment":" If the conversion can fail or is not perfect, use [`TryFrom`]."},{"DocComment":""},{"DocComment":" # Generic Implementations"},{"DocComment":""},{"DocComment":" - `From for U` implies [`Into`]` for T`"},{"DocComment":" - `From` is reflexive, which means that `From for T` is implemented"},{"DocComment":""},{"DocComment":" # When to implement `From`"},{"DocComment":""},{"DocComment":" While there's no technical restrictions on which conversions can be done using"},{"DocComment":" a `From` implementation, the general expectation is that the conversions"},{"DocComment":" should typically be restricted as follows:"},{"DocComment":""},{"DocComment":" * The conversion is *infallible*: if the conversion can fail, use [`TryFrom`]"},{"DocComment":" instead; don't provide a `From` impl that panics."},{"DocComment":""},{"DocComment":" * The conversion is *lossless*: semantically, it should not lose or discard"},{"DocComment":" information. For example, `i32: From` exists, where the original"},{"DocComment":" value can be recovered using `u16: TryFrom`. And `String: From<&str>`"},{"DocComment":" exists, where you can get something equivalent to the original value via"},{"DocComment":" `Deref`. But `From` cannot be used to convert from `u32` to `u16`, since"},{"DocComment":" that cannot succeed in a lossless way. (There's some wiggle room here for"},{"DocComment":" information not considered semantically relevant. For example,"},{"DocComment":" `Box<[T]>: From>` exists even though it might not preserve capacity,"},{"DocComment":" like how two vectors can be equal despite differing capacities.)"},{"DocComment":""},{"DocComment":" * The conversion is *value-preserving*: the conceptual kind and meaning of"},{"DocComment":" the resulting value is the same, even though the Rust type and technical"},{"DocComment":" representation might be different. For example `-1_i8 as u8` is *lossless*,"},{"DocComment":" since `as` casting back can recover the original value, but that conversion"},{"DocComment":" is *not* available via `From` because `-1` and `255` are different conceptual"},{"DocComment":" values (despite being identical bit patterns technically). But"},{"DocComment":" `f32: From` *is* available because `1_i16` and `1.0_f32` are conceptually"},{"DocComment":" the same real number (despite having very different bit patterns technically)."},{"DocComment":" `String: From` is available because they're both *text*, but"},{"DocComment":" `String: From` is *not* available, since `1` (a number) and `\"1\"`"},{"DocComment":" (text) are too different. (Converting values to text is instead covered"},{"DocComment":" by the [`Display`](crate::fmt::Display) trait.)"},{"DocComment":""},{"DocComment":" * The conversion is *obvious*: it's the only reasonable conversion between"},{"DocComment":" the two types. Otherwise it's better to have it be a named method or"},{"DocComment":" constructor, like how [`str::as_bytes`] is a method and how integers have"},{"DocComment":" methods like [`u32::from_ne_bytes`], [`u32::from_le_bytes`], and"},{"DocComment":" [`u32::from_be_bytes`], none of which are `From` implementations. Whereas"},{"DocComment":" there's only one reasonable way to wrap an [`Ipv6Addr`](crate::net::Ipv6Addr)"},{"DocComment":" into an [`IpAddr`](crate::net::IpAddr), thus `IpAddr: From` exists."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" [`String`] implements `From<&str>`:"},{"DocComment":""},{"DocComment":" An explicit conversion from a `&str` to a String is done as follows:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let string = \"hello\".to_string();"},{"DocComment":" let other_string = String::from(\"hello\");"},{"DocComment":""},{"DocComment":" assert_eq!(string, other_string);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" While performing error handling it is often useful to implement `From` for your own error type."},{"DocComment":" By converting underlying error types to our own custom error type that encapsulates the"},{"DocComment":" underlying error type, we can return a single error type without losing information on the"},{"DocComment":" underlying cause. The '?' operator automatically converts the underlying error type to our"},{"DocComment":" custom error type with `From::from`."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::fs;"},{"DocComment":" use std::io;"},{"DocComment":" use std::num;"},{"DocComment":""},{"DocComment":" enum CliError {"},{"DocComment":" IoError(io::Error),"},{"DocComment":" ParseError(num::ParseIntError),"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl From for CliError {"},{"DocComment":" fn from(error: io::Error) -> Self {"},{"DocComment":" CliError::IoError(error)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl From for CliError {"},{"DocComment":" fn from(error: num::ParseIntError) -> Self {"},{"DocComment":" CliError::ParseError(error)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn open_and_parse_file(file_name: &str) -> Result {"},{"DocComment":" let mut contents = fs::read_to_string(&file_name)?;"},{"DocComment":" let num: i32 = contents.trim().parse()?;"},{"DocComment":" Ok(num)"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`String`]: ../../std/string/struct.String.html"},{"DocComment":" [`from`]: From::from"},{"DocComment":" [book]: ../../book/ch09-00-error-handling.html"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(all(Self = \"&str\", T = \"alloc::string::String\"), note =\n\"to coerce a `{T}` into a `{Self}`, use `&*` as a prefix\",)"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"From"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"T"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":10,"beg":{"line":587,"col":25},"end":{"line":587,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":10,"beg":{"line":587,"col":21},"end":{"line":587,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"from","attr_info":{"attributes":[{"DocComment":" Converts to this type from the input type."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1585}],"output":{"Deduplicated":164}},"item":{"id":176,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5658,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[3,0]}}],"vtable":null},{"def_id":4,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]}],"span":{"data":{"file_id":16,"beg":{"line":242,"col":0},"end":{"line":242,"col":35}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The version of the call operator that takes a by-value receiver."},{"DocComment":""},{"DocComment":" Instances of `FnOnce` can be called, but might not be callable multiple"},{"DocComment":" times. Because of this, if the only thing known about a type is that it"},{"DocComment":" implements `FnOnce`, it can only be called once."},{"DocComment":""},{"DocComment":" `FnOnce` is implemented automatically by closures that might consume captured"},{"DocComment":" variables, as well as all types that implement [`FnMut`], e.g., (safe)"},{"DocComment":" [function pointers] (since `FnOnce` is a supertrait of [`FnMut`])."},{"DocComment":""},{"DocComment":" Since both [`Fn`] and [`FnMut`] are subtraits of `FnOnce`, any instance of"},{"DocComment":" [`Fn`] or [`FnMut`] can be used where a `FnOnce` is expected."},{"DocComment":""},{"DocComment":" Use `FnOnce` as a bound when you want to accept a parameter of function-like"},{"DocComment":" type and only need to call it once. If you need to call the parameter"},{"DocComment":" repeatedly, use [`FnMut`] as a bound; if you also need it to not mutate"},{"DocComment":" state, use [`Fn`]."},{"DocComment":""},{"DocComment":" See the [chapter on closures in *The Rust Programming Language*][book] for"},{"DocComment":" some more information on this topic."},{"DocComment":""},{"DocComment":" Also of note is the special syntax for `Fn` traits (e.g."},{"DocComment":" `Fn(usize, bool) -> usize`). Those interested in the technical details of"},{"DocComment":" this can refer to [the relevant section in the *Rustonomicon*][nomicon]."},{"DocComment":""},{"DocComment":" [book]: ../../book/ch13-01-closures.html"},{"DocComment":" [function pointers]: fn"},{"DocComment":" [nomicon]: ../../nomicon/hrtb.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ## Using a `FnOnce` parameter"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" fn consume_with_relish(func: F)"},{"DocComment":" where F: FnOnce() -> String"},{"DocComment":" {"},{"DocComment":" // `func` consumes its captured variables, so it cannot be run more"},{"DocComment":" // than once."},{"DocComment":" println!(\"Consumed: {}\", func());"},{"DocComment":""},{"DocComment":" println!(\"Delicious!\");"},{"DocComment":""},{"DocComment":" // Attempting to invoke `func()` again will throw a `use of moved"},{"DocComment":" // value` error for `func`."},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let x = String::from(\"x\");"},{"DocComment":" let consume_and_return_x = move || x;"},{"DocComment":" consume_with_relish(consume_and_return_x);"},{"DocComment":""},{"DocComment":" // `consume_and_return_x` can no longer be invoked at this point"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Args = \"()\", note =\n\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}`\"),\non(Self = \"unsafe fn\", note =\n\"unsafe function cannot be called generically without an unsafe block\", label\n= \"call the function in a closure: `|| unsafe {{ /* code */ }}`\"), message =\n\"expected a `{Trait}` closure, found `{Self}`\", label =\n\"expected an `{Trait}` closure, found `{Self}`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"fn_once"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":16,"beg":{"line":242,"col":0},"end":{"line":251,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":16,"beg":{"line":242,"col":23},"end":{"line":242,"col":27}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":16,"beg":{"line":242,"col":29},"end":{"line":242,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":16,"beg":{"line":246,"col":4},"end":{"line":246,"col":16}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5317,{"TraitType":[{"HashConsedValue":[4629,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Output","attr_info":{"attributes":[{"DocComment":" The returned type after the call operator is used."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[4,0]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"call_once","attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":164},{"Deduplicated":1585}],"output":{"Deduplicated":5317}},"item":{"id":179,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"Deduplicated":4629}]}}},"kind":{"TraitMethod":[4,0]}}],"vtable":{"id":{"Adt":42},"generics":{"regions":[],"types":[{"Deduplicated":1589},{"HashConsedValue":[6172,{"TraitType":[{"HashConsedValue":[6171,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":5,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]}],"span":{"data":{"file_id":1,"beg":{"line":1063,"col":0},"end":{"line":1063,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A marker for types that can be dropped."},{"DocComment":""},{"DocComment":" This should be used for `[const]` bounds,"},{"DocComment":" as non-const bounds will always hold for every type."},{"Unknown":{"path":"rustc_on_unimplemented","args":"message = \"can't drop `{Self}`\", append_const_msg"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"destruct"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"drop_in_place","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[6173,{"RawPtr":[{"Deduplicated":164},"Mut"]}]}],"output":{"Deduplicated":221}},"item":{"id":180,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}},"kind":{"TraitMethod":[5,0]}}],"vtable":null},{"def_id":6,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]}],"span":{"data":{"file_id":11,"beg":{"line":283,"col":0},"end":{"line":283,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Conversion into an [`Iterator`]."},{"DocComment":""},{"DocComment":" By implementing `IntoIterator` for a type, you define how it will be"},{"DocComment":" converted to an iterator. This is common for types which describe a"},{"DocComment":" collection of some kind."},{"DocComment":""},{"DocComment":" One benefit of implementing `IntoIterator` is that your type will [work"},{"DocComment":" with Rust's `for` loop syntax](crate::iter#for-loops-and-intoiterator)."},{"DocComment":""},{"DocComment":" See also: [`FromIterator`]."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let v = [1, 2, 3];"},{"DocComment":" let mut iter = v.into_iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"},{"DocComment":" Implementing `IntoIterator` for your type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // A sample collection, that's just a wrapper over Vec"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct MyCollection(Vec);"},{"DocComment":""},{"DocComment":" // Let's give it some methods so we can create one and add things"},{"DocComment":" // to it."},{"DocComment":" impl MyCollection {"},{"DocComment":" fn new() -> MyCollection {"},{"DocComment":" MyCollection(Vec::new())"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn add(&mut self, elem: i32) {"},{"DocComment":" self.0.push(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // and we'll implement IntoIterator"},{"DocComment":" impl IntoIterator for MyCollection {"},{"DocComment":" type Item = i32;"},{"DocComment":" type IntoIter = std::vec::IntoIter;"},{"DocComment":""},{"DocComment":" fn into_iter(self) -> Self::IntoIter {"},{"DocComment":" self.0.into_iter()"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Now we can make a new collection..."},{"DocComment":" let mut c = MyCollection::new();"},{"DocComment":""},{"DocComment":" // ... add some stuff to it ..."},{"DocComment":" c.add(0);"},{"DocComment":" c.add(1);"},{"DocComment":" c.add(2);"},{"DocComment":""},{"DocComment":" // ... and then turn it into an Iterator:"},{"DocComment":" for (i, n) in c.into_iter().enumerate() {"},{"DocComment":" assert_eq!(i as i32, n);"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" It is common to use `IntoIterator` as a trait bound. This allows"},{"DocComment":" the input collection type to change, so long as it is still an"},{"DocComment":" iterator. Additional bounds can be specified by restricting on"},{"DocComment":" `Item`:"},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" fn collect_as_strings(collection: T) -> Vec"},{"DocComment":" where"},{"DocComment":" T: IntoIterator,"},{"DocComment":" T::Item: std::fmt::Debug,"},{"DocComment":" {"},{"DocComment":" collection"},{"DocComment":" .into_iter()"},{"DocComment":" .map(|item| format!(\"{item:?}\"))"},{"DocComment":" .collect()"},{"DocComment":" }"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Self = \"core::ops::range::RangeTo\", label =\n\"if you meant to iterate until a value, add a starting value\", note =\n\"`..end` is a `RangeTo`, which cannot be iterated on; you might have meant to have a \\\n bounded `Range`: `0..end`\"),\non(Self = \"core::ops::range::RangeToInclusive\", label =\n\"if you meant to iterate until a value (including it), add a starting value\",\nnote =\n\"`..=end` is a `RangeToInclusive`, which cannot be iterated on; you might have meant \\\n to have a bounded `RangeInclusive`: `0..=end`\"),\non(Self = \"[]\", label =\n\"`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`\"),\non(Self = \"&[]\", label =\n\"`{Self}` is not an iterator; try calling `.iter()`\"),\non(Self = \"alloc::vec::Vec\", label =\n\"`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`\"),\non(Self = \"&str\", label =\n\"`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`\"),\non(Self = \"alloc::string::String\", label =\n\"`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`\"),\non(Self = \"{integral}\", note =\n\"if you want to iterate between `start` until a value `end`, use the exclusive range \\\n syntax `start..end` or the inclusive range syntax `start..=end`\"),\non(Self = \"{float}\", note =\n\"if you want to iterate between `start` until a value `end`, use the exclusive range \\\n syntax `start..end` or the inclusive range syntax `start..=end`\"),\nlabel = \"`{Self}` is not an iterator\", message = \"`{Self}` is not an iterator\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"IntoIterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[6039,{"kind":{"ParentClause":[{"HashConsedValue":[4663,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},3]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"HashConsedValue":[5663,{"TraitType":[{"HashConsedValue":[5662,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":1619}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"HashConsedValue":[5552,{"TraitType":[{"Deduplicated":4663},0]}]}}}]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":283,"col":0},"end":{"line":313,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":287,"col":4},"end":{"line":287,"col":14}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5552}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":11,"beg":{"line":291,"col":4},"end":{"line":291,"col":47}},"generated_from_span":null},"origin":{"TraitItem":1},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5321,{"TraitType":[{"Deduplicated":4663},1]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":11,"beg":{"line":291,"col":19},"end":{"line":291,"col":46}},"generated_from_span":null},"origin":{"TraitItem":1},"trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":5321}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Item","attr_info":{"attributes":[{"DocComment":" The type of the elements being iterated over."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"IntoIter","attr_info":{"attributes":[{"DocComment":" Which kind of iterator are we turning this into?"}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"into_iter","attr_info":{"attributes":[{"DocComment":" Creates an iterator from a value."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let v = [1, 2, 3];"},{"DocComment":" let mut iter = v.into_iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":164}],"output":{"Deduplicated":5321}},"item":{"id":183,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":4663}]}}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":{"Adt":43},"generics":{"regions":[],"types":[{"HashConsedValue":[6174,{"TraitType":[{"HashConsedValue":[4643,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]},{"HashConsedValue":[6175,{"TraitType":[{"Deduplicated":4643},1]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":7,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["ZeroablePrimitive",0]}],"span":{"data":{"file_id":19,"beg":{"line":33,"col":0},"end":{"line":33,"col":66}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A marker trait for primitive types which can be zero."},{"DocComment":""},{"DocComment":" This is an implementation detail for [NonZero]\\ which may disappear or be replaced at any time."},{"DocComment":""},{"DocComment":" # Safety"},{"DocComment":""},{"DocComment":" Types implementing this trait must be primitives that are valid when zeroed."},{"DocComment":""},{"DocComment":" The associated `Self::NonZeroInner` type must have the same size+align as `Self`,"},{"DocComment":" but with a niche and bit validity making it so the following `transmutes` are sound:"},{"DocComment":""},{"DocComment":" - `Self::NonZeroInner` to `Option`"},{"DocComment":" - `Option` to `Self`"},{"DocComment":""},{"DocComment":" (And, consequently, `Self::NonZeroInner` to `Self`.)"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":19,"beg":{"line":33,"col":36},"end":{"line":33,"col":41}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":19,"beg":{"line":33,"col":44},"end":{"line":33,"col":48}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":19,"beg":{"line":33,"col":51},"end":{"line":33,"col":66}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":19,"beg":{"line":35,"col":23},"end":{"line":35,"col":28}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5556,{"TraitType":[{"HashConsedValue":[5555,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":4,"span":{"data":{"file_id":19,"beg":{"line":35,"col":31},"end":{"line":35,"col":35}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":5556}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"NonZeroInner","attr_info":{"attributes":[{"DocComment":" A type like `Self` but with a niche that includes zero."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[7,0]}}],"methods":[],"vtable":null},{"def_id":8,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]}],"span":{"data":{"file_id":25,"beg":{"line":194,"col":0},"end":{"line":194,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A common trait that allows explicit creation of a duplicate value."},{"DocComment":""},{"DocComment":" Calling [`clone`] always produces a new value."},{"DocComment":" However, for types that are references to other data (such as smart pointers or references),"},{"DocComment":" the new value may still point to the same underlying data, rather than duplicating it."},{"DocComment":" See [`Clone::clone`] for more details."},{"DocComment":""},{"DocComment":" This distinction is especially important when using `#[derive(Clone)]` on structs containing"},{"DocComment":" smart pointers like `Arc>` - the cloned struct will share mutable state with the"},{"DocComment":" original."},{"DocComment":""},{"DocComment":" Differs from [`Copy`] in that [`Copy`] is implicit and an inexpensive bit-wise copy, while"},{"DocComment":" `Clone` is always explicit and may or may not be expensive. [`Copy`] has no methods, so you"},{"DocComment":" cannot change its behavior, but when implementing `Clone`, the `clone` method you provide"},{"DocComment":" may run arbitrary code."},{"DocComment":""},{"DocComment":" Since `Clone` is a supertrait of [`Copy`], any type that implements `Copy` must also implement"},{"DocComment":" `Clone`."},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d"},{"DocComment":" implementation of [`Clone`] calls [`clone`] on each field."},{"DocComment":""},{"DocComment":" [`clone`]: Clone::clone"},{"DocComment":""},{"DocComment":" For a generic struct, `#[derive]` implements `Clone` conditionally by adding bound `Clone` on"},{"DocComment":" generic parameters."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // `derive` implements Clone for Reading when T is Clone."},{"DocComment":" #[derive(Clone)]"},{"DocComment":" struct Reading {"},{"DocComment":" frequency: T,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## How can I implement `Clone`?"},{"DocComment":""},{"DocComment":" Types that are [`Copy`] should have a trivial implementation of `Clone`. More formally:"},{"DocComment":" if `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`."},{"DocComment":" Manual implementations should be careful to uphold this invariant; however, unsafe code"},{"DocComment":" must not rely on it to ensure memory safety."},{"DocComment":""},{"DocComment":" An example is a generic struct holding a function pointer. In this case, the"},{"DocComment":" implementation of `Clone` cannot be `derive`d, but can be implemented as:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" struct Generate(fn() -> T);"},{"DocComment":""},{"DocComment":" impl Copy for Generate {}"},{"DocComment":""},{"DocComment":" impl Clone for Generate {"},{"DocComment":" fn clone(&self) -> Self {"},{"DocComment":" *self"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" If we `derive`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct Generate(fn() -> T);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" the auto-derived implementations will have unnecessary `T: Copy` and `T: Clone` bounds:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # struct Generate(fn() -> T);"},{"DocComment":""},{"DocComment":" // Automatically derived"},{"DocComment":" impl Copy for Generate { }"},{"DocComment":""},{"DocComment":" // Automatically derived"},{"DocComment":" impl Clone for Generate {"},{"DocComment":" fn clone(&self) -> Generate {"},{"DocComment":" Generate(Clone::clone(&self.0))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The bounds are unnecessary because clearly the function itself should be"},{"DocComment":" copy- and cloneable even if its return type is not:"},{"DocComment":""},{"DocComment":" ```compile_fail,E0599"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct Generate(fn() -> T);"},{"DocComment":""},{"DocComment":" struct NotCloneable;"},{"DocComment":""},{"DocComment":" fn generate_not_cloneable() -> NotCloneable {"},{"DocComment":" NotCloneable"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" Generate(generate_not_cloneable).clone(); // error: trait bounds were not satisfied"},{"DocComment":" // Note: With the manual implementations the above line will compile."},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## `Clone` and `PartialEq`/`Eq`"},{"DocComment":" `Clone` is intended for the duplication of objects. Consequently, when implementing"},{"DocComment":" both `Clone` and [`PartialEq`], the following property is expected to hold:"},{"DocComment":" ```text"},{"DocComment":" x == x -> x.clone() == x"},{"DocComment":" ```"},{"DocComment":" In other words, if an object compares equal to itself,"},{"DocComment":" its clone must also compare equal to the original."},{"DocComment":""},{"DocComment":" For types that also implement [`Eq`] – for which `x == x` always holds –"},{"DocComment":" this implies that `x.clone() == x` must always be true."},{"DocComment":" Standard library collections such as"},{"DocComment":" [`HashMap`], [`HashSet`], [`BTreeMap`], [`BTreeSet`] and [`BinaryHeap`]"},{"DocComment":" rely on their keys respecting this property for correct behavior."},{"DocComment":" Furthermore, these collections require that cloning a key preserves the outcome of the"},{"DocComment":" [`Hash`] and [`Ord`] methods. Thankfully, this follows automatically from `x.clone() == x`"},{"DocComment":" if `Hash` and `Ord` are correctly implemented according to their own requirements."},{"DocComment":""},{"DocComment":" When deriving both `Clone` and [`PartialEq`] using `#[derive(Clone, PartialEq)]`"},{"DocComment":" or when additionally deriving [`Eq`] using `#[derive(Clone, PartialEq, Eq)]`,"},{"DocComment":" then this property is automatically upheld – provided that it is satisfied by"},{"DocComment":" the underlying types."},{"DocComment":""},{"DocComment":" Violating this property is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on this property"},{"DocComment":" being satisfied."},{"DocComment":""},{"DocComment":" ## Additional implementors"},{"DocComment":""},{"DocComment":" In addition to the [implementors listed below][impls],"},{"DocComment":" the following types also implement `Clone`:"},{"DocComment":""},{"DocComment":" * Function item types (i.e., the distinct types defined for each function)"},{"DocComment":" * Function pointer types (e.g., `fn() -> i32`)"},{"DocComment":" * Closure types, if they capture no value from the environment"},{"DocComment":" or if all such captured values implement `Clone` themselves."},{"DocComment":" Note that variables captured by shared reference always implement `Clone`"},{"DocComment":" (even if the referent doesn't),"},{"DocComment":" while variables captured by mutable reference never implement `Clone`."},{"DocComment":""},{"DocComment":" [`HashMap`]: ../../std/collections/struct.HashMap.html"},{"DocComment":" [`HashSet`]: ../../std/collections/struct.HashSet.html"},{"DocComment":" [`BTreeMap`]: ../../std/collections/struct.BTreeMap.html"},{"DocComment":" [`BTreeSet`]: ../../std/collections/struct.BTreeSet.html"},{"DocComment":" [`BinaryHeap`]: ../../std/collections/struct.BinaryHeap.html"},{"DocComment":" [impls]: #implementors"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"clone"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":25,"beg":{"line":194,"col":23},"end":{"line":194,"col":28}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"clone","attr_info":{"attributes":[{"DocComment":" Returns a duplicate of the value."},{"DocComment":""},{"DocComment":" Note that what \"duplicate\" means varies by type:"},{"DocComment":" - For most types, this creates a deep, independent copy"},{"DocComment":" - For reference types like `&T`, this creates another reference to the same value"},{"DocComment":" - For smart pointers like [`Arc`] or [`Rc`], this increments the reference count"},{"DocComment":" but still points to the same underlying data"},{"DocComment":""},{"DocComment":" [`Arc`]: ../../std/sync/struct.Arc.html"},{"DocComment":" [`Rc`]: ../../std/rc/struct.Rc.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(noop_method_call)]"},{"DocComment":" let hello = \"Hello\"; // &str implements Clone"},{"DocComment":""},{"DocComment":" assert_eq!(\"Hello\", hello.clone());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Example with a reference-counted type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::sync::{Arc, Mutex};"},{"DocComment":""},{"DocComment":" let data = Arc::new(Mutex::new(vec![1, 2, 3]));"},{"DocComment":" let data_clone = data.clone(); // Creates another Arc pointing to the same Mutex"},{"DocComment":""},{"DocComment":" {"},{"DocComment":" let mut lock = data.lock().unwrap();"},{"DocComment":" lock.push(4);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Changes are visible through the clone because they share the same underlying data"},{"DocComment":" assert_eq!(*data_clone.lock().unwrap(), vec![1, 2, 3, 4]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[1854,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":164},"Shared"]}]}],"output":{"Deduplicated":164}},"item":{"id":184,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5667,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[8,0]}},null],"vtable":null},{"def_id":9,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]}],"span":{"data":{"file_id":16,"beg":{"line":163,"col":0},"end":{"line":163,"col":48}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The version of the call operator that takes a mutable receiver."},{"DocComment":""},{"DocComment":" Instances of `FnMut` can be called repeatedly and may mutate state."},{"DocComment":""},{"DocComment":" `FnMut` is implemented automatically by closures which take mutable"},{"DocComment":" references to captured variables, as well as all types that implement"},{"DocComment":" [`Fn`], e.g., (safe) [function pointers] (since `FnMut` is a supertrait of"},{"DocComment":" [`Fn`]). Additionally, for any type `F` that implements `FnMut`, `&mut F`"},{"DocComment":" implements `FnMut`, too."},{"DocComment":""},{"DocComment":" Since [`FnOnce`] is a supertrait of `FnMut`, any instance of `FnMut` can be"},{"DocComment":" used where a [`FnOnce`] is expected, and since [`Fn`] is a subtrait of"},{"DocComment":" `FnMut`, any instance of [`Fn`] can be used where `FnMut` is expected."},{"DocComment":""},{"DocComment":" Use `FnMut` as a bound when you want to accept a parameter of function-like"},{"DocComment":" type and need to call it repeatedly, while allowing it to mutate state."},{"DocComment":" If you don't want the parameter to mutate state, use [`Fn`] as a"},{"DocComment":" bound; if you don't need to call it repeatedly, use [`FnOnce`]."},{"DocComment":""},{"DocComment":" See the [chapter on closures in *The Rust Programming Language*][book] for"},{"DocComment":" some more information on this topic."},{"DocComment":""},{"DocComment":" Also of note is the special syntax for `Fn` traits (e.g."},{"DocComment":" `Fn(usize, bool) -> usize`). Those interested in the technical details of"},{"DocComment":" this can refer to [the relevant section in the *Rustonomicon*][nomicon]."},{"DocComment":""},{"DocComment":" [book]: ../../book/ch13-01-closures.html"},{"DocComment":" [function pointers]: fn"},{"DocComment":" [nomicon]: ../../nomicon/hrtb.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ## Calling a mutably capturing closure"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let mut x = 5;"},{"DocComment":" {"},{"DocComment":" let mut square_x = || x *= x;"},{"DocComment":" square_x();"},{"DocComment":" }"},{"DocComment":" assert_eq!(x, 25);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Using a `FnMut` parameter"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" fn do_twice(mut func: F)"},{"DocComment":" where F: FnMut()"},{"DocComment":" {"},{"DocComment":" func();"},{"DocComment":" func();"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let mut x: usize = 1;"},{"DocComment":" {"},{"DocComment":" let add_two_to_x = || x += 2;"},{"DocComment":" do_twice(add_two_to_x);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert_eq!(x, 5);"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Args = \"()\", note =\n\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}`\"),\non(Self = \"unsafe fn\", note =\n\"unsafe function cannot be called generically without an unsafe block\", label\n= \"call the function in a closure: `|| unsafe {{ /* code */ }}`\"), message =\n\"expected a `{Trait}` closure, found `{Self}`\", label =\n\"expected an `{Trait}` closure, found `{Self}`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"fn_mut"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":16,"beg":{"line":163,"col":0},"end":{"line":167,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":16,"beg":{"line":163,"col":36},"end":{"line":163,"col":48}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":16,"beg":{"line":163,"col":22},"end":{"line":163,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":16,"beg":{"line":163,"col":28},"end":{"line":163,"col":33}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"call_mut","attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1729},{"Deduplicated":1585}],"output":{"HashConsedValue":[6177,{"TraitType":[{"HashConsedValue":[6176,{"kind":{"ParentClause":[{"HashConsedValue":[4781,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}},"item":{"id":186,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"Deduplicated":4781}]}}},"kind":{"TraitMethod":[9,0]}}],"vtable":{"id":{"Adt":45},"generics":{"regions":[],"types":[{"Deduplicated":1589},{"HashConsedValue":[6180,{"TraitType":[{"HashConsedValue":[6179,{"kind":{"ParentClause":[{"HashConsedValue":[6178,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":10,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]}],"span":{"data":{"file_id":11,"beg":{"line":134,"col":0},"end":{"line":134,"col":32}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Conversion from an [`Iterator`]."},{"DocComment":""},{"DocComment":" By implementing `FromIterator` for a type, you define how it will be"},{"DocComment":" created from an iterator. This is common for types which describe a"},{"DocComment":" collection of some kind."},{"DocComment":""},{"DocComment":" If you want to create a collection from the contents of an iterator, the"},{"DocComment":" [`Iterator::collect()`] method is preferred. However, when you need to"},{"DocComment":" specify the container type, [`FromIterator::from_iter()`] can be more"},{"DocComment":" readable than using a turbofish (e.g. `::>()`). See the"},{"DocComment":" [`Iterator::collect()`] documentation for more examples of its use."},{"DocComment":""},{"DocComment":" See also: [`IntoIterator`]."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v = Vec::from_iter(five_fives);"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Using [`Iterator::collect()`] to implicitly use `FromIterator`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v: Vec = five_fives.collect();"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Using [`FromIterator::from_iter()`] as a more readable alternative to"},{"DocComment":" [`Iterator::collect()`]:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::collections::VecDeque;"},{"DocComment":" let first = (0..10).collect::>();"},{"DocComment":" let second = VecDeque::from_iter(0..10);"},{"DocComment":""},{"DocComment":" assert_eq!(first, second);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Implementing `FromIterator` for your type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // A sample collection, that's just a wrapper over Vec"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct MyCollection(Vec);"},{"DocComment":""},{"DocComment":" // Let's give it some methods so we can create one and add things"},{"DocComment":" // to it."},{"DocComment":" impl MyCollection {"},{"DocComment":" fn new() -> MyCollection {"},{"DocComment":" MyCollection(Vec::new())"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn add(&mut self, elem: i32) {"},{"DocComment":" self.0.push(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // and we'll implement FromIterator"},{"DocComment":" impl FromIterator for MyCollection {"},{"DocComment":" fn from_iter>(iter: I) -> Self {"},{"DocComment":" let mut c = MyCollection::new();"},{"DocComment":""},{"DocComment":" for i in iter {"},{"DocComment":" c.add(i);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" c"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Now we can make a new iterator..."},{"DocComment":" let iter = (0..5).into_iter();"},{"DocComment":""},{"DocComment":" // ... and make a MyCollection out of it"},{"DocComment":" let c = MyCollection::from_iter(iter);"},{"DocComment":""},{"DocComment":" assert_eq!(c.0, vec![0, 1, 2, 3, 4]);"},{"DocComment":""},{"DocComment":" // collect works too!"},{"DocComment":""},{"DocComment":" let iter = (0..5).into_iter();"},{"DocComment":" let c: MyCollection = iter.collect();"},{"DocComment":""},{"DocComment":" assert_eq!(c.0, vec![0, 1, 2, 3, 4]);"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Self = \"&[{A}]\", message =\n\"a slice of type `{Self}` cannot be built since we need to store the elements somewhere\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(all(A = \"{integer}\", any(Self = \"&[{integral}]\",)), message =\n\"a slice of type `{Self}` cannot be built since we need to store the elements somewhere\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(Self = \"[{A}]\", message =\n\"a slice of type `{Self}` cannot be built since `{Self}` has no definite size\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(all(A = \"{integer}\", any(Self = \"[{integral}]\",)), message =\n\"a slice of type `{Self}` cannot be built since `{Self}` has no definite size\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(Self = \"[{A}; _]\", message =\n\"an array of type `{Self}` cannot be built directly from an iterator\", label =\n\"try collecting into a `Vec<{A}>`, then using `.try_into()`\",),\non(all(A = \"{integer}\", any(Self = \"[{integral}; _]\",)), message =\n\"an array of type `{Self}` cannot be built directly from an iterator\", label =\n\"try collecting into a `Vec<{A}>`, then using `.try_into()`\",), message =\n\"a value of type `{Self}` cannot be built from an iterator \\\n over elements of type `{A}`\",\nlabel =\n\"value of type `{Self}` cannot be built from `std::iter::Iterator`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"FromIterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":134,"col":27},"end":{"line":134,"col":32}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":134,"col":23},"end":{"line":134,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":152,"col":17},"end":{"line":152,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":152,"col":20},"end":{"line":152,"col":42}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[3889,{"kind":{"Clause":{"Bound":[1,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":2246}}}]},"skip_binder":{"name":"from_iter","attr_info":{"attributes":[{"DocComment":" Creates a value from an iterator."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v = Vec::from_iter(five_fives);"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":164}},"item":{"id":187,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585},{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5673,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":10,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"HashConsedValue":[3890,{"kind":{"Clause":{"Bound":[0,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[10,0]}}],"vtable":null},{"def_id":11,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]}],"span":{"data":{"file_id":42,"beg":{"line":133,"col":0},"end":{"line":133,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The `?` operator and `try {}` blocks."},{"DocComment":""},{"DocComment":" `try_*` methods typically involve a type implementing this trait. For"},{"DocComment":" example, the closures passed to [`Iterator::try_fold`] and"},{"DocComment":" [`Iterator::try_for_each`] must return such a type."},{"DocComment":""},{"DocComment":" `Try` types are typically those containing two or more categories of values,"},{"DocComment":" some subset of which are so commonly handled via early returns that it's"},{"DocComment":" worth providing a terse (but still visible) syntax to make that easy."},{"DocComment":""},{"DocComment":" This is most often seen for error handling with [`Result`] and [`Option`]."},{"DocComment":" The quintessential implementation of this trait is on [`ControlFlow`]."},{"DocComment":""},{"DocComment":" # Using `Try` in Generic Code"},{"DocComment":""},{"DocComment":" `Iterator::try_fold` was stabilized to call back in Rust 1.27, but"},{"DocComment":" this trait is much newer. To illustrate the various associated types and"},{"DocComment":" methods, let's implement our own version."},{"DocComment":""},{"DocComment":" As a reminder, an infallible version of a fold looks something like this:"},{"DocComment":" ```"},{"DocComment":" fn simple_fold("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> A,"},{"DocComment":" ) -> A {"},{"DocComment":" for x in iter {"},{"DocComment":" accum = f(accum, x);"},{"DocComment":" }"},{"DocComment":" accum"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" So instead of `f` returning just an `A`, we'll need it to return some other"},{"DocComment":" type that produces an `A` in the \"don't short circuit\" path. Conveniently,"},{"DocComment":" that's also the type we need to return from the function."},{"DocComment":""},{"DocComment":" Let's add a new generic parameter `R` for that type, and bound it to the"},{"DocComment":" output type that we want:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::Try;"},{"DocComment":" fn simple_try_fold_1>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" todo!()"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" If we get through the entire iterator, we need to wrap up the accumulator"},{"DocComment":" into the return type using [`Try::from_output`]:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::{ControlFlow, Try};"},{"DocComment":" fn simple_try_fold_2>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" for x in iter {"},{"DocComment":" let cf = f(accum, x).branch();"},{"DocComment":" match cf {"},{"DocComment":" ControlFlow::Continue(a) => accum = a,"},{"DocComment":" ControlFlow::Break(_) => todo!(),"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" R::from_output(accum)"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" We'll also need [`FromResidual::from_residual`] to turn the residual back"},{"DocComment":" into the original type. But because it's a supertrait of `Try`, we don't"},{"DocComment":" need to mention it in the bounds. All types which implement `Try` can be"},{"DocComment":" recreated from their corresponding residual, so we'll just call it:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::{ControlFlow, Try};"},{"DocComment":" pub fn simple_try_fold_3>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" for x in iter {"},{"DocComment":" let cf = f(accum, x).branch();"},{"DocComment":" match cf {"},{"DocComment":" ControlFlow::Continue(a) => accum = a,"},{"DocComment":" ControlFlow::Break(r) => return R::from_residual(r),"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" R::from_output(accum)"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" But this \"call `branch`, then `match` on it, and `return` if it was a"},{"DocComment":" `Break`\" is exactly what happens inside the `?` operator. So rather than"},{"DocComment":" do all this manually, we can just use `?` instead:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::Try;"},{"DocComment":" fn simple_try_fold>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" for x in iter {"},{"DocComment":" accum = f(accum, x)?;"},{"DocComment":" }"},{"DocComment":" R::from_output(accum)"},{"DocComment":" }"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(all(from_desugaring = \"TryBlock\"), message =\n\"a `try` block must return `Result` or `Option` \\\n (or another type that implements `{This}`)\",\nlabel =\n\"could not wrap the final value of the block as `{Self}` doesn't implement `Try`\",),\non(all(from_desugaring = \"QuestionMark\"), message =\n\"the `?` operator can only be applied to values that implement `{This}`\",\nlabel = \"the `?` operator cannot be applied to type `{Self}`\")"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Try"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":42,"beg":{"line":133,"col":0},"end":{"line":220,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":42,"beg":{"line":133,"col":21},"end":{"line":133,"col":41}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":164},{"HashConsedValue":[4813,{"TraitType":[{"HashConsedValue":[4812,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":42,"beg":{"line":136,"col":4},"end":{"line":136,"col":16}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[4826,{"TraitType":[{"Deduplicated":4812},0]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":42,"beg":{"line":160,"col":4},"end":{"line":160,"col":18}},"generated_from_span":null},"origin":{"TraitItem":1},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":4813}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Output","attr_info":{"attributes":[{"DocComment":" The type of the value produced by `?` when *not* short-circuiting."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Residual","attr_info":{"attributes":[{"DocComment":" The type of the value passed to [`FromResidual::from_residual`]"},{"DocComment":" as part of `?` when short-circuiting."},{"DocComment":""},{"DocComment":" This represents the possible values of the `Self` type which are *not*"},{"DocComment":" represented by the `Output` type."},{"DocComment":""},{"DocComment":" # Note to Implementors"},{"DocComment":""},{"DocComment":" The choice of this type is critical to interconversion."},{"DocComment":" Unlike the `Output` type, which will often be a raw generic type,"},{"DocComment":" this type is typically a newtype of some sort to \"color\" the type"},{"DocComment":" so that it's distinguishable from the residuals of other types."},{"DocComment":""},{"DocComment":" This is why `Result::Residual` is not `E`, but `Result`."},{"DocComment":" That way it's distinct from `ControlFlow::Residual`, for example,"},{"DocComment":" and thus `?` on `ControlFlow` cannot be used in a method returning `Result`."},{"DocComment":""},{"DocComment":" If you're making a generic type `Foo` that implements `Try`,"},{"DocComment":" then typically you can use `Foo` as its `Residual`"},{"DocComment":" type: that type will have a \"hole\" in the correct place, and will maintain the"},{"DocComment":" \"foo-ness\" of the residual so other types need to opt-in to interconversion."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[11,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"from_output","attr_info":{"attributes":[{"DocComment":" Constructs the type from its `Output` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method"},{"DocComment":" such that applying the `?` operator will get back the original value:"},{"DocComment":" `Try::from_output(x).branch() --> ControlFlow::Continue(x)`."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::Try;"},{"DocComment":""},{"DocComment":" assert_eq!( as Try>::from_output(3), Ok(3));"},{"DocComment":" assert_eq!( as Try>::from_output(4), Some(4));"},{"DocComment":" assert_eq!("},{"DocComment":" as Try>::from_output(5),"},{"DocComment":" std::ops::ControlFlow::Continue(5),"},{"DocComment":" );"},{"DocComment":""},{"DocComment":" # fn make_question_mark_work() -> Option<()> {"},{"DocComment":" assert_eq!(Option::from_output(4)?, 4);"},{"DocComment":" # None }"},{"DocComment":" # make_question_mark_work();"},{"DocComment":""},{"DocComment":" // This is used, for example, on the accumulator in `try_fold`:"},{"DocComment":" let r = std::iter::empty().try_fold(4, |_, ()| -> Option<_> { unreachable!() });"},{"DocComment":" assert_eq!(r, Some(4));"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4826}],"output":{"Deduplicated":164}},"item":{"id":188,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":4812}]}}},"kind":{"TraitMethod":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"branch","attr_info":{"attributes":[{"DocComment":" Used in `?` to decide whether the operator should produce a value"},{"DocComment":" (because this returned [`ControlFlow::Continue`])"},{"DocComment":" or propagate a value back to the caller"},{"DocComment":" (because this returned [`ControlFlow::Break`])."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, Try};"},{"DocComment":""},{"DocComment":" assert_eq!(Ok::<_, String>(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(Err::(3).branch(), ControlFlow::Break(Err(3)));"},{"DocComment":""},{"DocComment":" assert_eq!(Some(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(None::.branch(), ControlFlow::Break(None));"},{"DocComment":""},{"DocComment":" assert_eq!(ControlFlow::::Continue(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::Break(3).branch(),"},{"DocComment":" ControlFlow::Break(ControlFlow::Break(3)),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":164}],"output":{"HashConsedValue":[6185,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"Deduplicated":4813},{"Deduplicated":4826}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6182,{"kind":{"ParentClause":[{"HashConsedValue":[6181,{"kind":{"ParentClause":[{"Deduplicated":4812},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"HashConsedValue":[4820,{"TraitType":[{"HashConsedValue":[4818,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":1619}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":4820}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6184,{"kind":{"ParentClause":[{"Deduplicated":4812},2]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6183,{"TraitType":[{"Deduplicated":4818},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"item":{"id":189,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":4812}]}}},"kind":{"TraitMethod":[11,1]}}],"vtable":null},{"def_id":12,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Residual",0]}],"span":{"data":{"file_id":42,"beg":{"line":364,"col":0},"end":{"line":364,"col":34}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Allows retrieving the canonical type implementing [`Try`] that has this type"},{"DocComment":" as its residual and allows it to hold an `O` as its output."},{"DocComment":""},{"DocComment":" If you think of the `Try` trait as splitting a type into its [`Try::Output`]"},{"DocComment":" and [`Try::Residual`] components, this allows putting them back together."},{"DocComment":""},{"DocComment":" For example,"},{"DocComment":" `Result: Try>`,"},{"DocComment":" and in the other direction,"},{"DocComment":" ` as Residual>::TryType = Result`."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"O"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[5679,{"kind":{"ParentClause":[{"HashConsedValue":[5557,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":12,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},3]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"HashConsedValue":[5559,{"TraitType":[{"HashConsedValue":[4852,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":12,"generics":{"regions":[],"types":[{"Deduplicated":1619},{"HashConsedValue":[4587,{"TypeVar":{"Bound":[3,1]}}]}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":1585}}},{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5679},"type_id":1,"ty":{"Deduplicated":164}}}]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":42,"beg":{"line":364,"col":29},"end":{"line":364,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":42,"beg":{"line":364,"col":25},"end":{"line":364,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":42,"beg":{"line":368,"col":4},"end":{"line":368,"col":59}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5558,{"TraitType":[{"Deduplicated":5557},0]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":42,"beg":{"line":368,"col":18},"end":{"line":368,"col":58}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":5558}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"TryType","attr_info":{"attributes":[{"DocComment":" The \"return\" type of this meta-function."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[12,0]}}],"methods":[],"vtable":null},{"def_id":13,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]}],"span":{"data":{"file_id":11,"beg":{"line":397,"col":0},"end":{"line":397,"col":19}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Extend a collection with the contents of an iterator."},{"DocComment":""},{"DocComment":" Iterators produce a series of values, and collections can also be thought"},{"DocComment":" of as a series of values. The `Extend` trait bridges this gap, allowing you"},{"DocComment":" to extend a collection by including the contents of that iterator. When"},{"DocComment":" extending a collection with an already existing key, that entry is updated"},{"DocComment":" or, in the case of collections that permit multiple entries with equal"},{"DocComment":" keys, that entry is inserted."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // You can extend a String with some chars:"},{"DocComment":" let mut message = String::from(\"The first three letters are: \");"},{"DocComment":""},{"DocComment":" message.extend(&['a', 'b', 'c']);"},{"DocComment":""},{"DocComment":" assert_eq!(\"abc\", &message[29..32]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Implementing `Extend`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // A sample collection, that's just a wrapper over Vec"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct MyCollection(Vec);"},{"DocComment":""},{"DocComment":" // Let's give it some methods so we can create one and add things"},{"DocComment":" // to it."},{"DocComment":" impl MyCollection {"},{"DocComment":" fn new() -> MyCollection {"},{"DocComment":" MyCollection(Vec::new())"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn add(&mut self, elem: i32) {"},{"DocComment":" self.0.push(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // since MyCollection has a list of i32s, we implement Extend for i32"},{"DocComment":" impl Extend for MyCollection {"},{"DocComment":""},{"DocComment":" // This is a bit simpler with the concrete type signature: we can call"},{"DocComment":" // extend on anything which can be turned into an Iterator which gives"},{"DocComment":" // us i32s. Because we need i32s to put into MyCollection."},{"DocComment":" fn extend>(&mut self, iter: T) {"},{"DocComment":""},{"DocComment":" // The implementation is very straightforward: loop through the"},{"DocComment":" // iterator, and add() each element to ourselves."},{"DocComment":" for elem in iter {"},{"DocComment":" self.add(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let mut c = MyCollection::new();"},{"DocComment":""},{"DocComment":" c.add(5);"},{"DocComment":" c.add(6);"},{"DocComment":" c.add(7);"},{"DocComment":""},{"DocComment":" // let's extend our collection with three more numbers"},{"DocComment":" c.extend(vec![1, 2, 3]);"},{"DocComment":""},{"DocComment":" // we've added these elements onto the end"},{"DocComment":" assert_eq!(\"MyCollection([5, 6, 7, 1, 2, 3])\", format!(\"{c:?}\"));"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":397,"col":0},"end":{"line":451,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":397,"col":17},"end":{"line":397,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":416,"col":14},"end":{"line":416,"col":15}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":416,"col":17},"end":{"line":416,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":3889},"type_id":0,"ty":{"Deduplicated":2246}}}]},"skip_binder":{"name":"extend","attr_info":{"attributes":[{"DocComment":" Extends a collection with the contents of an iterator."},{"DocComment":""},{"DocComment":" As this is the only required method for this trait, the [trait-level] docs"},{"DocComment":" contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: Extend"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // You can extend a String with some chars:"},{"DocComment":" let mut message = String::from(\"abc\");"},{"DocComment":""},{"DocComment":" message.extend(['d', 'e', 'f'].iter());"},{"DocComment":""},{"DocComment":" assert_eq!(\"abcdef\", &message);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1729},{"Deduplicated":196}],"output":{"Deduplicated":221}},"item":{"id":190,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":164},{"Deduplicated":1585},{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5680,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":13,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"Deduplicated":3890}]}}},"kind":{"TraitMethod":[13,0]}},null,null,null],"vtable":null},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]}],"span":{"data":{"file_id":43,"beg":{"line":107,"col":0},"end":{"line":107,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A trait for giving a type a useful default value."},{"DocComment":""},{"DocComment":" Sometimes, you want to fall back to some kind of default value, and"},{"DocComment":" don't particularly care what it is. This comes up often with `struct`s"},{"DocComment":" that define a set of options:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" struct SomeOptions {"},{"DocComment":" foo: i32,"},{"DocComment":" bar: f32,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" How can we define some default values? You can use `Default`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" #[derive(Default)]"},{"DocComment":" struct SomeOptions {"},{"DocComment":" foo: i32,"},{"DocComment":" bar: f32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn main() {"},{"DocComment":" let options: SomeOptions = Default::default();"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Now, you get all of the default values. Rust implements `Default` for various primitive types."},{"DocComment":""},{"DocComment":" If you want to override a particular option, but still retain the other defaults:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" # #[derive(Default)]"},{"DocComment":" # struct SomeOptions {"},{"DocComment":" # foo: i32,"},{"DocComment":" # bar: f32,"},{"DocComment":" # }"},{"DocComment":" fn main() {"},{"DocComment":" let options = SomeOptions { foo: 42, ..Default::default() };"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]` if all of the type's fields implement"},{"DocComment":" `Default`. When `derive`d, it will use the default value for each field's type."},{"DocComment":""},{"DocComment":" ### `enum`s"},{"DocComment":""},{"DocComment":" When using `#[derive(Default)]` on an `enum`, you need to choose which unit variant will be"},{"DocComment":" default. You do this by placing the `#[default]` attribute on the variant."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Default)]"},{"DocComment":" enum Kind {"},{"DocComment":" #[default]"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" You cannot use the `#[default]` attribute on non-unit or non-exhaustive variants."},{"DocComment":""},{"DocComment":" The `#[default]` attribute was stabilized in Rust 1.62.0."},{"DocComment":""},{"DocComment":" ## How can I implement `Default`?"},{"DocComment":""},{"DocComment":" Provide an implementation for the `default()` method that returns the value of"},{"DocComment":" your type that should be the default:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" enum Kind {"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Default for Kind {"},{"DocComment":" fn default() -> Self { Kind::A }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" #[derive(Default)]"},{"DocComment":" struct SomeOptions {"},{"DocComment":" foo: i32,"},{"DocComment":" bar: f32,"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Default"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":43,"beg":{"line":107,"col":25},"end":{"line":107,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"default","attr_info":{"attributes":[{"DocComment":" Returns the \"default value\" for a type."},{"DocComment":""},{"DocComment":" Default values are often some kind of initial value, identity value, or anything else that"},{"DocComment":" may make sense as a default."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Using built-in default values:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let i: i8 = Default::default();"},{"DocComment":" let (x, y): (Option, f64) = Default::default();"},{"DocComment":" let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Making your own:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" enum Kind {"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Default for Kind {"},{"DocComment":" fn default() -> Self { Kind::A }"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[],"output":{"Deduplicated":164}},"item":{"id":194,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5681,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":14,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[14,0]}}],"vtable":null},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]}],"span":{"data":{"file_id":44,"beg":{"line":41,"col":0},"end":{"line":41,"col":39}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator able to yield elements from both ends."},{"DocComment":""},{"DocComment":" Something that implements `DoubleEndedIterator` has one extra capability"},{"DocComment":" over something that implements [`Iterator`]: the ability to also take"},{"DocComment":" `Item`s from the back, as well as the front."},{"DocComment":""},{"DocComment":" It is important to note that both back and forth work on the same range,"},{"DocComment":" and do not cross: iteration is over when they meet in the middle."},{"DocComment":""},{"DocComment":" In a similar fashion to the [`Iterator`] protocol, once a"},{"DocComment":" `DoubleEndedIterator` returns [`None`] from a [`next_back()`], calling it"},{"DocComment":" again may or may not ever return [`Some`] again. [`next()`] and"},{"DocComment":" [`next_back()`] are interchangeable for this purpose."},{"DocComment":""},{"DocComment":" [`next_back()`]: DoubleEndedIterator::next_back"},{"DocComment":" [`next()`]: Iterator::next"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let numbers = vec![1, 2, 3, 4, 5, 6];"},{"DocComment":""},{"DocComment":" let mut iter = numbers.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(&1), iter.next());"},{"DocComment":" assert_eq!(Some(&6), iter.next_back());"},{"DocComment":" assert_eq!(Some(&5), iter.next_back());"},{"DocComment":" assert_eq!(Some(&2), iter.next());"},{"DocComment":" assert_eq!(Some(&3), iter.next());"},{"DocComment":" assert_eq!(Some(&4), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next_back());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"DoubleEndedIterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":44,"beg":{"line":41,"col":0},"end":{"line":380,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":44,"beg":{"line":41,"col":31},"end":{"line":41,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"next_back","attr_info":{"attributes":[{"DocComment":" Removes and returns an element from the end of the iterator."},{"DocComment":""},{"DocComment":" Returns `None` when there are no more elements."},{"DocComment":""},{"DocComment":" The [trait-level] docs contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: DoubleEndedIterator"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let numbers = vec![1, 2, 3, 4, 5, 6];"},{"DocComment":""},{"DocComment":" let mut iter = numbers.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(&1), iter.next());"},{"DocComment":" assert_eq!(Some(&6), iter.next_back());"},{"DocComment":" assert_eq!(Some(&5), iter.next_back());"},{"DocComment":" assert_eq!(Some(&2), iter.next());"},{"DocComment":" assert_eq!(Some(&3), iter.next());"},{"DocComment":" assert_eq!(Some(&4), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next_back());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Remarks"},{"DocComment":""},{"DocComment":" The elements yielded by `DoubleEndedIterator`'s methods may differ from"},{"DocComment":" the ones yielded by [`Iterator`]'s methods:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let vec = vec![(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b')];"},{"DocComment":" let uniq_by_fst_comp = || {"},{"DocComment":" let mut seen = std::collections::HashSet::new();"},{"DocComment":" vec.iter().copied().filter(move |x| seen.insert(x.0))"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" assert_eq!(uniq_by_fst_comp().last(), Some((2, 'a')));"},{"DocComment":" assert_eq!(uniq_by_fst_comp().next_back(), Some((2, 'b')));"},{"DocComment":""},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().fold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(1, 'a'), (2, 'a')]"},{"DocComment":" );"},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().rfold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(2, 'b'), (1, 'c')]"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1729}],"output":{"HashConsedValue":[6188,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[6186,{"TraitType":[{"HashConsedValue":[4916,{"kind":{"ParentClause":[{"HashConsedValue":[4915,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6187,{"kind":{"ParentClause":[{"Deduplicated":4916},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[4920,{"TraitType":[{"HashConsedValue":[4919,{"kind":{"ParentClause":[{"HashConsedValue":[4918,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":1619}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1619}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"item":{"id":195,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":4915}]}}},"kind":{"TraitMethod":[15,0]}},null,null,null,null,null],"vtable":{"id":{"Adt":46},"generics":{"regions":[],"types":[{"HashConsedValue":[6191,{"TraitType":[{"HashConsedValue":[6190,{"kind":{"ParentClause":[{"HashConsedValue":[6189,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]}],"span":{"data":{"file_id":45,"beg":{"line":86,"col":0},"end":{"line":86,"col":37}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that knows its exact length."},{"DocComment":""},{"DocComment":" Many [`Iterator`]s don't know how many times they will iterate, but some do."},{"DocComment":" If an iterator knows how many times it can iterate, providing access to"},{"DocComment":" that information can be useful. For example, if you want to iterate"},{"DocComment":" backwards, a good start is to know where the end is."},{"DocComment":""},{"DocComment":" When implementing an `ExactSizeIterator`, you must also implement"},{"DocComment":" [`Iterator`]. When doing so, the implementation of [`Iterator::size_hint`]"},{"DocComment":" *must* return the exact size of the iterator."},{"DocComment":""},{"DocComment":" The [`len`] method has a default implementation, so you usually shouldn't"},{"DocComment":" implement it. However, you may be able to provide a more performant"},{"DocComment":" implementation than the default, so overriding it in this case makes sense."},{"DocComment":""},{"DocComment":" Note that this trait is a safe trait and as such does *not* and *cannot*"},{"DocComment":" guarantee that the returned length is correct. This means that `unsafe`"},{"DocComment":" code **must not** rely on the correctness of [`Iterator::size_hint`]. The"},{"DocComment":" unstable and unsafe [`TrustedLen`](super::marker::TrustedLen) trait gives"},{"DocComment":" this additional guarantee."},{"DocComment":""},{"DocComment":" [`len`]: ExactSizeIterator::len"},{"DocComment":""},{"DocComment":" # When *shouldn't* an adapter be `ExactSizeIterator`?"},{"DocComment":""},{"DocComment":" If an adapter makes an iterator *longer*, then it's usually incorrect for"},{"DocComment":" that adapter to implement `ExactSizeIterator`. The inner exact-sized"},{"DocComment":" iterator might already be `usize::MAX`-long, and thus the length of the"},{"DocComment":" longer adapted iterator would no longer be exactly representable in `usize`."},{"DocComment":""},{"DocComment":" This is why [`Chain`](crate::iter::Chain) isn't `ExactSizeIterator`,"},{"DocComment":" even when `A` and `B` are both `ExactSizeIterator`."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // a finite range knows exactly how many times it will iterate"},{"DocComment":" let five = 0..5;"},{"DocComment":""},{"DocComment":" assert_eq!(5, five.len());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" In the [module-level docs], we implemented an [`Iterator`], `Counter`."},{"DocComment":" Let's implement `ExactSizeIterator` for it as well:"},{"DocComment":""},{"DocComment":" [module-level docs]: crate::iter"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # struct Counter {"},{"DocComment":" # count: usize,"},{"DocComment":" # }"},{"DocComment":" # impl Counter {"},{"DocComment":" # fn new() -> Counter {"},{"DocComment":" # Counter { count: 0 }"},{"DocComment":" # }"},{"DocComment":" # }"},{"DocComment":" # impl Iterator for Counter {"},{"DocComment":" # type Item = usize;"},{"DocComment":" # fn next(&mut self) -> Option {"},{"DocComment":" # self.count += 1;"},{"DocComment":" # if self.count < 6 {"},{"DocComment":" # Some(self.count)"},{"DocComment":" # } else {"},{"DocComment":" # None"},{"DocComment":" # }"},{"DocComment":" # }"},{"DocComment":" # }"},{"DocComment":" impl ExactSizeIterator for Counter {"},{"DocComment":" // We can easily calculate the remaining number of iterations."},{"DocComment":" fn len(&self) -> usize {"},{"DocComment":" 5 - self.count"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // And now we can use it!"},{"DocComment":""},{"DocComment":" let mut counter = Counter::new();"},{"DocComment":""},{"DocComment":" assert_eq!(5, counter.len());"},{"DocComment":" let _ = counter.next();"},{"DocComment":" assert_eq!(4, counter.len());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":45,"beg":{"line":86,"col":0},"end":{"line":151,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":45,"beg":{"line":86,"col":29},"end":{"line":86,"col":37}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[null,null],"vtable":{"id":{"Adt":47},"generics":{"regions":[],"types":[{"HashConsedValue":[6194,{"TraitType":[{"HashConsedValue":[6193,{"kind":{"ParentClause":[{"HashConsedValue":[6192,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":16,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]}],"span":{"data":{"file_id":46,"beg":{"line":973,"col":0},"end":{"line":973,"col":73}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order)."},{"DocComment":""},{"DocComment":" Implementations must be consistent with the [`PartialOrd`] implementation, and ensure `max`,"},{"DocComment":" `min`, and `clamp` are consistent with `cmp`:"},{"DocComment":""},{"DocComment":" - `partial_cmp(a, b) == Some(cmp(a, b))`."},{"DocComment":" - `max(a, b) == max_by(a, b, cmp)` (ensured by the default implementation)."},{"DocComment":" - `min(a, b) == min_by(a, b, cmp)` (ensured by the default implementation)."},{"DocComment":" - For `a.clamp(min, max)`, see the [method docs](#method.clamp) (ensured by the default"},{"DocComment":" implementation)."},{"DocComment":""},{"DocComment":" Violating these requirements is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" ## Corollaries"},{"DocComment":""},{"DocComment":" From the above and the requirements of `PartialOrd`, it follows that for all `a`, `b` and `c`:"},{"DocComment":""},{"DocComment":" - exactly one of `a < b`, `a == b` or `a > b` is true; and"},{"DocComment":" - `<` is transitive: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and"},{"DocComment":" `>`."},{"DocComment":""},{"DocComment":" Mathematically speaking, the `<` operator defines a strict [weak order]. In cases where `==`"},{"DocComment":" conforms to mathematical equality, it also defines a strict [total order]."},{"DocComment":""},{"DocComment":" [weak order]: https://en.wikipedia.org/wiki/Weak_ordering"},{"DocComment":" [total order]: https://en.wikipedia.org/wiki/Total_order"},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`."},{"DocComment":""},{"DocComment":" When `derive`d on structs, it will produce a"},{"DocComment":" [lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering based on the"},{"DocComment":" top-to-bottom declaration order of the struct's members."},{"DocComment":""},{"DocComment":" When `derive`d on enums, variants are ordered primarily by their discriminants. Secondarily,"},{"DocComment":" they are ordered by their fields. By default, the discriminant is smallest for variants at the"},{"DocComment":" top, and largest for variants at the bottom. Here's an example:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, Eq, PartialOrd, Ord)]"},{"DocComment":" enum E {"},{"DocComment":" Top,"},{"DocComment":" Bottom,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Top < E::Bottom);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" However, manually setting the discriminants can override this default behavior:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, Eq, PartialOrd, Ord)]"},{"DocComment":" enum E {"},{"DocComment":" Top = 2,"},{"DocComment":" Bottom = 1,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Bottom < E::Top);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Lexicographical comparison"},{"DocComment":""},{"DocComment":" Lexicographical comparison is an operation with the following properties:"},{"DocComment":" - Two sequences are compared element by element."},{"DocComment":" - The first mismatching element defines which sequence is lexicographically less or greater"},{"DocComment":" than the other."},{"DocComment":" - If one sequence is a prefix of another, the shorter sequence is lexicographically less than"},{"DocComment":" the other."},{"DocComment":" - If two sequences have equivalent elements and are of the same length, then the sequences are"},{"DocComment":" lexicographically equal."},{"DocComment":" - An empty sequence is lexicographically less than any non-empty sequence."},{"DocComment":" - Two empty sequences are lexicographically equal."},{"DocComment":""},{"DocComment":" ## How can I implement `Ord`?"},{"DocComment":""},{"DocComment":" `Ord` requires that the type also be [`PartialOrd`], [`PartialEq`], and [`Eq`]."},{"DocComment":""},{"DocComment":" Because `Ord` implies a stronger ordering relationship than [`PartialOrd`], and both `Ord` and"},{"DocComment":" [`PartialOrd`] must agree, you must choose how to implement `Ord` **first**. You can choose to"},{"DocComment":" derive it, or implement it manually. If you derive it, you should derive all four traits. If you"},{"DocComment":" implement it manually, you should manually implement all four traits, based on the"},{"DocComment":" implementation of `Ord`."},{"DocComment":""},{"DocComment":" Here's an example where you want to define the `Character` comparison by `health` and"},{"DocComment":" `experience` only, disregarding the field `mana`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" struct Character {"},{"DocComment":" health: u32,"},{"DocComment":" experience: u32,"},{"DocComment":" mana: f32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Character {"},{"DocComment":" fn cmp(&self, other: &Self) -> Ordering {"},{"DocComment":" self.experience"},{"DocComment":" .cmp(&other.experience)"},{"DocComment":" .then(self.health.cmp(&other.health))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Character {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.health == other.health && self.experience == other.experience"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Character {}"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" If all you need is to `slice::sort` a type by a field value, it can be simpler to use"},{"DocComment":" `slice::sort_by_key`."},{"DocComment":""},{"DocComment":" ## Examples of incorrect `Ord` implementations"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct Character {"},{"DocComment":" health: f32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Character {"},{"DocComment":" fn cmp(&self, other: &Self) -> std::cmp::Ordering {"},{"DocComment":" if self.health < other.health {"},{"DocComment":" Ordering::Less"},{"DocComment":" } else if self.health > other.health {"},{"DocComment":" Ordering::Greater"},{"DocComment":" } else {"},{"DocComment":" Ordering::Equal"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Character {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.health == other.health"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Character {}"},{"DocComment":""},{"DocComment":" let a = Character { health: 4.5 };"},{"DocComment":" let b = Character { health: f32::NAN };"},{"DocComment":""},{"DocComment":" // Mistake: floating-point values do not form a total order and using the built-in comparison"},{"DocComment":" // operands to implement `Ord` irregardless of that reality does not change it. Use"},{"DocComment":" // `f32::total_cmp` if you need a total order for floating-point values."},{"DocComment":""},{"DocComment":" // Reflexivity requirement of `Ord` is not given."},{"DocComment":" assert!(a == a);"},{"DocComment":" assert!(b != b);"},{"DocComment":""},{"DocComment":" // Antisymmetry requirement of `Ord` is not given. Only one of a < c and c < a is allowed to be"},{"DocComment":" // true, not both or neither."},{"DocComment":" assert_eq!((a < b) as u8 + (b < a) as u8, 0);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct Character {"},{"DocComment":" health: u32,"},{"DocComment":" experience: u32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Character {"},{"DocComment":" fn cmp(&self, other: &Self) -> std::cmp::Ordering {"},{"DocComment":" if self.health < 50 {"},{"DocComment":" self.health.cmp(&other.health)"},{"DocComment":" } else {"},{"DocComment":" self.experience.cmp(&other.experience)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // For performance reasons implementing `PartialEq` this way is not the idiomatic way, but it"},{"DocComment":" // ensures consistent behavior between `PartialEq`, `PartialOrd` and `Ord` in this example."},{"DocComment":" impl PartialEq for Character {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.cmp(other) == Ordering::Equal"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Character {}"},{"DocComment":""},{"DocComment":" let a = Character {"},{"DocComment":" health: 3,"},{"DocComment":" experience: 5,"},{"DocComment":" };"},{"DocComment":" let b = Character {"},{"DocComment":" health: 10,"},{"DocComment":" experience: 77,"},{"DocComment":" };"},{"DocComment":" let c = Character {"},{"DocComment":" health: 143,"},{"DocComment":" experience: 2,"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" // Mistake: The implementation of `Ord` compares different fields depending on the value of"},{"DocComment":" // `self.health`, the resulting order is not total."},{"DocComment":""},{"DocComment":" // Transitivity requirement of `Ord` is not given. If a is smaller than b and b is smaller than"},{"DocComment":" // c, by transitive property a must also be smaller than c."},{"DocComment":" assert!(a < b && b < c && c < a);"},{"DocComment":""},{"DocComment":" // Antisymmetry requirement of `Ord` is not given. Only one of a < c and c < a is allowed to be"},{"DocComment":" // true, not both or neither."},{"DocComment":" assert_eq!((a < c) as u8 + (c < a) as u8, 2);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The documentation of [`PartialOrd`] contains further examples, for example it's wrong for"},{"DocComment":" [`PartialOrd`] and [`PartialEq`] to disagree."},{"DocComment":""},{"DocComment":" [`cmp`]: Ord::cmp"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Ord"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":46,"beg":{"line":973,"col":21},"end":{"line":973,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":27,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":46,"beg":{"line":973,"col":34},"end":{"line":973,"col":58}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"cmp","attr_info":{"attributes":[{"DocComment":" This method returns an [`Ordering`] between `self` and `other`."},{"DocComment":""},{"DocComment":" By convention, `self.cmp(&other)` returns the ordering matching the expression"},{"DocComment":" `self other` if true."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" assert_eq!(5.cmp(&10), Ordering::Less);"},{"DocComment":" assert_eq!(10.cmp(&5), Ordering::Greater);"},{"DocComment":" assert_eq!(5.cmp(&5), Ordering::Equal);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1854},{"HashConsedValue":[6195,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":164},"Shared"]}]}],"output":{"Deduplicated":3603}},"item":{"id":203,"generics":{"regions":[{"Var":{"Bound":[0,0]}},{"Var":{"Bound":[0,1]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5692,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[17,0]}},null,null,null],"vtable":null},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Copy",0]}],"span":{"data":{"file_id":1,"beg":{"line":457,"col":0},"end":{"line":457,"col":21}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Types whose values can be duplicated simply by copying bits."},{"DocComment":""},{"DocComment":" By default, variable bindings have 'move semantics.' In other"},{"DocComment":" words:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct Foo;"},{"DocComment":""},{"DocComment":" let x = Foo;"},{"DocComment":""},{"DocComment":" let y = x;"},{"DocComment":""},{"DocComment":" // `x` has moved into `y`, and so cannot be used"},{"DocComment":""},{"DocComment":" // println!(\"{x:?}\"); // error: use of moved value"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" However, if a type implements `Copy`, it instead has 'copy semantics':"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // We can derive a `Copy` implementation. `Clone` is also required, as it's"},{"DocComment":" // a supertrait of `Copy`."},{"DocComment":" #[derive(Debug, Copy, Clone)]"},{"DocComment":" struct Foo;"},{"DocComment":""},{"DocComment":" let x = Foo;"},{"DocComment":""},{"DocComment":" let y = x;"},{"DocComment":""},{"DocComment":" // `y` is a copy of `x`"},{"DocComment":""},{"DocComment":" println!(\"{x:?}\"); // A-OK!"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" It's important to note that in these two examples, the only difference is whether you"},{"DocComment":" are allowed to access `x` after the assignment. Under the hood, both a copy and a move"},{"DocComment":" can result in bits being copied in memory, although this is sometimes optimized away."},{"DocComment":""},{"DocComment":" ## How can I implement `Copy`?"},{"DocComment":""},{"DocComment":" There are two ways to implement `Copy` on your type. The simplest is to use `derive`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct MyStruct;"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" You can also implement `Copy` and `Clone` manually:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" struct MyStruct;"},{"DocComment":""},{"DocComment":" impl Copy for MyStruct { }"},{"DocComment":""},{"DocComment":" impl Clone for MyStruct {"},{"DocComment":" fn clone(&self) -> MyStruct {"},{"DocComment":" *self"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" There is a small difference between the two. The `derive` strategy will also place a `Copy`"},{"DocComment":" bound on type parameters:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Clone)]"},{"DocComment":" struct MyStruct(T);"},{"DocComment":""},{"DocComment":" impl Copy for MyStruct { }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" This isn't always desired. For example, shared references (`&T`) can be copied regardless of"},{"DocComment":" whether `T` is `Copy`. Likewise, a generic struct containing markers such as [`PhantomData`]"},{"DocComment":" could potentially be duplicated with a bit-wise copy."},{"DocComment":""},{"DocComment":" ## What's the difference between `Copy` and `Clone`?"},{"DocComment":""},{"DocComment":" Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of"},{"DocComment":" `Copy` is not overloadable; it is always a simple bit-wise copy."},{"DocComment":""},{"DocComment":" Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can"},{"DocComment":" provide any type-specific behavior necessary to duplicate values safely. For example,"},{"DocComment":" the implementation of [`Clone`] for [`String`] needs to copy the pointed-to string"},{"DocComment":" buffer in the heap. A simple bitwise copy of [`String`] values would merely copy the"},{"DocComment":" pointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]"},{"DocComment":" but not `Copy`."},{"DocComment":""},{"DocComment":" [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement"},{"DocComment":" [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`"},{"DocComment":" (see the example above)."},{"DocComment":""},{"DocComment":" ## When can my type be `Copy`?"},{"DocComment":""},{"DocComment":" A type can implement `Copy` if all of its components implement `Copy`. For example, this"},{"DocComment":" struct can be `Copy`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct Point {"},{"DocComment":" x: i32,"},{"DocComment":" y: i32,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`."},{"DocComment":" By contrast, consider"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" # struct Point;"},{"DocComment":" struct PointList {"},{"DocComment":" points: Vec,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The struct `PointList` cannot implement `Copy`, because [`Vec`] is not `Copy`. If we"},{"DocComment":" attempt to derive a `Copy` implementation, we'll get an error:"},{"DocComment":""},{"DocComment":" ```text"},{"DocComment":" the trait `Copy` cannot be implemented for this type; field `points` does not implement `Copy`"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Shared references (`&T`) are also `Copy`, so a type can be `Copy`, even when it holds"},{"DocComment":" shared references of types `T` that are *not* `Copy`. Consider the following struct,"},{"DocComment":" which can implement `Copy`, because it only holds a *shared reference* to our non-`Copy`"},{"DocComment":" type `PointList` from above:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" # struct PointList;"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct PointListWrapper<'a> {"},{"DocComment":" point_list_ref: &'a PointList,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## When *can't* my type be `Copy`?"},{"DocComment":""},{"DocComment":" Some types can't be copied safely. For example, copying `&mut T` would create an aliased"},{"DocComment":" mutable reference. Copying [`String`] would duplicate responsibility for managing the"},{"DocComment":" [`String`]'s buffer, leading to a double free."},{"DocComment":""},{"DocComment":" Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's"},{"DocComment":" managing some resource besides its own [`size_of::`] bytes."},{"DocComment":""},{"DocComment":" If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get"},{"DocComment":" the error [E0204]."},{"DocComment":""},{"DocComment":" [E0204]: ../../error_codes/E0204.html"},{"DocComment":""},{"DocComment":" ## When *should* my type be `Copy`?"},{"DocComment":""},{"DocComment":" Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,"},{"DocComment":" that implementing `Copy` is part of the public API of your type. If the type might become"},{"DocComment":" non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to"},{"DocComment":" avoid a breaking API change."},{"DocComment":""},{"DocComment":" ## Additional implementors"},{"DocComment":""},{"DocComment":" In addition to the [implementors listed below][impls],"},{"DocComment":" the following types also implement `Copy`:"},{"DocComment":""},{"DocComment":" * Function item types (i.e., the distinct types defined for each function)"},{"DocComment":" * Function pointer types (e.g., `fn() -> i32`)"},{"DocComment":" * Closure types, if they capture no value from the environment"},{"DocComment":" or if all such captured values implement `Copy` themselves."},{"DocComment":" Note that variables captured by shared reference always implement `Copy`"},{"DocComment":" (even if the referent doesn't),"},{"DocComment":" while variables captured by mutable reference never implement `Copy`."},{"DocComment":""},{"DocComment":" [`Vec`]: ../../std/vec/struct.Vec.html"},{"DocComment":" [`String`]: ../../std/string/struct.String.html"},{"DocComment":" [`size_of::`]: size_of"},{"DocComment":" [impls]: #implementors"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"copy"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":1,"beg":{"line":457,"col":0},"end":{"line":459,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":1,"beg":{"line":457,"col":16},"end":{"line":457,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":19,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]}],"span":{"data":{"file_id":52,"beg":{"line":17,"col":0},"end":{"line":17,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait to represent types that can be created by summing up an iterator."},{"DocComment":""},{"DocComment":" This trait is used to implement [`Iterator::sum()`]. Types which implement"},{"DocComment":" this trait can be generated by using the [`sum()`] method on an iterator."},{"DocComment":" Like [`FromIterator`], this trait should rarely be called directly."},{"DocComment":""},{"DocComment":" [`sum()`]: Iterator::sum"},{"DocComment":" [`FromIterator`]: iter::FromIterator"},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message =\n\"a value of type `{Self}` cannot be made by summing an iterator over elements of type `{A}`\",\nlabel =\n\"value of type `{Self}` cannot be made by summing a `std::iter::Iterator`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":17,"col":25},"end":{"line":17,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":17,"col":14},"end":{"line":17,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":21,"col":11},"end":{"line":21,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":21,"col":14},"end":{"line":21,"col":32}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":4567},"type_id":0,"ty":{"Deduplicated":2246}}}]},"skip_binder":{"name":"sum","attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by \"summing up\""},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":164}},"item":{"id":207,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585},{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5693,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":19,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"Deduplicated":4562}]}}},"kind":{"TraitMethod":[19,0]}}],"vtable":null},{"def_id":20,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]}],"span":{"data":{"file_id":52,"beg":{"line":38,"col":0},"end":{"line":38,"col":34}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait to represent types that can be created by multiplying elements of an"},{"DocComment":" iterator."},{"DocComment":""},{"DocComment":" This trait is used to implement [`Iterator::product()`]. Types which implement"},{"DocComment":" this trait can be generated by using the [`product()`] method on an iterator."},{"DocComment":" Like [`FromIterator`], this trait should rarely be called directly."},{"DocComment":""},{"DocComment":" [`product()`]: Iterator::product"},{"DocComment":" [`FromIterator`]: iter::FromIterator"},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message =\n\"a value of type `{Self}` cannot be made by multiplying all elements of type `{A}` from an iterator\",\nlabel =\n\"value of type `{Self}` cannot be made by multiplying all elements from a `std::iter::Iterator`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":38,"col":29},"end":{"line":38,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":38,"col":18},"end":{"line":38,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":42,"col":15},"end":{"line":42,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":42,"col":18},"end":{"line":42,"col":36}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":4567},"type_id":0,"ty":{"Deduplicated":2246}}}]},"skip_binder":{"name":"product","attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by multiplying"},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":196}],"output":{"Deduplicated":164}},"item":{"id":208,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585},{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5694,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"Deduplicated":4562}]}}},"kind":{"TraitMethod":[20,0]}}],"vtable":null},{"def_id":21,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]}],"span":{"data":{"file_id":46,"beg":{"line":1358,"col":0},"end":{"line":1359,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for types that form a [partial order](https://en.wikipedia.org/wiki/Partial_order)."},{"DocComment":""},{"DocComment":" The `lt`, `le`, `gt`, and `ge` methods of this trait can be called using the `<`, `<=`, `>`, and"},{"DocComment":" `>=` operators, respectively."},{"DocComment":""},{"DocComment":" This trait should **only** contain the comparison logic for a type **if one plans on only"},{"DocComment":" implementing `PartialOrd` but not [`Ord`]**. Otherwise the comparison logic should be in [`Ord`]"},{"DocComment":" and this trait implemented with `Some(self.cmp(other))`."},{"DocComment":""},{"DocComment":" The methods of this trait must be consistent with each other and with those of [`PartialEq`]."},{"DocComment":" The following conditions must hold:"},{"DocComment":""},{"DocComment":" 1. `a == b` if and only if `partial_cmp(a, b) == Some(Equal)`."},{"DocComment":" 2. `a < b` if and only if `partial_cmp(a, b) == Some(Less)`"},{"DocComment":" 3. `a > b` if and only if `partial_cmp(a, b) == Some(Greater)`"},{"DocComment":" 4. `a <= b` if and only if `a < b || a == b`"},{"DocComment":" 5. `a >= b` if and only if `a > b || a == b`"},{"DocComment":" 6. `a != b` if and only if `!(a == b)`."},{"DocComment":""},{"DocComment":" Conditions 2–5 above are ensured by the default implementation. Condition 6 is already ensured"},{"DocComment":" by [`PartialEq`]."},{"DocComment":""},{"DocComment":" If [`Ord`] is also implemented for `Self` and `Rhs`, it must also be consistent with"},{"DocComment":" `partial_cmp` (see the documentation of that trait for the exact requirements). It's easy to"},{"DocComment":" accidentally make them disagree by deriving some of the traits and manually implementing others."},{"DocComment":""},{"DocComment":" The comparison relations must satisfy the following conditions (for all `a`, `b`, `c` of type"},{"DocComment":" `A`, `B`, `C`):"},{"DocComment":""},{"DocComment":" - **Transitivity**: if `A: PartialOrd` and `B: PartialOrd` and `A: PartialOrd`, then `a"},{"DocComment":" < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`. This must also"},{"DocComment":" work for longer chains, such as when `A: PartialOrd`, `B: PartialOrd`, `C:"},{"DocComment":" PartialOrd`, and `A: PartialOrd` all exist."},{"DocComment":" - **Duality**: if `A: PartialOrd` and `B: PartialOrd`, then `a < b` if and only if `b >"},{"DocComment":" a`."},{"DocComment":""},{"DocComment":" Note that the `B: PartialOrd` (dual) and `A: PartialOrd` (transitive) impls are not forced"},{"DocComment":" to exist, but these requirements apply whenever they do exist."},{"DocComment":""},{"DocComment":" Violating these requirements is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" ## Cross-crate considerations"},{"DocComment":""},{"DocComment":" Upholding the requirements stated above can become tricky when one crate implements `PartialOrd`"},{"DocComment":" for a type of another crate (i.e., to allow comparing one of its own types with a type from the"},{"DocComment":" standard library). The recommendation is to never implement this trait for a foreign type. In"},{"DocComment":" other words, such a crate should do `impl PartialOrd for LocalType`, but it should"},{"DocComment":" *not* do `impl PartialOrd for ForeignType`."},{"DocComment":""},{"DocComment":" This avoids the problem of transitive chains that criss-cross crate boundaries: for all local"},{"DocComment":" types `T`, you may assume that no other crate will add `impl`s that allow comparing `T < U`. In"},{"DocComment":" other words, if other crates add `impl`s that allow building longer transitive chains `U1 < ..."},{"DocComment":" < T < V1 < ...`, then all the types that appear to the right of `T` must be types that the crate"},{"DocComment":" defining `T` already knows about. This rules out transitive chains where downstream crates can"},{"DocComment":" add new `impl`s that \"stitch together\" comparisons of foreign types in ways that violate"},{"DocComment":" transitivity."},{"DocComment":""},{"DocComment":" Not having such foreign `impl`s also avoids forward compatibility issues where one crate adding"},{"DocComment":" more `PartialOrd` implementations can cause build failures in downstream crates."},{"DocComment":""},{"DocComment":" ## Corollaries"},{"DocComment":""},{"DocComment":" The following corollaries follow from the above requirements:"},{"DocComment":""},{"DocComment":" - irreflexivity of `<` and `>`: `!(a < a)`, `!(a > a)`"},{"DocComment":" - transitivity of `>`: if `a > b` and `b > c` then `a > c`"},{"DocComment":" - duality of `partial_cmp`: `partial_cmp(a, b) == partial_cmp(b, a).map(Ordering::reverse)`"},{"DocComment":""},{"DocComment":" ## Strict and non-strict partial orders"},{"DocComment":""},{"DocComment":" The `<` and `>` operators behave according to a *strict* partial order. However, `<=` and `>=`"},{"DocComment":" do **not** behave according to a *non-strict* partial order. That is because mathematically, a"},{"DocComment":" non-strict partial order would require reflexivity, i.e. `a <= a` would need to be true for"},{"DocComment":" every `a`. This isn't always the case for types that implement `PartialOrd`, for example:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let a = f64::NAN;"},{"DocComment":" assert_eq!(a <= a, false);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`."},{"DocComment":""},{"DocComment":" When `derive`d on structs, it will produce a"},{"DocComment":" [lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering based on the"},{"DocComment":" top-to-bottom declaration order of the struct's members."},{"DocComment":""},{"DocComment":" When `derive`d on enums, variants are primarily ordered by their discriminants. Secondarily,"},{"DocComment":" they are ordered by their fields. By default, the discriminant is smallest for variants at the"},{"DocComment":" top, and largest for variants at the bottom. Here's an example:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, PartialOrd)]"},{"DocComment":" enum E {"},{"DocComment":" Top,"},{"DocComment":" Bottom,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Top < E::Bottom);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" However, manually setting the discriminants can override this default behavior:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, PartialOrd)]"},{"DocComment":" enum E {"},{"DocComment":" Top = 2,"},{"DocComment":" Bottom = 1,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Bottom < E::Top);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## How can I implement `PartialOrd`?"},{"DocComment":""},{"DocComment":" `PartialOrd` only requires implementation of the [`partial_cmp`] method, with the others"},{"DocComment":" generated from default implementations."},{"DocComment":""},{"DocComment":" However it remains possible to implement the others separately for types which do not have a"},{"DocComment":" total order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 == false`"},{"DocComment":" (cf. IEEE 754-2008 section 5.11)."},{"DocComment":""},{"DocComment":" `PartialOrd` requires your type to be [`PartialEq`]."},{"DocComment":""},{"DocComment":" If your type is [`Ord`], you can implement [`partial_cmp`] by using [`cmp`]:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" struct Person {"},{"DocComment":" id: u32,"},{"DocComment":" name: String,"},{"DocComment":" height: u32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Person {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Person {"},{"DocComment":" fn cmp(&self, other: &Self) -> Ordering {"},{"DocComment":" self.height.cmp(&other.height)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Person {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.height == other.height"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Person {}"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" You may also find it useful to use [`partial_cmp`] on your type's fields. Here is an example of"},{"DocComment":" `Person` types who have a floating-point `height` field that is the only field to be used for"},{"DocComment":" sorting:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" struct Person {"},{"DocComment":" id: u32,"},{"DocComment":" name: String,"},{"DocComment":" height: f64,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Person {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" self.height.partial_cmp(&other.height)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Person {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.height == other.height"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Examples of incorrect `PartialOrd` implementations"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" #[derive(PartialEq, Debug)]"},{"DocComment":" struct Character {"},{"DocComment":" health: u32,"},{"DocComment":" experience: u32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.health.cmp(&other.health))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let a = Character {"},{"DocComment":" health: 10,"},{"DocComment":" experience: 5,"},{"DocComment":" };"},{"DocComment":" let b = Character {"},{"DocComment":" health: 10,"},{"DocComment":" experience: 77,"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" // Mistake: `PartialEq` and `PartialOrd` disagree with each other."},{"DocComment":""},{"DocComment":" assert_eq!(a.partial_cmp(&b).unwrap(), Ordering::Equal); // a == b according to `PartialOrd`."},{"DocComment":" assert_ne!(a, b); // a != b according to `PartialEq`."},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let x: u32 = 0;"},{"DocComment":" let y: u32 = 1;"},{"DocComment":""},{"DocComment":" assert_eq!(x < y, true);"},{"DocComment":" assert_eq!(x.lt(&y), true);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`partial_cmp`]: PartialOrd::partial_cmp"},{"DocComment":" [`cmp`]: Ord::cmp"},{"Unknown":{"path":"rustc_on_unimplemented","args":"message = \"can't compare `{Self}` with `{Rhs}`\", label =\n\"no implementation for `{Self} < {Rhs}` and `{Self} > {Rhs}`\",\nappend_const_msg"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"partial_ord"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":46,"beg":{"line":1359,"col":4},"end":{"line":1359,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"partial_cmp","attr_info":{"attributes":[{"DocComment":" This method returns an ordering between `self` and `other` values if one exists."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&2.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Less));"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Equal));"},{"DocComment":""},{"DocComment":" let result = 2.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Greater));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" When comparison is impossible:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let result = f64::NAN.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, None);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1854},{"HashConsedValue":[5140,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":1585},"Shared"]}]}],"output":{"Deduplicated":3972}},"item":{"id":209,"generics":{"regions":[{"Var":{"Bound":[0,0]}},{"Var":{"Bound":[0,1]}}],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5695,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[21,0]}},null,null,null,null,null,null,null,null],"vtable":{"id":{"Adt":48},"generics":{"regions":[],"types":[{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}}},{"def_id":22,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]}],"span":{"data":{"file_id":46,"beg":{"line":251,"col":0},"end":{"line":251,"col":65}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for comparisons using the equality operator."},{"DocComment":""},{"DocComment":" Implementing this trait for types provides the `==` and `!=` operators for"},{"DocComment":" those types."},{"DocComment":""},{"DocComment":" `x.eq(y)` can also be written `x == y`, and `x.ne(y)` can be written `x != y`."},{"DocComment":" We use the easier-to-read infix notation in the remainder of this documentation."},{"DocComment":""},{"DocComment":" This trait allows for comparisons using the equality operator, for types"},{"DocComment":" that do not have a full equivalence relation. For example, in floating point"},{"DocComment":" numbers `NaN != NaN`, so floating point types implement `PartialEq` but not"},{"DocComment":" [`trait@Eq`]. Formally speaking, when `Rhs == Self`, this trait corresponds"},{"DocComment":" to a [partial equivalence relation]."},{"DocComment":""},{"DocComment":" [partial equivalence relation]: https://en.wikipedia.org/wiki/Partial_equivalence_relation"},{"DocComment":""},{"DocComment":" Implementations must ensure that `eq` and `ne` are consistent with each other:"},{"DocComment":""},{"DocComment":" - `a != b` if and only if `!(a == b)`."},{"DocComment":""},{"DocComment":" The default implementation of `ne` provides this consistency and is almost"},{"DocComment":" always sufficient. It should not be overridden without very good reason."},{"DocComment":""},{"DocComment":" If [`PartialOrd`] or [`Ord`] are also implemented for `Self` and `Rhs`, their methods must also"},{"DocComment":" be consistent with `PartialEq` (see the documentation of those traits for the exact"},{"DocComment":" requirements). It's easy to accidentally make them disagree by deriving some of the traits and"},{"DocComment":" manually implementing others."},{"DocComment":""},{"DocComment":" The equality relation `==` must satisfy the following conditions"},{"DocComment":" (for all `a`, `b`, `c` of type `A`, `B`, `C`):"},{"DocComment":""},{"DocComment":" - **Symmetry**: if `A: PartialEq` and `B: PartialEq`, then **`a == b`"},{"DocComment":" implies `b == a`**; and"},{"DocComment":""},{"DocComment":" - **Transitivity**: if `A: PartialEq` and `B: PartialEq` and `A:"},{"DocComment":" PartialEq`, then **`a == b` and `b == c` implies `a == c`**."},{"DocComment":" This must also work for longer chains, such as when `A: PartialEq`, `B: PartialEq`,"},{"DocComment":" `C: PartialEq`, and `A: PartialEq` all exist."},{"DocComment":""},{"DocComment":" Note that the `B: PartialEq` (symmetric) and `A: PartialEq`"},{"DocComment":" (transitive) impls are not forced to exist, but these requirements apply"},{"DocComment":" whenever they do exist."},{"DocComment":""},{"DocComment":" Violating these requirements is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" ## Cross-crate considerations"},{"DocComment":""},{"DocComment":" Upholding the requirements stated above can become tricky when one crate implements `PartialEq`"},{"DocComment":" for a type of another crate (i.e., to allow comparing one of its own types with a type from the"},{"DocComment":" standard library). The recommendation is to never implement this trait for a foreign type. In"},{"DocComment":" other words, such a crate should do `impl PartialEq for LocalType`, but it should"},{"DocComment":" *not* do `impl PartialEq for ForeignType`."},{"DocComment":""},{"DocComment":" This avoids the problem of transitive chains that criss-cross crate boundaries: for all local"},{"DocComment":" types `T`, you may assume that no other crate will add `impl`s that allow comparing `T == U`. In"},{"DocComment":" other words, if other crates add `impl`s that allow building longer transitive chains `U1 == ..."},{"DocComment":" == T == V1 == ...`, then all the types that appear to the right of `T` must be types that the"},{"DocComment":" crate defining `T` already knows about. This rules out transitive chains where downstream crates"},{"DocComment":" can add new `impl`s that \"stitch together\" comparisons of foreign types in ways that violate"},{"DocComment":" transitivity."},{"DocComment":""},{"DocComment":" Not having such foreign `impl`s also avoids forward compatibility issues where one crate adding"},{"DocComment":" more `PartialEq` implementations can cause build failures in downstream crates."},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`. When `derive`d on structs, two"},{"DocComment":" instances are equal if all fields are equal, and not equal if any fields"},{"DocComment":" are not equal. When `derive`d on enums, two instances are equal if they"},{"DocComment":" are the same variant and all fields are equal."},{"DocComment":""},{"DocComment":" ## How can I implement `PartialEq`?"},{"DocComment":""},{"DocComment":" An example implementation for a domain in which two books are considered"},{"DocComment":" the same book if their ISBN matches, even if the formats differ:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.isbn == other.isbn"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let b1 = Book { isbn: 3, format: BookFormat::Paperback };"},{"DocComment":" let b2 = Book { isbn: 3, format: BookFormat::Ebook };"},{"DocComment":" let b3 = Book { isbn: 10, format: BookFormat::Paperback };"},{"DocComment":""},{"DocComment":" assert!(b1 == b2);"},{"DocComment":" assert!(b1 != b3);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## How can I compare two different types?"},{"DocComment":""},{"DocComment":" The type you can compare with is controlled by `PartialEq`'s type parameter."},{"DocComment":" For example, let's tweak our previous code a bit:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // The derive implements == comparisons"},{"DocComment":" #[derive(PartialEq)]"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Implement == comparisons"},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &BookFormat) -> bool {"},{"DocComment":" self.format == *other"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Implement == comparisons"},{"DocComment":" impl PartialEq for BookFormat {"},{"DocComment":" fn eq(&self, other: &Book) -> bool {"},{"DocComment":" *self == other.format"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let b1 = Book { isbn: 3, format: BookFormat::Paperback };"},{"DocComment":""},{"DocComment":" assert!(b1 == BookFormat::Paperback);"},{"DocComment":" assert!(BookFormat::Ebook != b1);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" By changing `impl PartialEq for Book` to `impl PartialEq for Book`,"},{"DocComment":" we allow `BookFormat`s to be compared with `Book`s."},{"DocComment":""},{"DocComment":" A comparison like the one above, which ignores some fields of the struct,"},{"DocComment":" can be dangerous. It can easily lead to an unintended violation of the"},{"DocComment":" requirements for a partial equivalence relation. For example, if we kept"},{"DocComment":" the above implementation of `PartialEq` for `BookFormat` and added an"},{"DocComment":" implementation of `PartialEq` for `Book` (either via a `#[derive]` or"},{"DocComment":" via the manual implementation from the first example) then the result would"},{"DocComment":" violate transitivity:"},{"DocComment":""},{"DocComment":" ```should_panic"},{"DocComment":" #[derive(PartialEq)]"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" #[derive(PartialEq)]"},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &BookFormat) -> bool {"},{"DocComment":" self.format == *other"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for BookFormat {"},{"DocComment":" fn eq(&self, other: &Book) -> bool {"},{"DocComment":" *self == other.format"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn main() {"},{"DocComment":" let b1 = Book { isbn: 1, format: BookFormat::Paperback };"},{"DocComment":" let b2 = Book { isbn: 2, format: BookFormat::Paperback };"},{"DocComment":""},{"DocComment":" assert!(b1 == BookFormat::Paperback);"},{"DocComment":" assert!(BookFormat::Paperback == b2);"},{"DocComment":""},{"DocComment":" // The following should hold by transitivity but doesn't."},{"DocComment":" assert!(b1 == b2); // <-- PANICS"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let x: u32 = 0;"},{"DocComment":" let y: u32 = 1;"},{"DocComment":""},{"DocComment":" assert_eq!(x == y, false);"},{"DocComment":" assert_eq!(x.eq(&y), false);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`eq`]: PartialEq::eq"},{"DocComment":" [`ne`]: PartialEq::ne"},{"Unknown":{"path":"rustc_on_unimplemented","args":"message = \"can't compare `{Self}` with `{Rhs}`\", label =\n\"no implementation for `{Self} == {Rhs}`\", append_const_msg"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"eq"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"eq","attr_info":{"attributes":[{"DocComment":" Tests for `self` and `other` values to be equal, and is used by `==`."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1854},{"Deduplicated":5140}],"output":{"Deduplicated":211}},"item":{"id":218,"generics":{"regions":[{"Var":{"Bound":[0,0]}},{"Var":{"Bound":[0,1]}}],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6196,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[22,0]}},null],"vtable":{"id":{"Adt":49},"generics":{"regions":[],"types":[{"Deduplicated":1589}],"const_generics":[],"trait_refs":[]}}},{"def_id":23,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["TrustedRandomAccessNoCoerce",0]}],"span":{"data":{"file_id":24,"beg":{"line":585,"col":0},"end":{"line":585,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Like [`TrustedRandomAccess`] but without any of the requirements / guarantees around"},{"DocComment":" coercions to supertypes after `__iterator_get_unchecked` (they aren’t allowed here!), and"},{"DocComment":" without the requirement that subtypes / supertypes implement `TrustedRandomAccessNoCoerce`."},{"DocComment":""},{"DocComment":" This trait was created in PR #85874 to fix soundness issue #85873 without performance regressions."},{"DocComment":" It is subject to change as we might want to build a more generally useful (for performance"},{"DocComment":" optimizations) and more sophisticated trait or trait hierarchy that replaces or extends"},{"DocComment":" [`TrustedRandomAccess`] and `TrustedRandomAccessNoCoerce`."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":24,"beg":{"line":585,"col":46},"end":{"line":585,"col":51}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[{"name":"MAY_HAVE_SIDE_EFFECT","attr_info":{"attributes":[{"DocComment":" `true` if getting an iterator element may have side effects."},{"DocComment":" Remember to take inner iterators into account."}],"inline":null,"rename":null,"public":true},"ty":{"Deduplicated":211},"default":null}],"types":[],"methods":[null],"vtable":null},{"def_id":24,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]}],"span":{"data":{"file_id":42,"beg":{"line":310,"col":0},"end":{"line":310,"col":57}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used to specify which residuals can be converted into which [`crate::ops::Try`] types."},{"DocComment":""},{"DocComment":" Every `Try` type needs to be recreatable from its own associated"},{"DocComment":" `Residual` type, but can also have additional `FromResidual` implementations"},{"DocComment":" to support interconversion with other `Try` types."},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(all(from_desugaring = \"QuestionMark\", Self = \"core::result::Result\",\nR = \"core::option::Option\",), message =\n\"the `?` operator can only be used on `Result`s, not `Option`s, \\\n in {ItemContext} that returns `Result`\",\nlabel = \"use `.ok_or(...)?` to provide an error compatible with `{Self}`\",\nparent_label = \"this function returns a `Result`\"),\non(all(from_desugaring = \"QuestionMark\", Self =\n\"core::result::Result\",), message =\n\"the `?` operator can only be used on `Result`s \\\n in {ItemContext} that returns `Result`\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns a `Result`\"),\non(all(from_desugaring = \"QuestionMark\", Self = \"core::option::Option\", R =\n\"core::result::Result\",), message =\n\"the `?` operator can only be used on `Option`s, not `Result`s, \\\n in {ItemContext} that returns `Option`\",\nlabel = \"use `.ok()?` if you want to discard the `{R}` error information\",\nparent_label = \"this function returns an `Option`\"),\non(all(from_desugaring = \"QuestionMark\", Self = \"core::option::Option\",),\nmessage =\n\"the `?` operator can only be used on `Option`s \\\n in {ItemContext} that returns `Option`\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns an `Option`\"),\non(all(from_desugaring = \"QuestionMark\", Self =\n\"core::ops::control_flow::ControlFlow\", R =\n\"core::ops::control_flow::ControlFlow\",), message =\n\"the `?` operator in {ItemContext} that returns `ControlFlow` \\\n can only be used on other `ControlFlow`s (with the same Break type)\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns a `ControlFlow`\", note =\n\"unlike `Result`, there's no `From`-conversion performed for `ControlFlow`\"),\non(all(from_desugaring = \"QuestionMark\", Self =\n\"core::ops::control_flow::ControlFlow\",), message =\n\"the `?` operator can only be used on `ControlFlow`s \\\n in {ItemContext} that returns `ControlFlow`\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns a `ControlFlow`\",),\non(all(from_desugaring = \"QuestionMark\"), message =\n\"the `?` operator can only be used in {ItemContext} \\\n that returns `Result` or `Option` \\\n (or another type that implements `{This}`)\",\nlabel = \"cannot use the `?` operator in {ItemContext} that returns `{Self}`\",\nparent_label =\n\"this function should return `Result` or `Option` to accept `?`\"),"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"FromResidual"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"R"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":42,"beg":{"line":310,"col":0},"end":{"line":334,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":42,"beg":{"line":310,"col":29},"end":{"line":310,"col":56}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"from_residual","attr_info":{"attributes":[{"DocComment":" Constructs the type from a compatible `Residual` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method such"},{"DocComment":" that applying the `?` operator will get back an equivalent residual:"},{"DocComment":" `FromResidual::from_residual(r).branch() --> ControlFlow::Break(r)`."},{"DocComment":" (The residual is not mandated to be *identical* when interconversion is involved.)"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, FromResidual};"},{"DocComment":""},{"DocComment":" assert_eq!(Result::::from_residual(Err(3_u8)), Err(3));"},{"DocComment":" assert_eq!(Option::::from_residual(None), None);"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::from_residual(ControlFlow::Break(5)),"},{"DocComment":" ControlFlow::Break(5),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1585}],"output":{"Deduplicated":164}},"item":{"id":221,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5697,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":1611},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[24,0]}}],"vtable":null},{"def_id":25,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Tuple",0]}],"span":{"data":{"file_id":1,"beg":{"line":1074,"col":0},"end":{"line":1074,"col":15}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A marker for tuple types."},{"DocComment":""},{"DocComment":" The implementation of this trait is built-in and cannot be implemented"},{"DocComment":" for any user type."},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message = \"`{Self}` is not a tuple\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"tuple_trait"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":1,"beg":{"line":1074,"col":0},"end":{"line":1074,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":26,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["private",0]},{"Ident":["Sealed",0]}],"span":{"data":{"file_id":19,"beg":{"line":46,"col":12},"end":{"line":46,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":19,"beg":{"line":46,"col":12},"end":{"line":46,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":{"id":{"Adt":50},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},{"def_id":27,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Eq",0]}],"span":{"data":{"file_id":46,"beg":{"line":338,"col":0},"end":{"line":338,"col":58}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for comparisons corresponding to [equivalence relations]("},{"DocComment":" https://en.wikipedia.org/wiki/Equivalence_relation)."},{"DocComment":""},{"DocComment":" The primary difference to [`PartialEq`] is the additional requirement for reflexivity. A type"},{"DocComment":" that implements [`PartialEq`] guarantees that for all `a`, `b` and `c`:"},{"DocComment":""},{"DocComment":" - symmetric: `a == b` implies `b == a` and `a != b` implies `!(a == b)`"},{"DocComment":" - transitive: `a == b` and `b == c` implies `a == c`"},{"DocComment":""},{"DocComment":" `Eq`, which builds on top of [`PartialEq`] also implies:"},{"DocComment":""},{"DocComment":" - reflexive: `a == a`"},{"DocComment":""},{"DocComment":" This property cannot be checked by the compiler, and therefore `Eq` is a trait without methods."},{"DocComment":""},{"DocComment":" Violating this property is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" Floating point types such as [`f32`] and [`f64`] implement only [`PartialEq`] but *not* `Eq`"},{"DocComment":" because `NaN` != `NaN`."},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`. When `derive`d, because `Eq` has no extra methods, it"},{"DocComment":" is only informing the compiler that this is an equivalence relation rather than a partial"},{"DocComment":" equivalence relation. Note that the `derive` strategy requires all fields are `Eq`, which isn't"},{"DocComment":" always desired."},{"DocComment":""},{"DocComment":" ## How can I implement `Eq`?"},{"DocComment":""},{"DocComment":" If you cannot use the `derive` strategy, specify that your type implements `Eq`, which has no"},{"DocComment":" extra methods:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.isbn == other.isbn"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Book {}"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Eq"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":46,"beg":{"line":338,"col":20},"end":{"line":338,"col":43}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[null],"vtable":null}],"trait_impls":[{"def_id":0,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}}],"span":{"data":{"file_id":4,"beg":{"line":21,"col":0},"end":{"line":21,"col":36}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":1602}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":4,"beg":{"line":21,"col":9},"end":{"line":21,"col":10}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[6204,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6203,{"Ref":["Erased",{"HashConsedValue":[1603,{"Slice":{"Deduplicated":164}}]},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[5561,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"Deduplicated":5517}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5516}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6205,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5361,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5360,{"Adt":{"id":{"Adt":6},"generics":{"regions":["Erased"],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"HashConsedValue":[1617,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1611}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5360}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6206,{"kind":{"TraitImpl":{"id":1,"generics":{"regions":["Erased"],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":5360}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":1610},"implied_trait_refs":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"HashConsedValue":[1618,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}}}]},"implied_trait_refs":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":12,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":0,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}}},{"def_id":1,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}}],"span":{"data":{"file_id":7,"beg":{"line":153,"col":8},"end":{"line":153,"col":45}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":1625}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":7,"beg":{"line":153,"col":17},"end":{"line":153,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":5361},{"Deduplicated":5561}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":1610},"implied_trait_refs":[]},"kind":{"TraitType":[2,0]}}],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":13,"generics":{"regions":[{"Var":{"Bound":[1,0]}},{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}},"kind":{"TraitMethod":[2,0]}},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"vtable":{"id":1,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}}},{"def_id":2,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":2}}],"span":{"data":{"file_id":11,"beg":{"line":317,"col":0},"end":{"line":317,"col":50}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":11,"beg":{"line":317,"col":5},"end":{"line":317,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":11,"beg":{"line":317,"col":8},"end":{"line":317,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[6213,{"kind":{"ParentClause":[{"Deduplicated":199},0]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6214,{"kind":{"ParentClause":[{"Deduplicated":4562},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":4568}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"Deduplicated":4562}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":4568},"implied_trait_refs":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":164},"implied_trait_refs":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617},{"Deduplicated":4567}]}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"Deduplicated":4562}]}}},{"def_id":3,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":3}}],"span":{"data":{"file_id":3,"beg":{"line":2162,"col":0},"end":{"line":2162,"col":42}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":4574}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":5},"end":{"line":2162,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":8},"end":{"line":2162,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[6217,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[4575,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"Deduplicated":1617},{"Deduplicated":2664}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6219,{"kind":{"TraitImpl":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":1589},{"Deduplicated":1589}],"const_generics":[],"trait_refs":[{"Deduplicated":199},{"Deduplicated":2275},{"Deduplicated":2275},{"HashConsedValue":[6218,{"kind":{"TraitImpl":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":1589}],"const_generics":[],"trait_refs":[{"Deduplicated":2275}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":1585},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":4575},{"Deduplicated":4580}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"Deduplicated":4596}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":164},"implied_trait_refs":[]},"kind":{"TraitType":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":4580},"implied_trait_refs":[]},"kind":{"TraitType":[11,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":175,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"Deduplicated":1617},{"Deduplicated":2664}]}},"kind":{"TraitMethod":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":16,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[{"Deduplicated":1617},{"Deduplicated":2664}]}},"kind":{"TraitMethod":[11,1]}}],"vtable":null},{"def_id":4,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":4}}],"span":{"data":{"file_id":3,"beg":{"line":2182,"col":0},"end":{"line":2183,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":4598},{"Deduplicated":4594}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":5},"end":{"line":2182,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":8},"end":{"line":2182,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":11},"end":{"line":2182,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2626}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":14},"end":{"line":2182,"col":29}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2626},{"Deduplicated":1585}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[6220,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[4601,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":2626}],"const_generics":[],"trait_refs":[{"Deduplicated":1617},{"HashConsedValue":[4600,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2630}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":4596}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":164},{"Deduplicated":1585},{"Deduplicated":2626}],"const_generics":[],"trait_refs":[{"Deduplicated":1617},{"Deduplicated":2664},{"Deduplicated":4600},{"HashConsedValue":[6221,{"kind":{"Clause":{"Bound":[1,3]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2630},{"Deduplicated":2246}],"const_generics":[],"trait_refs":[]}}}}]}]}},"kind":{"TraitMethod":[24,0]}}],"vtable":null},{"def_id":5,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":5}}],"span":{"data":{"file_id":10,"beg":{"line":785,"col":0},"end":{"line":785,"col":27}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":196},{"Deduplicated":196}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":10,"beg":{"line":785,"col":5},"end":{"line":785,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":199},{"Deduplicated":199}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":177,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}},"kind":{"TraitMethod":[3,0]}}],"vtable":null},{"def_id":6,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":6}}],"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"impl_trait":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":4614},{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[6225,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5709,{"Adt":{"id":{"Adt":10},"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[1972,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1971,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6226,{"kind":{"BuiltinOrAuto":{"builtin_data":"Tuple","parent_trait_refs":[{"Deduplicated":1971}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":221}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":332}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":207},"implied_trait_refs":[]},"kind":{"TraitType":[4,0]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":178,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[4,0]}}],"vtable":null},{"def_id":7,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":7}}],"span":{"data":{"file_id":0,"beg":{"line":106,"col":11},"end":{"line":106,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"impl_trait":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":4614}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":181,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[5,0]}}],"vtable":null},{"def_id":8,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":8}}],"span":{"data":{"file_id":6,"beg":{"line":2755,"col":0},"end":{"line":2755,"col":36}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":3361}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2755,"col":5},"end":{"line":2755,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[4634,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[2395,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6229,{"kind":{"TraitImpl":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":196}],"const_generics":[],"trait_refs":[{"Deduplicated":199}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":2395},{"Deduplicated":1533}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":199},{"Deduplicated":1535}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":164},"implied_trait_refs":[]},"kind":{"TraitType":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":1533},"implied_trait_refs":[]},"kind":{"TraitType":[11,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":182,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}},"kind":{"TraitMethod":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}},"kind":{"TraitMethod":[11,1]}}],"vtable":null},{"def_id":9,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":9}}],"span":{"data":{"file_id":6,"beg":{"line":2777,"col":0},"end":{"line":2777,"col":74}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":3361},{"Deduplicated":1533}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2777,"col":5},"end":{"line":2777,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":4634},{"Deduplicated":1535}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":164}],"const_generics":[],"trait_refs":[{"Deduplicated":1617}]}},"kind":{"TraitMethod":[24,0]}}],"vtable":null},{"def_id":10,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":10}}],"span":{"data":{"file_id":19,"beg":{"line":62,"col":12},"end":{"line":62,"col":56}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[1856,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1855,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6231,{"kind":{"TraitImpl":{"id":11,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6232,{"kind":{"TraitImpl":{"id":12,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[4742,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[4741,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6233,{"kind":{"TraitImpl":{"id":13,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":4740},"implied_trait_refs":[]},"kind":{"TraitType":[7,0]}}],"methods":[],"vtable":null},{"def_id":11,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Impl":{"Trait":11}}],"span":{"data":{"file_id":1,"beg":{"line":60,"col":25},"end":{"line":60,"col":62}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":1855},{"HashConsedValue":[6234,{"kind":{"TraitImpl":{"id":14,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":12,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":12}}],"span":{"data":{"file_id":19,"beg":{"line":55,"col":12},"end":{"line":55,"col":47}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":1855}],"consts":[],"types":[],"methods":[],"vtable":{"id":3,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},{"def_id":13,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":13}}],"span":{"data":{"file_id":53,"beg":{"line":17,"col":24},"end":{"line":17,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":4741},{"HashConsedValue":[6235,{"kind":{"TraitImpl":{"id":15,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":14}}],"span":{"data":{"file_id":25,"beg":{"line":612,"col":16},"end":{"line":612,"col":39}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":614}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":1856}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":223,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[8,0]}},null],"vtable":null},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":15}}],"span":{"data":{"file_id":53,"beg":{"line":17,"col":17},"end":{"line":17,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":4740}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":4742}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":225,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[8,0]}},null],"vtable":null}],"ordered_decls":[{"TraitDecl":{"NonRec":1}},{"TraitDecl":{"NonRec":0}},{"Type":{"NonRec":7}},{"TraitDecl":{"NonRec":5}},{"Fun":{"NonRec":19}},{"TraitDecl":{"NonRec":25}},{"TraitDecl":{"NonRec":4}},{"Fun":{"NonRec":18}},{"TraitDecl":{"NonRec":3}},{"Fun":{"NonRec":176}},{"Fun":{"NonRec":177}},{"TraitImpl":{"NonRec":5}},{"Type":{"NonRec":9}},{"TraitDecl":{"NonRec":2}},{"Fun":{"NonRec":15}},{"Fun":{"NonRec":29}},{"Fun":{"NonRec":180}},{"Type":{"NonRec":8}},{"Fun":{"NonRec":179}},{"Fun":{"NonRec":20}},{"Fun":{"NonRec":21}},{"Type":{"NonRec":5}},{"Fun":{"NonRec":16}},{"Fun":{"NonRec":17}},{"Type":{"NonRec":6}},{"Fun":{"NonRec":13}},{"TraitImpl":{"NonRec":1}},{"Fun":{"NonRec":12}},{"Fun":{"NonRec":14}},{"Type":{"NonRec":0}},{"Fun":{"NonRec":0}},{"Fun":{"NonRec":1}},{"Type":{"NonRec":1}},{"Fun":{"NonRec":2}},{"Type":{"NonRec":2}},{"Fun":{"NonRec":3}},{"Fun":{"NonRec":4}},{"Fun":{"NonRec":5}},{"Type":{"NonRec":10}},{"Fun":{"NonRec":181}},{"TraitImpl":{"NonRec":7}},{"Fun":{"NonRec":178}},{"TraitImpl":{"NonRec":6}},{"Fun":{"NonRec":6}},{"Fun":{"NonRec":7}},{"Fun":{"NonRec":8}},{"Fun":{"NonRec":9}},{"Type":{"NonRec":3}},{"Type":{"NonRec":4}},{"Fun":{"NonRec":10}},{"Fun":{"NonRec":11}}]},"has_errors":false} \ No newline at end of file +{"charon_version":"0.1.201","translated":{"crate_name":"charon_corpus","options":{"ullbc":true,"precise_drops":false,"skip_borrowck":false,"mir":null,"rustc_args":[],"targets":[],"monomorphize":false,"monomorphize_mut":null,"start_from":[],"start_from_if_exists":[],"start_from_attribute":null,"start_from_pub":false,"include":[],"opaque":[],"exclude":[],"extract_opaque_bodies":false,"translate_all_methods":false,"lift_associated_types":[],"hide_marker_traits":false,"remove_adt_clauses":false,"hide_allocator":false,"remove_unused_self_clauses":false,"desugar_drops":false,"ops_to_function_calls":false,"index_to_function_calls":false,"treat_box_as_builtin":false,"raw_consts":false,"unsized_strings":false,"reconstruct_fallible_operations":false,"reconstruct_asserts":false,"unbind_item_vars":false,"print_original_ullbc":false,"print_ullbc":false,"print_built_llbc":false,"print_llbc":false,"dest_dir":null,"dest_file":"/Users/youknowone/Projects/pyre-2/build/llbc/corpus.ullbc","no_dedup_serialized_ast":false,"format":null,"no_serialize":false,"no_typecheck":false,"no_normalize":false,"abort_on_error":false,"error_on_warnings":false,"preset":null},"target_information":[{"key":"aarch64-apple-darwin","value":{"target_pointer_size":8,"is_little_endian":true}}],"files":[{"id":0,"name":{"Local":"src/lib.rs"},"crate_name":"charon_corpus","contents":"//! Charon fixture corpus: representative shapes from issue #97.\n//!\n//! 1. `straight_line_add` — straight-line interpreter-shaped function.\n//! 2. `branch_loop_sum` — branch + loop, like opcode dispatch fragments.\n//! 3. `strategy_dispatch` — enum-as-strategy (dict-strategy stand-in).\n//! 4. `desugar_mix` — `?`, `match`, and iterator desugaring together.\n\n#![allow(dead_code)]\n\npub type PyResult = Result;\n\n// 1. Straight-line\n#[inline(never)]\npub fn straight_line_add(a: i64, b: i64, c: i64) -> i64 {\n let s = a + b;\n let t = s * 2;\n t + c\n}\n\n// 2. Branch and loop\n#[inline(never)]\npub fn branch_loop_sum(slice: &[i64], threshold: i64) -> i64 {\n let mut acc: i64 = 0;\n for &v in slice {\n if v > threshold {\n acc += v;\n } else {\n acc -= v;\n }\n }\n acc\n}\n\n// 2b. Iterator element kinds. `next()`'s payload carries one reference for\n// a slice iterator (`core::slice::iter::Iter` yields `Option<&T>`) and none\n// for a by-value one (`core::array::iter::IntoIter` yields `Option`), so\n// the two spell the same `Option<&i64>` payload for different reasons: here\n// the element is `&i64` both times, and only the first has a reference the\n// iterator added. A frontend that peels unconditionally, or never, types one\n// of the two into the wrong register bank.\n#[inline(never)]\npub fn slice_of_refs_sum(slice: &[&i64]) -> i64 {\n let mut acc: i64 = 0;\n for r in slice {\n acc += **r;\n }\n acc\n}\n\n#[inline(never)]\npub fn array_of_refs_sum(refs: [&i64; 3]) -> i64 {\n let mut acc: i64 = 0;\n for r in refs {\n acc += *r;\n }\n acc\n}\n\n// 3. Strategy dispatch (dict-strategy stand-in)\npub enum Strategy {\n Empty,\n IntKeyed { len: usize },\n StrKeyed { len: usize, capacity: usize },\n}\n\n#[inline(never)]\npub fn strategy_len(s: &Strategy) -> usize {\n match s {\n Strategy::Empty => 0,\n Strategy::IntKeyed { len } => *len,\n Strategy::StrKeyed { len, capacity: _ } => *len,\n }\n}\n\n// 4. Desugaring mix: `?`, `match`, and iteration\npub enum Token {\n Add(i64),\n Sub(i64),\n Halt,\n}\n\nfn parse_one(raw: i64) -> PyResult {\n match raw {\n i64::MIN => Ok(Token::Halt),\n 0 => Err(\"halt-zero forbidden\"),\n v if v > 0 => Ok(Token::Add(v)),\n v => Ok(Token::Sub(-v)),\n }\n}\n\n#[inline(never)]\npub fn desugar_mix(input: &[i64]) -> PyResult {\n let mut acc: i64 = 0;\n for &raw in input.iter() {\n let tok = parse_one(raw)?;\n match tok {\n Token::Add(v) => acc += v,\n Token::Sub(v) => acc -= v,\n Token::Halt => break,\n }\n }\n Ok(acc)\n}\n\n// 5. Tuple round-trip: construct a tuple and read both fields\n//\n// Exercises `Rvalue::Aggregate` for a *non-Adt* (tuple) value paired\n// with `Field` projection reads of that same local. The lowering must\n// emit a `__pos_` `FieldRead` symmetric to the construction-side\n// `FieldWrite` chain rather than collapsing every `.N` to the base.\n\n#[inline(never)]\npub fn tuple_roundtrip(a: i64, b: i64) -> i64 {\n let pair = (a + b, a - b);\n pair.0 * pair.1\n}\n\n// 6. Closures\n// `bool_then_closure` is the exact `core::bool::::then` census shape:\n// an opaque combinator taking a `FnOnce` closure that captures a value from\n// the enclosing scope. Charon extracts the closure's `call_once` body as a\n// transparent inherent method of the closure type.\n\n#[inline(never)]\npub fn bool_then_closure(c: bool, x: i64) -> Option {\n c.then(|| x + 1)\n}\n\n// `then_some` is the eager sibling of `then`: it takes an already-evaluated\n// value rather than a closure, so the diamond's `then` arm wraps it in `Some`\n// directly (no `call_once`). Same Opaque-core-combinator residual shape.\n#[inline(never)]\npub fn bool_then_some(c: bool, x: i64) -> Option {\n c.then_some(x + 1)\n}\n\n// 7. Option question mark\n// Exercises `Try::branch` on `Option`: `Some(v)` continues with `v`, while\n// `None` returns `None` normally from the enclosing Option-returning function.\n\n#[inline(never)]\nfn option_source(keep: bool, value: i64) -> Option {\n if keep { Some(value) } else { None }\n}\n\n#[inline(never)]\npub fn option_question_mark(keep: bool, value: i64, addend: i64) -> Option {\n let v = option_source(keep, value)?;\n Some(v + addend)\n}\n\n// A host-registered callback table.\n\n/// The callback a host installs at run time. A bare `fn` pointer, so the set\n/// of addresses that can reach a call through it is not recoverable from this\n/// artifact — the shape used by host-settable callback hooks.\npub type HostCallback = fn(i64) -> i64;\n\npub struct HostRegistry {\n pub slot: HostCallback,\n pub maybe_slot: Option,\n}\n\n/// Call through the registered callback. `front::mir` lowers this to\n/// `OpKind::IndirectCall { graphs: None }` — `indirect_call` with an\n/// unknown PBC family, which `guess_call_kind` answers `residual` for\n/// (`call.py:105`/`137`, `jtransform.py:410-412`). The `__dyn_call`\n/// placeholder it used to reach is an unregistered synthetic path with no\n/// continuation.\n#[inline(never)]\npub fn host_registry_dispatch(reg: &HostRegistry, x: i64) -> i64 {\n (reg.slot)(x)\n}\n\n/// The one-hop `Option` spelling of the same shape.\n#[inline(never)]\npub fn host_registry_dispatch_optional(reg: &HostRegistry, x: i64) -> i64 {\n match reg.maybe_slot {\n Some(f) => f(x),\n None => 0,\n }\n}\n"},{"id":1,"name":{"Local":"/rustc/library/core/src/marker.rs"},"crate_name":"core","contents":null},{"id":2,"name":{"Local":"/rustc/library/core/src/lib.rs"},"crate_name":"core","contents":null},{"id":3,"name":{"Local":"/rustc/library/core/src/result.rs"},"crate_name":"core","contents":null},{"id":4,"name":{"Local":"/rustc/library/core/src/slice/iter.rs"},"crate_name":"core","contents":null},{"id":5,"name":{"Local":"/rustc/library/core/src/slice/mod.rs"},"crate_name":"core","contents":null},{"id":6,"name":{"Local":"/rustc/library/core/src/option.rs"},"crate_name":"core","contents":null},{"id":7,"name":{"Local":"/rustc/library/core/src/slice/iter/macros.rs"},"crate_name":"core","contents":null},{"id":8,"name":{"Local":"/rustc/library/core/src/array/iter.rs"},"crate_name":"core","contents":null},{"id":9,"name":{"Local":"/rustc/library/core/src/array/mod.rs"},"crate_name":"core","contents":null},{"id":10,"name":{"Local":"/rustc/library/core/src/ops/control_flow.rs"},"crate_name":"core","contents":null},{"id":11,"name":{"Local":"/rustc/library/core/src/ops/mod.rs"},"crate_name":"core","contents":null},{"id":12,"name":{"Local":"/rustc/library/core/src/convert/mod.rs"},"crate_name":"core","contents":null},{"id":13,"name":{"Local":"/rustc/library/core/src/iter/traits/collect.rs"},"crate_name":"core","contents":null},{"id":14,"name":{"Local":"/rustc/library/core/src/iter/traits/mod.rs"},"crate_name":"core","contents":null},{"id":15,"name":{"Local":"/rustc/library/core/src/iter/mod.rs"},"crate_name":"core","contents":null},{"id":16,"name":{"Local":"/rustc/library/core/src/iter/traits/iterator.rs"},"crate_name":"core","contents":null},{"id":17,"name":{"Local":"/rustc/library/core/src/bool.rs"},"crate_name":"core","contents":null},{"id":18,"name":{"Local":"/rustc/library/core/src/ops/function.rs"},"crate_name":"core","contents":null},{"id":19,"name":{"Local":"/rustc/library/core/src/num/nonzero.rs"},"crate_name":"core","contents":null},{"id":20,"name":{"Local":"/rustc/library/core/src/num/mod.rs"},"crate_name":"core","contents":null},{"id":21,"name":{"Local":"/rustc/library/core/src/iter/adapters/step_by.rs"},"crate_name":"core","contents":null},{"id":22,"name":{"Local":"/rustc/library/core/src/iter/adapters/mod.rs"},"crate_name":"core","contents":null},{"id":23,"name":{"Local":"/rustc/library/core/src/iter/adapters/chain.rs"},"crate_name":"core","contents":null},{"id":24,"name":{"Local":"/rustc/library/core/src/iter/adapters/zip.rs"},"crate_name":"core","contents":null},{"id":25,"name":{"Local":"/rustc/library/core/src/clone.rs"},"crate_name":"core","contents":null},{"id":26,"name":{"Local":"/rustc/library/core/src/iter/adapters/intersperse.rs"},"crate_name":"core","contents":null},{"id":27,"name":{"Local":"/rustc/library/core/src/iter/adapters/map.rs"},"crate_name":"core","contents":null},{"id":28,"name":{"Local":"/rustc/library/core/src/iter/adapters/filter.rs"},"crate_name":"core","contents":null},{"id":29,"name":{"Local":"/rustc/library/core/src/iter/adapters/filter_map.rs"},"crate_name":"core","contents":null},{"id":30,"name":{"Local":"/rustc/library/core/src/iter/adapters/enumerate.rs"},"crate_name":"core","contents":null},{"id":31,"name":{"Local":"/rustc/library/core/src/iter/adapters/peekable.rs"},"crate_name":"core","contents":null},{"id":32,"name":{"Local":"/rustc/library/core/src/iter/adapters/skip_while.rs"},"crate_name":"core","contents":null},{"id":33,"name":{"Local":"/rustc/library/core/src/iter/adapters/take_while.rs"},"crate_name":"core","contents":null},{"id":34,"name":{"Local":"/rustc/library/core/src/iter/adapters/map_while.rs"},"crate_name":"core","contents":null},{"id":35,"name":{"Local":"/rustc/library/core/src/iter/adapters/skip.rs"},"crate_name":"core","contents":null},{"id":36,"name":{"Local":"/rustc/library/core/src/iter/adapters/take.rs"},"crate_name":"core","contents":null},{"id":37,"name":{"Local":"/rustc/library/core/src/iter/adapters/scan.rs"},"crate_name":"core","contents":null},{"id":38,"name":{"Local":"/rustc/library/core/src/iter/adapters/flatten.rs"},"crate_name":"core","contents":null},{"id":39,"name":{"Local":"/rustc/library/core/src/iter/adapters/map_windows.rs"},"crate_name":"core","contents":null},{"id":40,"name":{"Local":"/rustc/library/core/src/iter/adapters/fuse.rs"},"crate_name":"core","contents":null},{"id":41,"name":{"Local":"/rustc/library/core/src/iter/adapters/inspect.rs"},"crate_name":"core","contents":null},{"id":42,"name":{"Local":"/rustc/library/core/src/ops/try_trait.rs"},"crate_name":"core","contents":null},{"id":43,"name":{"Local":"/rustc/library/core/src/default.rs"},"crate_name":"core","contents":null},{"id":44,"name":{"Local":"/rustc/library/core/src/iter/traits/double_ended.rs"},"crate_name":"core","contents":null},{"id":45,"name":{"Local":"/rustc/library/core/src/iter/traits/exact_size.rs"},"crate_name":"core","contents":null},{"id":46,"name":{"Local":"/rustc/library/core/src/cmp.rs"},"crate_name":"core","contents":null},{"id":47,"name":{"Local":"/rustc/library/core/src/iter/adapters/rev.rs"},"crate_name":"core","contents":null},{"id":48,"name":{"Local":"/rustc/library/core/src/iter/adapters/copied.rs"},"crate_name":"core","contents":null},{"id":49,"name":{"Local":"/rustc/library/core/src/iter/adapters/cloned.rs"},"crate_name":"core","contents":null},{"id":50,"name":{"Local":"/rustc/library/core/src/iter/adapters/cycle.rs"},"crate_name":"core","contents":null},{"id":51,"name":{"Local":"/rustc/library/core/src/iter/adapters/array_chunks.rs"},"crate_name":"core","contents":null},{"id":52,"name":{"Local":"/rustc/library/core/src/iter/traits/accum.rs"},"crate_name":"core","contents":null},{"id":53,"name":{"Local":"/rustc/library/core/src/num/niche_types.rs"},"crate_name":"core","contents":null}],"item_names":[{"key":{"Type":0},"value":[{"Ident":["charon_corpus",0]},{"Ident":["PyResult",0]}]},{"key":{"Fun":0},"value":[{"Ident":["charon_corpus",0]},{"Ident":["straight_line_add",0]}]},{"key":{"Fun":1},"value":[{"Ident":["charon_corpus",0]},{"Ident":["branch_loop_sum",0]}]},{"key":{"Fun":2},"value":[{"Ident":["charon_corpus",0]},{"Ident":["slice_of_refs_sum",0]}]},{"key":{"Fun":3},"value":[{"Ident":["charon_corpus",0]},{"Ident":["array_of_refs_sum",0]}]},{"key":{"Type":1},"value":[{"Ident":["charon_corpus",0]},{"Ident":["Strategy",0]}]},{"key":{"Fun":4},"value":[{"Ident":["charon_corpus",0]},{"Ident":["strategy_len",0]}]},{"key":{"Type":2},"value":[{"Ident":["charon_corpus",0]},{"Ident":["Token",0]}]},{"key":{"Fun":5},"value":[{"Ident":["charon_corpus",0]},{"Ident":["parse_one",0]}]},{"key":{"Fun":6},"value":[{"Ident":["charon_corpus",0]},{"Ident":["desugar_mix",0]}]},{"key":{"Fun":7},"value":[{"Ident":["charon_corpus",0]},{"Ident":["tuple_roundtrip",0]}]},{"key":{"Fun":8},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]}]},{"key":{"Fun":9},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_some",0]}]},{"key":{"Fun":10},"value":[{"Ident":["charon_corpus",0]},{"Ident":["option_source",0]}]},{"key":{"Fun":11},"value":[{"Ident":["charon_corpus",0]},{"Ident":["option_question_mark",0]}]},{"key":{"Type":3},"value":[{"Ident":["charon_corpus",0]},{"Ident":["HostCallback",0]}]},{"key":{"Type":4},"value":[{"Ident":["charon_corpus",0]},{"Ident":["HostRegistry",0]}]},{"key":{"Fun":12},"value":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch",0]}]},{"key":{"Fun":13},"value":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch_optional",0]}]},{"key":{"TraitDecl":0},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Sized",0]}]},{"key":{"Type":5},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Ident":["Result",0]}]},{"key":{"TraitDecl":1},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["MetaSized",0]}]},{"key":{"Type":6},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Ident":["Iter",0]}]},{"key":{"Type":7},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Ident":["Option",0]}]},{"key":{"TraitImpl":0},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}}]},{"key":{"Fun":14},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":1},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}}]},{"key":{"Fun":15},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["next",0]}]},{"key":{"Type":8},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]}]},{"key":{"TraitImpl":2},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":2}}]},{"key":{"Fun":16},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":2}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":3},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}}]},{"key":{"Fun":17},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["next",0]}]},{"key":{"TraitDecl":2},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]}]},{"key":{"TraitImpl":4},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]},{"Impl":{"Trait":4}}]},{"key":{"Fun":18},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]},{"Ident":["drop_in_place",0]}]},{"key":{"Type":9},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["control_flow",0]},{"Ident":["ControlFlow",0]}]},{"key":{"Type":10},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["Infallible",0]}]},{"key":{"Fun":19},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":5,"beg":{"line":101,"col":5},"end":{"line":101,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[188,{"TypeVar":{"Bound":[1,0]}}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"HashConsedValue":[1511,{"Slice":{"HashConsedValue":[220,{"TypeVar":{"Bound":[0,0]}}]}}]},"kind":"InherentImplBlock"}}},{"Ident":["iter",0]}]},{"key":{"TraitImpl":5},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":5}}]},{"key":{"Fun":20},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":5}},{"Ident":["into_iter",0]}]},{"key":{"TraitDecl":3},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]}]},{"key":{"TraitImpl":6},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":6}}]},{"key":{"Fun":21},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":6}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":7},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":7}}]},{"key":{"Fun":22},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":7}},{"Ident":["from_residual",0]}]},{"key":{"TraitDecl":4},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]}]},{"key":{"TraitImpl":8},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":8}}]},{"key":{"Type":11},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]}]},{"key":{"TraitImpl":9},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":9}}]},{"key":{"Fun":23},"value":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"HashConsedValue":[235,{"Literal":"Bool"}]},"kind":"InherentImplBlock"}}},{"Ident":["then",0]}]},{"key":{"TraitDecl":5},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]}]},{"key":{"TraitImpl":10},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":10}}]},{"key":{"Fun":24},"value":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":235},"kind":"InherentImplBlock"}}},{"Ident":["then_some",0]}]},{"key":{"TraitImpl":11},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":11}}]},{"key":{"Fun":25},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":11}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":12},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":12}}]},{"key":{"Fun":26},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":12}},{"Ident":["from_residual",0]}]},{"key":{"Type":12},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["MetaSized",0]},{"Ident":["{vtable}",0]}]},{"key":{"TraitDecl":6},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]}]},{"key":{"Global":0},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}},{"Ident":["{vtable}",0]}]},{"key":{"Global":1},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":27},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["next_chunk",0]}]},{"key":{"Fun":28},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["size_hint",0]}]},{"key":{"Fun":29},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["count",0]}]},{"key":{"Fun":30},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["last",0]}]},{"key":{"Fun":31},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["advance_by",0]}]},{"key":{"Fun":32},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["nth",0]}]},{"key":{"Fun":33},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["step_by",0]}]},{"key":{"Type":13},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":34},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["next",0]}]},{"key":{"Fun":35},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["next_chunk",0]}]},{"key":{"Fun":36},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["size_hint",0]}]},{"key":{"Fun":37},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["count",0]}]},{"key":{"Fun":38},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["last",0]}]},{"key":{"Fun":39},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["advance_by",0]}]},{"key":{"Type":14},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["NonZero",0]}]},{"key":{"TraitDecl":7},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["ZeroablePrimitive",0]}]},{"key":{"TraitImpl":13},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":13}}]},{"key":{"Fun":40},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["nth",0]}]},{"key":{"Fun":41},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["step_by",0]}]},{"key":{"Type":15},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["step_by",0]},{"Ident":["StepBy",0]}]},{"key":{"Fun":42},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["chain",0]}]},{"key":{"Type":16},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["chain",0]},{"Ident":["Chain",0]}]},{"key":{"Fun":43},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["zip",0]}]},{"key":{"Type":17},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["Zip",0]}]},{"key":{"Fun":44},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["intersperse",0]}]},{"key":{"TraitDecl":8},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]}]},{"key":{"Type":18},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["Intersperse",0]}]},{"key":{"Fun":45},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["intersperse_with",0]}]},{"key":{"TraitDecl":9},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]}]},{"key":{"Type":19},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["IntersperseWith",0]}]},{"key":{"Fun":46},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["map",0]}]},{"key":{"Type":20},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map",0]},{"Ident":["Map",0]}]},{"key":{"Fun":47},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["for_each",0]}]},{"key":{"Fun":48},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["filter",0]}]},{"key":{"Type":21},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter",0]},{"Ident":["Filter",0]}]},{"key":{"Fun":49},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["filter_map",0]}]},{"key":{"Type":22},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter_map",0]},{"Ident":["FilterMap",0]}]},{"key":{"Fun":50},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["enumerate",0]}]},{"key":{"Type":23},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["enumerate",0]},{"Ident":["Enumerate",0]}]},{"key":{"Fun":51},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["peekable",0]}]},{"key":{"Type":24},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["peekable",0]},{"Ident":["Peekable",0]}]},{"key":{"Fun":52},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["skip_while",0]}]},{"key":{"Type":25},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip_while",0]},{"Ident":["SkipWhile",0]}]},{"key":{"Fun":53},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["take_while",0]}]},{"key":{"Type":26},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take_while",0]},{"Ident":["TakeWhile",0]}]},{"key":{"Fun":54},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["map_while",0]}]},{"key":{"Type":27},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_while",0]},{"Ident":["MapWhile",0]}]},{"key":{"Fun":55},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["skip",0]}]},{"key":{"Type":28},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip",0]},{"Ident":["Skip",0]}]},{"key":{"Fun":56},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["take",0]}]},{"key":{"Type":29},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take",0]},{"Ident":["Take",0]}]},{"key":{"Fun":57},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["scan",0]}]},{"key":{"Type":30},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["scan",0]},{"Ident":["Scan",0]}]},{"key":{"Fun":58},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["flat_map",0]}]},{"key":{"Type":31},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["FlatMap",0]}]},{"key":{"Fun":59},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["flatten",0]}]},{"key":{"Type":32},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["Flatten",0]}]},{"key":{"Fun":60},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["map_windows",0]}]},{"key":{"Type":33},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_windows",0]},{"Ident":["MapWindows",0]}]},{"key":{"Fun":61},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["fuse",0]}]},{"key":{"Type":34},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["fuse",0]},{"Ident":["Fuse",0]}]},{"key":{"Fun":62},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["inspect",0]}]},{"key":{"Type":35},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["inspect",0]},{"Ident":["Inspect",0]}]},{"key":{"Fun":63},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["by_ref",0]}]},{"key":{"Fun":64},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["collect",0]}]},{"key":{"TraitDecl":10},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]}]},{"key":{"Fun":65},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_collect",0]}]},{"key":{"TraitDecl":11},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]}]},{"key":{"TraitDecl":12},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Residual",0]}]},{"key":{"Fun":66},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["collect_into",0]}]},{"key":{"TraitDecl":13},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]}]},{"key":{"Fun":67},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partition",0]}]},{"key":{"TraitDecl":14},"value":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]}]},{"key":{"Fun":68},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partition_in_place",0]}]},{"key":{"TraitDecl":15},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]}]},{"key":{"Fun":69},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":70},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_fold",0]}]},{"key":{"Fun":71},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_for_each",0]}]},{"key":{"Fun":72},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["fold",0]}]},{"key":{"Fun":73},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["reduce",0]}]},{"key":{"Fun":74},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_reduce",0]}]},{"key":{"Fun":75},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["all",0]}]},{"key":{"Fun":76},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["any",0]}]},{"key":{"Fun":77},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["find",0]}]},{"key":{"Fun":78},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["find_map",0]}]},{"key":{"Fun":79},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["try_find",0]}]},{"key":{"Fun":80},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["position",0]}]},{"key":{"Fun":81},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["rposition",0]}]},{"key":{"TraitDecl":16},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]}]},{"key":{"Fun":82},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["max",0]}]},{"key":{"TraitDecl":17},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]}]},{"key":{"Fun":83},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["min",0]}]},{"key":{"Fun":84},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["max_by_key",0]}]},{"key":{"Fun":85},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["max_by",0]}]},{"key":{"Type":36},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ordering",0]}]},{"key":{"Fun":86},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["min_by_key",0]}]},{"key":{"Fun":87},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["min_by",0]}]},{"key":{"Fun":88},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["rev",0]}]},{"key":{"Type":37},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["rev",0]},{"Ident":["Rev",0]}]},{"key":{"Fun":89},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["unzip",0]}]},{"key":{"Fun":90},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["copied",0]}]},{"key":{"TraitDecl":18},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Copy",0]}]},{"key":{"Type":38},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["copied",0]},{"Ident":["Copied",0]}]},{"key":{"Fun":91},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cloned",0]}]},{"key":{"Type":39},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cloned",0]},{"Ident":["Cloned",0]}]},{"key":{"Fun":92},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cycle",0]}]},{"key":{"Type":40},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cycle",0]},{"Ident":["Cycle",0]}]},{"key":{"Fun":93},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["array_chunks",0]}]},{"key":{"Type":41},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["array_chunks",0]},{"Ident":["ArrayChunks",0]}]},{"key":{"Fun":94},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["sum",0]}]},{"key":{"TraitDecl":19},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]}]},{"key":{"Fun":95},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["product",0]}]},{"key":{"TraitDecl":20},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]}]},{"key":{"Fun":96},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cmp",0]}]},{"key":{"Fun":97},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["cmp_by",0]}]},{"key":{"Fun":98},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partial_cmp",0]}]},{"key":{"TraitDecl":21},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]}]},{"key":{"Fun":99},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":100},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["eq",0]}]},{"key":{"TraitDecl":22},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]}]},{"key":{"Fun":101},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["eq_by",0]}]},{"key":{"Fun":102},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["ne",0]}]},{"key":{"Fun":103},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["lt",0]}]},{"key":{"Fun":104},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["le",0]}]},{"key":{"Fun":105},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["gt",0]}]},{"key":{"Fun":106},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["ge",0]}]},{"key":{"Fun":107},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_sorted",0]}]},{"key":{"Fun":108},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":109},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":110},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"TraitDecl":23},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["TrustedRandomAccessNoCoerce",0]}]},{"key":{"Fun":111},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["chain",0]}]},{"key":{"Fun":112},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["zip",0]}]},{"key":{"Fun":113},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["intersperse",0]}]},{"key":{"Fun":114},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["intersperse_with",0]}]},{"key":{"Fun":115},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["map",0]}]},{"key":{"Fun":116},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["for_each",0]}]},{"key":{"Fun":117},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["filter",0]}]},{"key":{"Fun":118},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["filter_map",0]}]},{"key":{"Fun":119},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["enumerate",0]}]},{"key":{"Fun":120},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["peekable",0]}]},{"key":{"Fun":121},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["skip_while",0]}]},{"key":{"Fun":122},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["take_while",0]}]},{"key":{"Fun":123},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["map_while",0]}]},{"key":{"Fun":124},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["skip",0]}]},{"key":{"Fun":125},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["take",0]}]},{"key":{"Fun":126},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["scan",0]}]},{"key":{"Fun":127},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["flat_map",0]}]},{"key":{"Fun":128},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["flatten",0]}]},{"key":{"Fun":129},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["map_windows",0]}]},{"key":{"Fun":130},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["fuse",0]}]},{"key":{"Fun":131},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["inspect",0]}]},{"key":{"Fun":132},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["by_ref",0]}]},{"key":{"Fun":133},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["collect",0]}]},{"key":{"Fun":134},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_collect",0]}]},{"key":{"Fun":135},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["collect_into",0]}]},{"key":{"Fun":136},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partition",0]}]},{"key":{"Fun":137},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partition_in_place",0]}]},{"key":{"Fun":138},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":139},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_fold",0]}]},{"key":{"Fun":140},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_for_each",0]}]},{"key":{"Fun":141},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["fold",0]}]},{"key":{"Fun":142},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["reduce",0]}]},{"key":{"Fun":143},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_reduce",0]}]},{"key":{"Fun":144},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["all",0]}]},{"key":{"Fun":145},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["any",0]}]},{"key":{"Fun":146},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["find",0]}]},{"key":{"Fun":147},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["find_map",0]}]},{"key":{"Fun":148},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["try_find",0]}]},{"key":{"Fun":149},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["position",0]}]},{"key":{"Fun":150},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["rposition",0]}]},{"key":{"Fun":151},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["max",0]}]},{"key":{"Fun":152},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["min",0]}]},{"key":{"Fun":153},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["max_by_key",0]}]},{"key":{"Fun":154},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["max_by",0]}]},{"key":{"Fun":155},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["min_by_key",0]}]},{"key":{"Fun":156},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["min_by",0]}]},{"key":{"Fun":157},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["rev",0]}]},{"key":{"Fun":158},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["unzip",0]}]},{"key":{"Fun":159},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["copied",0]}]},{"key":{"Fun":160},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cloned",0]}]},{"key":{"Fun":161},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cycle",0]}]},{"key":{"Fun":162},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["array_chunks",0]}]},{"key":{"Fun":163},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["sum",0]}]},{"key":{"Fun":164},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["product",0]}]},{"key":{"Fun":165},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cmp",0]}]},{"key":{"Fun":166},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["cmp_by",0]}]},{"key":{"Fun":167},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":168},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":169},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["eq",0]}]},{"key":{"Fun":170},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["eq_by",0]}]},{"key":{"Fun":171},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["ne",0]}]},{"key":{"Fun":172},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["lt",0]}]},{"key":{"Fun":173},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["le",0]}]},{"key":{"Fun":174},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["gt",0]}]},{"key":{"Fun":175},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["ge",0]}]},{"key":{"Fun":176},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_sorted",0]}]},{"key":{"Fun":177},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":178},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":179},"value":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"Global":2},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":2}},{"Ident":["{vtable}",0]}]},{"key":{"Global":3},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":180},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["next_chunk",0]}]},{"key":{"Fun":181},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["size_hint",0]}]},{"key":{"Fun":182},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["count",0]}]},{"key":{"Fun":183},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["last",0]}]},{"key":{"Fun":184},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["advance_by",0]}]},{"key":{"Fun":185},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["nth",0]}]},{"key":{"Fun":186},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["step_by",0]}]},{"key":{"Fun":187},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["chain",0]}]},{"key":{"Fun":188},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["zip",0]}]},{"key":{"Fun":189},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["intersperse",0]}]},{"key":{"Fun":190},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["intersperse_with",0]}]},{"key":{"Fun":191},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["map",0]}]},{"key":{"Fun":192},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["for_each",0]}]},{"key":{"Fun":193},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["filter",0]}]},{"key":{"Fun":194},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["filter_map",0]}]},{"key":{"Fun":195},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["enumerate",0]}]},{"key":{"Fun":196},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["peekable",0]}]},{"key":{"Fun":197},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["skip_while",0]}]},{"key":{"Fun":198},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["take_while",0]}]},{"key":{"Fun":199},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["map_while",0]}]},{"key":{"Fun":200},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["skip",0]}]},{"key":{"Fun":201},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["take",0]}]},{"key":{"Fun":202},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["scan",0]}]},{"key":{"Fun":203},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["flat_map",0]}]},{"key":{"Fun":204},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["flatten",0]}]},{"key":{"Fun":205},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["map_windows",0]}]},{"key":{"Fun":206},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["fuse",0]}]},{"key":{"Fun":207},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["inspect",0]}]},{"key":{"Fun":208},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["by_ref",0]}]},{"key":{"Fun":209},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["collect",0]}]},{"key":{"Fun":210},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["try_collect",0]}]},{"key":{"Fun":211},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["collect_into",0]}]},{"key":{"Fun":212},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["partition",0]}]},{"key":{"Fun":213},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["partition_in_place",0]}]},{"key":{"Fun":214},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":215},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["try_fold",0]}]},{"key":{"Fun":216},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["try_for_each",0]}]},{"key":{"Fun":217},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["fold",0]}]},{"key":{"Fun":218},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["reduce",0]}]},{"key":{"Fun":219},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["try_reduce",0]}]},{"key":{"Fun":220},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["all",0]}]},{"key":{"Fun":221},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["any",0]}]},{"key":{"Fun":222},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["find",0]}]},{"key":{"Fun":223},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["find_map",0]}]},{"key":{"Fun":224},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["try_find",0]}]},{"key":{"Fun":225},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["position",0]}]},{"key":{"Fun":226},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["rposition",0]}]},{"key":{"Fun":227},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["max",0]}]},{"key":{"Fun":228},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["min",0]}]},{"key":{"Fun":229},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["max_by_key",0]}]},{"key":{"Fun":230},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["max_by",0]}]},{"key":{"Fun":231},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["min_by_key",0]}]},{"key":{"Fun":232},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["min_by",0]}]},{"key":{"Fun":233},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["rev",0]}]},{"key":{"Fun":234},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["unzip",0]}]},{"key":{"Fun":235},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["copied",0]}]},{"key":{"Fun":236},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["cloned",0]}]},{"key":{"Fun":237},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["cycle",0]}]},{"key":{"Fun":238},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["array_chunks",0]}]},{"key":{"Fun":239},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["sum",0]}]},{"key":{"Fun":240},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["product",0]}]},{"key":{"Fun":241},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["cmp",0]}]},{"key":{"Fun":242},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["cmp_by",0]}]},{"key":{"Fun":243},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":244},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":245},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["eq",0]}]},{"key":{"Fun":246},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["eq_by",0]}]},{"key":{"Fun":247},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["ne",0]}]},{"key":{"Fun":248},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["lt",0]}]},{"key":{"Fun":249},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["le",0]}]},{"key":{"Fun":250},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["gt",0]}]},{"key":{"Fun":251},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["ge",0]}]},{"key":{"Fun":252},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["is_sorted",0]}]},{"key":{"Fun":253},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":254},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":255},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"Fun":256},"value":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]},{"Impl":{"Trait":4}},{"Ident":["drop_in_place",0]}]},{"key":{"Global":4},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":5}},{"Ident":["{vtable}",0]}]},{"key":{"TraitDecl":24},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]}]},{"key":{"Fun":257},"value":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":6}},{"Ident":["from_output",0]}]},{"key":{"Fun":258},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]},{"Ident":["from",0]}]},{"key":{"Fun":259},"value":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":8}},{"Ident":["from",0]}]},{"key":{"TraitDecl":25},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Tuple",0]}]},{"key":{"Fun":260},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":9}},{"Ident":["call_once",0]}]},{"key":{"Type":42},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":261},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]},{"Ident":["call_once",0]}]},{"key":{"Fun":262},"value":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":10}},{"Ident":["drop_in_place",0]}]},{"key":{"Fun":263},"value":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":11}},{"Ident":["from_output",0]}]},{"key":{"Type":43},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":264},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]},{"Ident":["into_iter",0]}]},{"key":{"TraitDecl":26},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["private",0]},{"Ident":["Sealed",0]}]},{"key":{"TraitImpl":14},"value":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Impl":{"Trait":14}}]},{"key":{"TraitImpl":15},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":15}}]},{"key":{"Type":44},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Ident":["NonZeroUsizeInner",0]}]},{"key":{"TraitImpl":16},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":16}}]},{"key":{"Fun":265},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]},{"Ident":["clone",0]}]},{"key":{"Fun":266},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]},{"Ident":["clone_from",0]}]},{"key":{"Type":45},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":267},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]},{"Ident":["call_mut",0]}]},{"key":{"Fun":268},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]},{"Ident":["from_iter",0]}]},{"key":{"Fun":269},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["from_output",0]}]},{"key":{"Fun":270},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["branch",0]}]},{"key":{"Fun":271},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend",0]}]},{"key":{"Fun":272},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend_one",0]}]},{"key":{"Fun":273},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend_reserve",0]}]},{"key":{"Fun":274},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend_one_unchecked",0]}]},{"key":{"Fun":275},"value":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]},{"Ident":["default",0]}]},{"key":{"Type":46},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":276},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["next_back",0]}]},{"key":{"Fun":277},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["advance_back_by",0]}]},{"key":{"Fun":278},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["nth_back",0]}]},{"key":{"Fun":279},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["try_rfold",0]}]},{"key":{"Fun":280},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["rfold",0]}]},{"key":{"Fun":281},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["rfind",0]}]},{"key":{"Type":47},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":282},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]},{"Ident":["len",0]}]},{"key":{"Fun":283},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]},{"Ident":["is_empty",0]}]},{"key":{"TraitDecl":27},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Eq",0]}]},{"key":{"Fun":284},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["cmp",0]}]},{"key":{"Fun":285},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["max",0]}]},{"key":{"Fun":286},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["min",0]}]},{"key":{"Fun":287},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["clamp",0]}]},{"key":{"Fun":288},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]},{"Ident":["sum",0]}]},{"key":{"Fun":289},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]},{"Ident":["product",0]}]},{"key":{"Type":48},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":290},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":291},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["lt",0]}]},{"key":{"Fun":292},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["le",0]}]},{"key":{"Fun":293},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["gt",0]}]},{"key":{"Fun":294},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["ge",0]}]},{"key":{"Fun":295},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_lt",0]}]},{"key":{"Fun":296},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_le",0]}]},{"key":{"Fun":297},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_gt",0]}]},{"key":{"Fun":298},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["__chaining_ge",0]}]},{"key":{"Type":49},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["{vtable}",0]}]},{"key":{"Fun":299},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["eq",0]}]},{"key":{"Fun":300},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["ne",0]}]},{"key":{"Fun":301},"value":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["TrustedRandomAccessNoCoerce",0]},{"Ident":["size",0]}]},{"key":{"Fun":302},"value":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]},{"Ident":["from_residual",0]}]},{"key":{"Type":50},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["private",0]},{"Ident":["Sealed",0]},{"Ident":["{vtable}",0]}]},{"key":{"TraitImpl":17},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":17}}]},{"key":{"Global":5},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":15}},{"Ident":["{vtable}",0]}]},{"key":{"TraitImpl":18},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":18}}]},{"key":{"Fun":303},"value":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Eq",0]},{"Ident":["assert_receiver_is_total_eq",0]}]},{"key":{"Fun":304},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":17}},{"Ident":["clone",0]}]},{"key":{"Fun":305},"value":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":17}},{"Ident":["clone_from",0]}]},{"key":{"Fun":306},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":18}},{"Ident":["clone",0]}]},{"key":{"Fun":307},"value":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":18}},{"Ident":["clone_from",0]}]}],"assoc_item_names":[{"types":[],"methods":[],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":["drop_in_place"],"consts":[]},{"types":["Item"],"methods":["next","next_chunk","size_hint","count","last","advance_by","nth","step_by","chain","zip","intersperse","intersperse_with","map","for_each","filter","filter_map","enumerate","peekable","skip_while","take_while","map_while","skip","take","scan","flat_map","flatten","map_windows","fuse","inspect","by_ref","collect","try_collect","collect_into","partition","partition_in_place","is_partitioned","try_fold","try_for_each","fold","reduce","try_reduce","all","any","find","find_map","try_find","position","rposition","max","min","max_by_key","max_by","min_by_key","min_by","rev","unzip","copied","cloned","cycle","array_chunks","sum","product","cmp","cmp_by","partial_cmp","partial_cmp_by","eq","eq_by","ne","lt","le","gt","ge","is_sorted","is_sorted_by","is_sorted_by_key","__iterator_get_unchecked"],"consts":[]},{"types":[],"methods":["from"],"consts":[]},{"types":["Output"],"methods":["call_once"],"consts":[]},{"types":["Item","IntoIter"],"methods":["into_iter"],"consts":[]},{"types":["NonZeroInner"],"methods":[],"consts":[]},{"types":[],"methods":["clone","clone_from"],"consts":[]},{"types":[],"methods":["call_mut"],"consts":[]},{"types":[],"methods":["from_iter"],"consts":[]},{"types":["Output","Residual"],"methods":["from_output","branch"],"consts":[]},{"types":["TryType"],"methods":[],"consts":[]},{"types":[],"methods":["extend","extend_one","extend_reserve","extend_one_unchecked"],"consts":[]},{"types":[],"methods":["default"],"consts":[]},{"types":[],"methods":["next_back","advance_back_by","nth_back","try_rfold","rfold","rfind"],"consts":[]},{"types":[],"methods":["len","is_empty"],"consts":[]},{"types":[],"methods":["cmp","max","min","clamp"],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":["sum"],"consts":[]},{"types":[],"methods":["product"],"consts":[]},{"types":[],"methods":["partial_cmp","lt","le","gt","ge","__chaining_lt","__chaining_le","__chaining_gt","__chaining_ge"],"consts":[]},{"types":[],"methods":["eq","ne"],"consts":[]},{"types":[],"methods":["size"],"consts":["MAY_HAVE_SIDE_EFFECT"]},{"types":[],"methods":["from_residual"],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":[],"consts":[]},{"types":[],"methods":["assert_receiver_is_total_eq"],"consts":[]}],"short_names":[{"key":{"TraitImpl":0},"value":[{"Impl":{"Trait":0}}]},{"key":{"Fun":14},"value":[{"Impl":{"Trait":0}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":1},"value":[{"Impl":{"Trait":1}}]},{"key":{"Fun":15},"value":[{"Impl":{"Trait":1}},{"Ident":["next",0]}]},{"key":{"TraitImpl":2},"value":[{"Impl":{"Trait":2}}]},{"key":{"Fun":16},"value":[{"Impl":{"Trait":2}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":3},"value":[{"Impl":{"Trait":3}}]},{"key":{"Fun":17},"value":[{"Impl":{"Trait":3}},{"Ident":["next",0]}]},{"key":{"TraitImpl":4},"value":[{"Impl":{"Trait":4}}]},{"key":{"TraitImpl":5},"value":[{"Impl":{"Trait":5}}]},{"key":{"Fun":20},"value":[{"Impl":{"Trait":5}},{"Ident":["into_iter",0]}]},{"key":{"TraitImpl":6},"value":[{"Impl":{"Trait":6}}]},{"key":{"Fun":21},"value":[{"Impl":{"Trait":6}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":7},"value":[{"Impl":{"Trait":7}}]},{"key":{"Fun":22},"value":[{"Impl":{"Trait":7}},{"Ident":["from_residual",0]}]},{"key":{"TraitImpl":8},"value":[{"Impl":{"Trait":8}}]},{"key":{"TraitImpl":9},"value":[{"Impl":{"Trait":9}}]},{"key":{"TraitImpl":10},"value":[{"Impl":{"Trait":10}}]},{"key":{"TraitImpl":11},"value":[{"Impl":{"Trait":11}}]},{"key":{"Fun":25},"value":[{"Impl":{"Trait":11}},{"Ident":["branch",0]}]},{"key":{"TraitImpl":12},"value":[{"Impl":{"Trait":12}}]},{"key":{"Fun":26},"value":[{"Impl":{"Trait":12}},{"Ident":["from_residual",0]}]},{"key":{"Global":0},"value":[{"Impl":{"Trait":0}},{"Ident":["{vtable}",0]}]},{"key":{"Global":1},"value":[{"Impl":{"Trait":1}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":27},"value":[{"Impl":{"Trait":1}},{"Ident":["next_chunk",0]}]},{"key":{"Fun":28},"value":[{"Impl":{"Trait":1}},{"Ident":["size_hint",0]}]},{"key":{"Fun":29},"value":[{"Impl":{"Trait":1}},{"Ident":["count",0]}]},{"key":{"Fun":30},"value":[{"Impl":{"Trait":1}},{"Ident":["last",0]}]},{"key":{"Fun":31},"value":[{"Impl":{"Trait":1}},{"Ident":["advance_by",0]}]},{"key":{"Fun":32},"value":[{"Impl":{"Trait":1}},{"Ident":["nth",0]}]},{"key":{"Fun":33},"value":[{"Impl":{"Trait":1}},{"Ident":["step_by",0]}]},{"key":{"TraitImpl":13},"value":[{"Impl":{"Trait":13}}]},{"key":{"Fun":111},"value":[{"Impl":{"Trait":1}},{"Ident":["chain",0]}]},{"key":{"Fun":112},"value":[{"Impl":{"Trait":1}},{"Ident":["zip",0]}]},{"key":{"Fun":113},"value":[{"Impl":{"Trait":1}},{"Ident":["intersperse",0]}]},{"key":{"Fun":114},"value":[{"Impl":{"Trait":1}},{"Ident":["intersperse_with",0]}]},{"key":{"Fun":115},"value":[{"Impl":{"Trait":1}},{"Ident":["map",0]}]},{"key":{"Fun":116},"value":[{"Impl":{"Trait":1}},{"Ident":["for_each",0]}]},{"key":{"Fun":117},"value":[{"Impl":{"Trait":1}},{"Ident":["filter",0]}]},{"key":{"Fun":118},"value":[{"Impl":{"Trait":1}},{"Ident":["filter_map",0]}]},{"key":{"Fun":119},"value":[{"Impl":{"Trait":1}},{"Ident":["enumerate",0]}]},{"key":{"Fun":120},"value":[{"Impl":{"Trait":1}},{"Ident":["peekable",0]}]},{"key":{"Fun":121},"value":[{"Impl":{"Trait":1}},{"Ident":["skip_while",0]}]},{"key":{"Fun":122},"value":[{"Impl":{"Trait":1}},{"Ident":["take_while",0]}]},{"key":{"Fun":123},"value":[{"Impl":{"Trait":1}},{"Ident":["map_while",0]}]},{"key":{"Fun":124},"value":[{"Impl":{"Trait":1}},{"Ident":["skip",0]}]},{"key":{"Fun":125},"value":[{"Impl":{"Trait":1}},{"Ident":["take",0]}]},{"key":{"Fun":126},"value":[{"Impl":{"Trait":1}},{"Ident":["scan",0]}]},{"key":{"Fun":127},"value":[{"Impl":{"Trait":1}},{"Ident":["flat_map",0]}]},{"key":{"Fun":128},"value":[{"Impl":{"Trait":1}},{"Ident":["flatten",0]}]},{"key":{"Fun":129},"value":[{"Impl":{"Trait":1}},{"Ident":["map_windows",0]}]},{"key":{"Fun":130},"value":[{"Impl":{"Trait":1}},{"Ident":["fuse",0]}]},{"key":{"Fun":131},"value":[{"Impl":{"Trait":1}},{"Ident":["inspect",0]}]},{"key":{"Fun":132},"value":[{"Impl":{"Trait":1}},{"Ident":["by_ref",0]}]},{"key":{"Fun":133},"value":[{"Impl":{"Trait":1}},{"Ident":["collect",0]}]},{"key":{"Fun":134},"value":[{"Impl":{"Trait":1}},{"Ident":["try_collect",0]}]},{"key":{"Fun":135},"value":[{"Impl":{"Trait":1}},{"Ident":["collect_into",0]}]},{"key":{"Fun":136},"value":[{"Impl":{"Trait":1}},{"Ident":["partition",0]}]},{"key":{"Fun":137},"value":[{"Impl":{"Trait":1}},{"Ident":["partition_in_place",0]}]},{"key":{"Fun":138},"value":[{"Impl":{"Trait":1}},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":139},"value":[{"Impl":{"Trait":1}},{"Ident":["try_fold",0]}]},{"key":{"Fun":140},"value":[{"Impl":{"Trait":1}},{"Ident":["try_for_each",0]}]},{"key":{"Fun":141},"value":[{"Impl":{"Trait":1}},{"Ident":["fold",0]}]},{"key":{"Fun":142},"value":[{"Impl":{"Trait":1}},{"Ident":["reduce",0]}]},{"key":{"Fun":143},"value":[{"Impl":{"Trait":1}},{"Ident":["try_reduce",0]}]},{"key":{"Fun":144},"value":[{"Impl":{"Trait":1}},{"Ident":["all",0]}]},{"key":{"Fun":145},"value":[{"Impl":{"Trait":1}},{"Ident":["any",0]}]},{"key":{"Fun":146},"value":[{"Impl":{"Trait":1}},{"Ident":["find",0]}]},{"key":{"Fun":147},"value":[{"Impl":{"Trait":1}},{"Ident":["find_map",0]}]},{"key":{"Fun":148},"value":[{"Impl":{"Trait":1}},{"Ident":["try_find",0]}]},{"key":{"Fun":149},"value":[{"Impl":{"Trait":1}},{"Ident":["position",0]}]},{"key":{"Fun":150},"value":[{"Impl":{"Trait":1}},{"Ident":["rposition",0]}]},{"key":{"Fun":151},"value":[{"Impl":{"Trait":1}},{"Ident":["max",0]}]},{"key":{"Fun":152},"value":[{"Impl":{"Trait":1}},{"Ident":["min",0]}]},{"key":{"Fun":153},"value":[{"Impl":{"Trait":1}},{"Ident":["max_by_key",0]}]},{"key":{"Fun":154},"value":[{"Impl":{"Trait":1}},{"Ident":["max_by",0]}]},{"key":{"Fun":155},"value":[{"Impl":{"Trait":1}},{"Ident":["min_by_key",0]}]},{"key":{"Fun":156},"value":[{"Impl":{"Trait":1}},{"Ident":["min_by",0]}]},{"key":{"Fun":157},"value":[{"Impl":{"Trait":1}},{"Ident":["rev",0]}]},{"key":{"Fun":158},"value":[{"Impl":{"Trait":1}},{"Ident":["unzip",0]}]},{"key":{"Fun":159},"value":[{"Impl":{"Trait":1}},{"Ident":["copied",0]}]},{"key":{"Fun":160},"value":[{"Impl":{"Trait":1}},{"Ident":["cloned",0]}]},{"key":{"Fun":161},"value":[{"Impl":{"Trait":1}},{"Ident":["cycle",0]}]},{"key":{"Fun":162},"value":[{"Impl":{"Trait":1}},{"Ident":["array_chunks",0]}]},{"key":{"Fun":163},"value":[{"Impl":{"Trait":1}},{"Ident":["sum",0]}]},{"key":{"Fun":164},"value":[{"Impl":{"Trait":1}},{"Ident":["product",0]}]},{"key":{"Fun":165},"value":[{"Impl":{"Trait":1}},{"Ident":["cmp",0]}]},{"key":{"Fun":166},"value":[{"Impl":{"Trait":1}},{"Ident":["cmp_by",0]}]},{"key":{"Fun":167},"value":[{"Impl":{"Trait":1}},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":168},"value":[{"Impl":{"Trait":1}},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":169},"value":[{"Impl":{"Trait":1}},{"Ident":["eq",0]}]},{"key":{"Fun":170},"value":[{"Impl":{"Trait":1}},{"Ident":["eq_by",0]}]},{"key":{"Fun":171},"value":[{"Impl":{"Trait":1}},{"Ident":["ne",0]}]},{"key":{"Fun":172},"value":[{"Impl":{"Trait":1}},{"Ident":["lt",0]}]},{"key":{"Fun":173},"value":[{"Impl":{"Trait":1}},{"Ident":["le",0]}]},{"key":{"Fun":174},"value":[{"Impl":{"Trait":1}},{"Ident":["gt",0]}]},{"key":{"Fun":175},"value":[{"Impl":{"Trait":1}},{"Ident":["ge",0]}]},{"key":{"Fun":176},"value":[{"Impl":{"Trait":1}},{"Ident":["is_sorted",0]}]},{"key":{"Fun":177},"value":[{"Impl":{"Trait":1}},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":178},"value":[{"Impl":{"Trait":1}},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":179},"value":[{"Impl":{"Trait":1}},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"Global":2},"value":[{"Impl":{"Trait":2}},{"Ident":["{vtable}",0]}]},{"key":{"Global":3},"value":[{"Impl":{"Trait":3}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":180},"value":[{"Impl":{"Trait":3}},{"Ident":["next_chunk",0]}]},{"key":{"Fun":181},"value":[{"Impl":{"Trait":3}},{"Ident":["size_hint",0]}]},{"key":{"Fun":182},"value":[{"Impl":{"Trait":3}},{"Ident":["count",0]}]},{"key":{"Fun":183},"value":[{"Impl":{"Trait":3}},{"Ident":["last",0]}]},{"key":{"Fun":184},"value":[{"Impl":{"Trait":3}},{"Ident":["advance_by",0]}]},{"key":{"Fun":185},"value":[{"Impl":{"Trait":3}},{"Ident":["nth",0]}]},{"key":{"Fun":186},"value":[{"Impl":{"Trait":3}},{"Ident":["step_by",0]}]},{"key":{"Fun":187},"value":[{"Impl":{"Trait":3}},{"Ident":["chain",0]}]},{"key":{"Fun":188},"value":[{"Impl":{"Trait":3}},{"Ident":["zip",0]}]},{"key":{"Fun":189},"value":[{"Impl":{"Trait":3}},{"Ident":["intersperse",0]}]},{"key":{"Fun":190},"value":[{"Impl":{"Trait":3}},{"Ident":["intersperse_with",0]}]},{"key":{"Fun":191},"value":[{"Impl":{"Trait":3}},{"Ident":["map",0]}]},{"key":{"Fun":192},"value":[{"Impl":{"Trait":3}},{"Ident":["for_each",0]}]},{"key":{"Fun":193},"value":[{"Impl":{"Trait":3}},{"Ident":["filter",0]}]},{"key":{"Fun":194},"value":[{"Impl":{"Trait":3}},{"Ident":["filter_map",0]}]},{"key":{"Fun":195},"value":[{"Impl":{"Trait":3}},{"Ident":["enumerate",0]}]},{"key":{"Fun":196},"value":[{"Impl":{"Trait":3}},{"Ident":["peekable",0]}]},{"key":{"Fun":197},"value":[{"Impl":{"Trait":3}},{"Ident":["skip_while",0]}]},{"key":{"Fun":198},"value":[{"Impl":{"Trait":3}},{"Ident":["take_while",0]}]},{"key":{"Fun":199},"value":[{"Impl":{"Trait":3}},{"Ident":["map_while",0]}]},{"key":{"Fun":200},"value":[{"Impl":{"Trait":3}},{"Ident":["skip",0]}]},{"key":{"Fun":201},"value":[{"Impl":{"Trait":3}},{"Ident":["take",0]}]},{"key":{"Fun":202},"value":[{"Impl":{"Trait":3}},{"Ident":["scan",0]}]},{"key":{"Fun":203},"value":[{"Impl":{"Trait":3}},{"Ident":["flat_map",0]}]},{"key":{"Fun":204},"value":[{"Impl":{"Trait":3}},{"Ident":["flatten",0]}]},{"key":{"Fun":205},"value":[{"Impl":{"Trait":3}},{"Ident":["map_windows",0]}]},{"key":{"Fun":206},"value":[{"Impl":{"Trait":3}},{"Ident":["fuse",0]}]},{"key":{"Fun":207},"value":[{"Impl":{"Trait":3}},{"Ident":["inspect",0]}]},{"key":{"Fun":208},"value":[{"Impl":{"Trait":3}},{"Ident":["by_ref",0]}]},{"key":{"Fun":209},"value":[{"Impl":{"Trait":3}},{"Ident":["collect",0]}]},{"key":{"Fun":210},"value":[{"Impl":{"Trait":3}},{"Ident":["try_collect",0]}]},{"key":{"Fun":211},"value":[{"Impl":{"Trait":3}},{"Ident":["collect_into",0]}]},{"key":{"Fun":212},"value":[{"Impl":{"Trait":3}},{"Ident":["partition",0]}]},{"key":{"Fun":213},"value":[{"Impl":{"Trait":3}},{"Ident":["partition_in_place",0]}]},{"key":{"Fun":214},"value":[{"Impl":{"Trait":3}},{"Ident":["is_partitioned",0]}]},{"key":{"Fun":215},"value":[{"Impl":{"Trait":3}},{"Ident":["try_fold",0]}]},{"key":{"Fun":216},"value":[{"Impl":{"Trait":3}},{"Ident":["try_for_each",0]}]},{"key":{"Fun":217},"value":[{"Impl":{"Trait":3}},{"Ident":["fold",0]}]},{"key":{"Fun":218},"value":[{"Impl":{"Trait":3}},{"Ident":["reduce",0]}]},{"key":{"Fun":219},"value":[{"Impl":{"Trait":3}},{"Ident":["try_reduce",0]}]},{"key":{"Fun":220},"value":[{"Impl":{"Trait":3}},{"Ident":["all",0]}]},{"key":{"Fun":221},"value":[{"Impl":{"Trait":3}},{"Ident":["any",0]}]},{"key":{"Fun":222},"value":[{"Impl":{"Trait":3}},{"Ident":["find",0]}]},{"key":{"Fun":223},"value":[{"Impl":{"Trait":3}},{"Ident":["find_map",0]}]},{"key":{"Fun":224},"value":[{"Impl":{"Trait":3}},{"Ident":["try_find",0]}]},{"key":{"Fun":225},"value":[{"Impl":{"Trait":3}},{"Ident":["position",0]}]},{"key":{"Fun":226},"value":[{"Impl":{"Trait":3}},{"Ident":["rposition",0]}]},{"key":{"Fun":227},"value":[{"Impl":{"Trait":3}},{"Ident":["max",0]}]},{"key":{"Fun":228},"value":[{"Impl":{"Trait":3}},{"Ident":["min",0]}]},{"key":{"Fun":229},"value":[{"Impl":{"Trait":3}},{"Ident":["max_by_key",0]}]},{"key":{"Fun":230},"value":[{"Impl":{"Trait":3}},{"Ident":["max_by",0]}]},{"key":{"Fun":231},"value":[{"Impl":{"Trait":3}},{"Ident":["min_by_key",0]}]},{"key":{"Fun":232},"value":[{"Impl":{"Trait":3}},{"Ident":["min_by",0]}]},{"key":{"Fun":233},"value":[{"Impl":{"Trait":3}},{"Ident":["rev",0]}]},{"key":{"Fun":234},"value":[{"Impl":{"Trait":3}},{"Ident":["unzip",0]}]},{"key":{"Fun":235},"value":[{"Impl":{"Trait":3}},{"Ident":["copied",0]}]},{"key":{"Fun":236},"value":[{"Impl":{"Trait":3}},{"Ident":["cloned",0]}]},{"key":{"Fun":237},"value":[{"Impl":{"Trait":3}},{"Ident":["cycle",0]}]},{"key":{"Fun":238},"value":[{"Impl":{"Trait":3}},{"Ident":["array_chunks",0]}]},{"key":{"Fun":239},"value":[{"Impl":{"Trait":3}},{"Ident":["sum",0]}]},{"key":{"Fun":240},"value":[{"Impl":{"Trait":3}},{"Ident":["product",0]}]},{"key":{"Fun":241},"value":[{"Impl":{"Trait":3}},{"Ident":["cmp",0]}]},{"key":{"Fun":242},"value":[{"Impl":{"Trait":3}},{"Ident":["cmp_by",0]}]},{"key":{"Fun":243},"value":[{"Impl":{"Trait":3}},{"Ident":["partial_cmp",0]}]},{"key":{"Fun":244},"value":[{"Impl":{"Trait":3}},{"Ident":["partial_cmp_by",0]}]},{"key":{"Fun":245},"value":[{"Impl":{"Trait":3}},{"Ident":["eq",0]}]},{"key":{"Fun":246},"value":[{"Impl":{"Trait":3}},{"Ident":["eq_by",0]}]},{"key":{"Fun":247},"value":[{"Impl":{"Trait":3}},{"Ident":["ne",0]}]},{"key":{"Fun":248},"value":[{"Impl":{"Trait":3}},{"Ident":["lt",0]}]},{"key":{"Fun":249},"value":[{"Impl":{"Trait":3}},{"Ident":["le",0]}]},{"key":{"Fun":250},"value":[{"Impl":{"Trait":3}},{"Ident":["gt",0]}]},{"key":{"Fun":251},"value":[{"Impl":{"Trait":3}},{"Ident":["ge",0]}]},{"key":{"Fun":252},"value":[{"Impl":{"Trait":3}},{"Ident":["is_sorted",0]}]},{"key":{"Fun":253},"value":[{"Impl":{"Trait":3}},{"Ident":["is_sorted_by",0]}]},{"key":{"Fun":254},"value":[{"Impl":{"Trait":3}},{"Ident":["is_sorted_by_key",0]}]},{"key":{"Fun":255},"value":[{"Impl":{"Trait":3}},{"Ident":["__iterator_get_unchecked",0]}]},{"key":{"Fun":256},"value":[{"Impl":{"Trait":4}},{"Ident":["drop_in_place",0]}]},{"key":{"Global":4},"value":[{"Impl":{"Trait":5}},{"Ident":["{vtable}",0]}]},{"key":{"Fun":257},"value":[{"Impl":{"Trait":6}},{"Ident":["from_output",0]}]},{"key":{"Fun":259},"value":[{"Impl":{"Trait":8}},{"Ident":["from",0]}]},{"key":{"Fun":260},"value":[{"Impl":{"Trait":9}},{"Ident":["call_once",0]}]},{"key":{"Fun":262},"value":[{"Impl":{"Trait":10}},{"Ident":["drop_in_place",0]}]},{"key":{"Fun":263},"value":[{"Impl":{"Trait":11}},{"Ident":["from_output",0]}]},{"key":{"TraitImpl":14},"value":[{"Impl":{"Trait":14}}]},{"key":{"TraitImpl":15},"value":[{"Impl":{"Trait":15}}]},{"key":{"TraitImpl":16},"value":[{"Impl":{"Trait":16}}]},{"key":{"TraitImpl":17},"value":[{"Impl":{"Trait":17}}]},{"key":{"Global":5},"value":[{"Impl":{"Trait":15}},{"Ident":["{vtable}",0]}]},{"key":{"TraitImpl":18},"value":[{"Impl":{"Trait":18}}]},{"key":{"Fun":304},"value":[{"Impl":{"Trait":17}},{"Ident":["clone",0]}]},{"key":{"Fun":305},"value":[{"Impl":{"Trait":17}},{"Ident":["clone_from",0]}]},{"key":{"Fun":306},"value":[{"Impl":{"Trait":18}},{"Ident":["clone",0]}]},{"key":{"Fun":307},"value":[{"Impl":{"Trait":18}},{"Ident":["clone_from",0]}]},{"key":{"TraitDecl":0},"value":[{"Ident":["Sized",0]}]},{"key":{"TraitDecl":24},"value":[{"Ident":["FromResidual",0]}]},{"key":{"Fun":281},"value":[{"Ident":["rfind",0]}]},{"key":{"Type":21},"value":[{"Ident":["Filter",0]}]},{"key":{"Fun":3},"value":[{"Ident":["array_of_refs_sum",0]}]},{"key":{"TraitDecl":8},"value":[{"Ident":["Clone",0]}]},{"key":{"Fun":274},"value":[{"Ident":["extend_one_unchecked",0]}]},{"key":{"Fun":275},"value":[{"Ident":["default",0]}]},{"key":{"Type":4},"value":[{"Ident":["HostRegistry",0]}]},{"key":{"Fun":277},"value":[{"Ident":["advance_back_by",0]}]},{"key":{"Fun":283},"value":[{"Ident":["is_empty",0]}]},{"key":{"Type":19},"value":[{"Ident":["IntersperseWith",0]}]},{"key":{"TraitDecl":4},"value":[{"Ident":["From",0]}]},{"key":{"Type":20},"value":[{"Ident":["Map",0]}]},{"key":{"TraitDecl":5},"value":[{"Ident":["FnOnce",0]}]},{"key":{"Type":5},"value":[{"Ident":["Result",0]}]},{"key":{"Fun":10},"value":[{"Ident":["option_source",0]}]},{"key":{"Fun":1},"value":[{"Ident":["branch_loop_sum",0]}]},{"key":{"Type":14},"value":[{"Ident":["NonZero",0]}]},{"key":{"TraitDecl":7},"value":[{"Ident":["ZeroablePrimitive",0]}]},{"key":{"TraitDecl":19},"value":[{"Ident":["Sum",0]}]},{"key":{"TraitDecl":22},"value":[{"Ident":["PartialEq",0]}]},{"key":{"Fun":279},"value":[{"Ident":["try_rfold",0]}]},{"key":{"TraitDecl":27},"value":[{"Ident":["Eq",0]}]},{"key":{"Fun":295},"value":[{"Ident":["__chaining_lt",0]}]},{"key":{"Fun":303},"value":[{"Ident":["assert_receiver_is_total_eq",0]}]},{"key":{"Type":8},"value":[{"Ident":["IntoIter",0]}]},{"key":{"Fun":24},"value":[{"Ident":["then_some",0]}]},{"key":{"Type":2},"value":[{"Ident":["Token",0]}]},{"key":{"TraitDecl":9},"value":[{"Ident":["FnMut",0]}]},{"key":{"Fun":297},"value":[{"Ident":["__chaining_gt",0]}]},{"key":{"Type":36},"value":[{"Ident":["Ordering",0]}]},{"key":{"Type":39},"value":[{"Ident":["Cloned",0]}]},{"key":{"Fun":8},"value":[{"Ident":["bool_then_closure",0]}]},{"key":{"Fun":280},"value":[{"Ident":["rfold",0]}]},{"key":{"Fun":6},"value":[{"Ident":["desugar_mix",0]}]},{"key":{"TraitDecl":20},"value":[{"Ident":["Product",0]}]},{"key":{"Type":6},"value":[{"Ident":["Iter",0]}]},{"key":{"Type":9},"value":[{"Ident":["ControlFlow",0]}]},{"key":{"TraitDecl":3},"value":[{"Ident":["Iterator",0]}]},{"key":{"Type":3},"value":[{"Ident":["HostCallback",0]}]},{"key":{"Type":11},"value":[{"Ident":["closure",0]}]},{"key":{"Type":26},"value":[{"Ident":["TakeWhile",0]}]},{"key":{"Fun":12},"value":[{"Ident":["host_registry_dispatch",0]}]},{"key":{"TraitDecl":11},"value":[{"Ident":["Try",0]}]},{"key":{"Type":44},"value":[{"Ident":["NonZeroUsizeInner",0]}]},{"key":{"Fun":268},"value":[{"Ident":["from_iter",0]}]},{"key":{"Type":27},"value":[{"Ident":["MapWhile",0]}]},{"key":{"Type":31},"value":[{"Ident":["FlatMap",0]}]},{"key":{"Type":1},"value":[{"Ident":["Strategy",0]}]},{"key":{"Type":15},"value":[{"Ident":["StepBy",0]}]},{"key":{"TraitDecl":10},"value":[{"Ident":["FromIterator",0]}]},{"key":{"Type":41},"value":[{"Ident":["ArrayChunks",0]}]},{"key":{"Fun":271},"value":[{"Ident":["extend",0]}]},{"key":{"TraitDecl":23},"value":[{"Ident":["TrustedRandomAccessNoCoerce",0]}]},{"key":{"Type":28},"value":[{"Ident":["Skip",0]}]},{"key":{"Fun":11},"value":[{"Ident":["option_question_mark",0]}]},{"key":{"Fun":19},"value":[{"Ident":["iter",0]}]},{"key":{"Fun":276},"value":[{"Ident":["next_back",0]}]},{"key":{"Fun":287},"value":[{"Ident":["clamp",0]}]},{"key":{"TraitDecl":21},"value":[{"Ident":["PartialOrd",0]}]},{"key":{"Fun":7},"value":[{"Ident":["tuple_roundtrip",0]}]},{"key":{"Type":23},"value":[{"Ident":["Enumerate",0]}]},{"key":{"Type":24},"value":[{"Ident":["Peekable",0]}]},{"key":{"Fun":278},"value":[{"Ident":["nth_back",0]}]},{"key":{"TraitDecl":1},"value":[{"Ident":["MetaSized",0]}]},{"key":{"Type":30},"value":[{"Ident":["Scan",0]}]},{"key":{"TraitDecl":18},"value":[{"Ident":["Copy",0]}]},{"key":{"Type":40},"value":[{"Ident":["Cycle",0]}]},{"key":{"Type":33},"value":[{"Ident":["MapWindows",0]}]},{"key":{"TraitDecl":26},"value":[{"Ident":["Sealed",0]}]},{"key":{"Fun":4},"value":[{"Ident":["strategy_len",0]}]},{"key":{"Fun":301},"value":[{"Ident":["size",0]}]},{"key":{"TraitDecl":6},"value":[{"Ident":["IntoIterator",0]}]},{"key":{"Type":29},"value":[{"Ident":["Take",0]}]},{"key":{"TraitDecl":2},"value":[{"Ident":["Destruct",0]}]},{"key":{"Fun":298},"value":[{"Ident":["__chaining_ge",0]}]},{"key":{"Type":0},"value":[{"Ident":["PyResult",0]}]},{"key":{"Type":10},"value":[{"Ident":["Infallible",0]}]},{"key":{"Fun":2},"value":[{"Ident":["slice_of_refs_sum",0]}]},{"key":{"TraitDecl":14},"value":[{"Ident":["Default",0]}]},{"key":{"Fun":282},"value":[{"Ident":["len",0]}]},{"key":{"Fun":296},"value":[{"Ident":["__chaining_le",0]}]},{"key":{"Type":18},"value":[{"Ident":["Intersperse",0]}]},{"key":{"Type":16},"value":[{"Ident":["Chain",0]}]},{"key":{"Type":25},"value":[{"Ident":["SkipWhile",0]}]},{"key":{"Type":34},"value":[{"Ident":["Fuse",0]}]},{"key":{"Type":17},"value":[{"Ident":["Zip",0]}]},{"key":{"TraitDecl":16},"value":[{"Ident":["ExactSizeIterator",0]}]},{"key":{"TraitDecl":13},"value":[{"Ident":["Extend",0]}]},{"key":{"Fun":23},"value":[{"Ident":["then",0]}]},{"key":{"Fun":13},"value":[{"Ident":["host_registry_dispatch_optional",0]}]},{"key":{"Fun":5},"value":[{"Ident":["parse_one",0]}]},{"key":{"TraitDecl":12},"value":[{"Ident":["Residual",0]}]},{"key":{"Type":37},"value":[{"Ident":["Rev",0]}]},{"key":{"Type":38},"value":[{"Ident":["Copied",0]}]},{"key":{"TraitDecl":25},"value":[{"Ident":["Tuple",0]}]},{"key":{"Type":22},"value":[{"Ident":["FilterMap",0]}]},{"key":{"Fun":272},"value":[{"Ident":["extend_one",0]}]},{"key":{"Fun":0},"value":[{"Ident":["straight_line_add",0]}]},{"key":{"Type":35},"value":[{"Ident":["Inspect",0]}]},{"key":{"Fun":267},"value":[{"Ident":["call_mut",0]}]},{"key":{"Fun":273},"value":[{"Ident":["extend_reserve",0]}]},{"key":{"Type":32},"value":[{"Ident":["Flatten",0]}]},{"key":{"Fun":9},"value":[{"Ident":["bool_then_some",0]}]},{"key":{"Type":7},"value":[{"Ident":["Option",0]}]},{"key":{"TraitDecl":17},"value":[{"Ident":["Ord",0]}]},{"key":{"TraitDecl":15},"value":[{"Ident":["DoubleEndedIterator",0]}]}],"type_decls":[{"def_id":0,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["PyResult",0]}],"span":{"data":{"file_id":0,"beg":{"line":10,"col":0},"end":{"line":10,"col":47}},"generated_from_span":null},"source_text":"pub type PyResult = Result;","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":10,"col":18},"end":{"line":10,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Alias":{"HashConsedValue":[6986,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":220},{"HashConsedValue":[222,{"Ref":["Static",{"HashConsedValue":[221,{"Adt":{"id":{"Builtin":"Str"},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[223,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[229,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[228,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[227,{"Ref":["Erased",{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":222}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"layout":[],"ptr_metadata":"None"},{"def_id":1,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["Strategy",0]}],"span":{"data":{"file_id":0,"beg":{"line":60,"col":0},"end":{"line":64,"col":1}},"generated_from_span":null},"source_text":"pub enum Strategy {\n Empty,\n IntKeyed { len: usize },\n StrKeyed { len: usize, capacity: usize },\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":0,"beg":{"line":61,"col":4},"end":{"line":61,"col":9}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Empty","fields":[],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":0,"beg":{"line":62,"col":4},"end":{"line":62,"col":12}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"IntKeyed","fields":[{"span":{"data":{"file_id":0,"beg":{"line":62,"col":15},"end":{"line":62,"col":25}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"len","ty":{"HashConsedValue":[775,{"Literal":{"UInt":"Usize"}}]}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}},{"id":2,"span":{"data":{"file_id":0,"beg":{"line":63,"col":4},"end":{"line":63,"col":12}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"StrKeyed","fields":[{"span":{"data":{"file_id":0,"beg":{"line":63,"col":15},"end":{"line":63,"col":25}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"len","ty":{"Deduplicated":775}},{"span":{"data":{"file_id":0,"beg":{"line":63,"col":27},"end":{"line":63,"col":42}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"capacity","ty":{"Deduplicated":775}}],"discriminant":{"Scalar":{"Signed":["Isize","2"]}}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":24,"align":8,"discriminator":{"Branch":{"offset":0,"int_ty":{"Unsigned":"U64"},"children":[[{"start":{"Unsigned":["U64","0"]},"end":{"Unsigned":["U64","0"]}},{"Known":0}],[{"start":{"Unsigned":["U64","1"]},"end":{"Unsigned":["U64","1"]}},{"Known":1}],[{"start":{"Unsigned":["U64","2"]},"end":{"Unsigned":["U64","2"]}},{"Known":2}]],"fallback":"Invalid"}},"uninhabited":false,"variant_layouts":[{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","0"]}]]},{"field_offsets":[8],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","1"]}]]},{"field_offsets":[8,16],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","2"]}]]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":2,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["Token",0]}],"span":{"data":{"file_id":0,"beg":{"line":76,"col":0},"end":{"line":80,"col":1}},"generated_from_span":null},"source_text":"pub enum Token {\n Add(i64),\n Sub(i64),\n Halt,\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":0,"beg":{"line":77,"col":4},"end":{"line":77,"col":7}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Add","fields":[{"span":{"data":{"file_id":0,"beg":{"line":77,"col":8},"end":{"line":77,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"HashConsedValue":[231,{"Literal":{"Int":"I64"}}]}}],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":0,"beg":{"line":78,"col":4},"end":{"line":78,"col":7}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Sub","fields":[{"span":{"data":{"file_id":0,"beg":{"line":78,"col":8},"end":{"line":78,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":231}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}},{"id":2,"span":{"data":{"file_id":0,"beg":{"line":79,"col":4},"end":{"line":79,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"Halt","fields":[],"discriminant":{"Scalar":{"Signed":["Isize","2"]}}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":16,"align":8,"discriminator":{"Branch":{"offset":0,"int_ty":{"Unsigned":"U64"},"children":[[{"start":{"Unsigned":["U64","0"]},"end":{"Unsigned":["U64","0"]}},{"Known":0}],[{"start":{"Unsigned":["U64","1"]},"end":{"Unsigned":["U64","1"]}},{"Known":1}],[{"start":{"Unsigned":["U64","2"]},"end":{"Unsigned":["U64","2"]}},{"Known":2}]],"fallback":"Invalid"}},"uninhabited":false,"variant_layouts":[{"field_offsets":[8],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","0"]}]]},{"field_offsets":[8],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","1"]}]]},{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Unsigned":["U64","2"]}]]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":3,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["HostCallback",0]}],"span":{"data":{"file_id":0,"beg":{"line":157,"col":0},"end":{"line":157,"col":39}},"generated_from_span":null},"source_text":"pub type HostCallback = fn(i64) -> i64;","attr_info":{"attributes":[{"DocComment":" The callback a host installs at run time. A bare `fn` pointer, so the set"},{"DocComment":" of addresses that can reach a call through it is not recoverable from this"},{"DocComment":" artifact — the shape used by host-settable callback hooks."}],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Alias":{"HashConsedValue":[2011,{"FnPtr":{"regions":[],"skip_binder":{"is_unsafe":false,"inputs":[{"Deduplicated":231}],"output":{"Deduplicated":231}}}}]}},"layout":[{"key":"aarch64-apple-darwin","value":{"size":8,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":4,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["HostRegistry",0]}],"span":{"data":{"file_id":0,"beg":{"line":159,"col":0},"end":{"line":162,"col":1}},"generated_from_span":null},"source_text":"pub struct HostRegistry {\n pub slot: HostCallback,\n pub maybe_slot: Option,\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Struct":[{"span":{"data":{"file_id":0,"beg":{"line":160,"col":4},"end":{"line":160,"col":26}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"slot","ty":{"Deduplicated":2011}},{"span":{"data":{"file_id":0,"beg":{"line":161,"col":4},"end":{"line":161,"col":40}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":"maybe_slot","ty":{"HashConsedValue":[2015,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":2011}],"const_generics":[],"trait_refs":[{"HashConsedValue":[2014,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[2013,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":2011}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2011}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":16,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0,8],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":5,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Ident":["Result",0]}],"span":{"data":{"file_id":3,"beg":{"line":557,"col":0},"end":{"line":557,"col":21}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" `Result` is a type that represents either success ([`Ok`]) or failure ([`Err`])."},{"DocComment":""},{"DocComment":" See the [module documentation](self) for details."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Result"},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":557,"col":16},"end":{"line":557,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":557,"col":19},"end":{"line":557,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2023,{"TypeVar":{"Bound":[1,1]}}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":3,"beg":{"line":561,"col":4},"end":{"line":561,"col":6}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Contains the success value"}],"inline":null,"rename":null,"public":true},"name":"Ok","fields":[{"span":{"data":{"file_id":3,"beg":{"line":561,"col":53},"end":{"line":561,"col":54}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":220}}],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":3,"beg":{"line":566,"col":4},"end":{"line":566,"col":7}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Contains the error value"}],"inline":null,"rename":null,"public":true},"name":"Err","fields":[{"span":{"data":{"file_id":3,"beg":{"line":566,"col":54},"end":{"line":566,"col":55}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"HashConsedValue":[2027,{"TypeVar":{"Bound":[0,1]}}]}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}}]},"layout":[],"ptr_metadata":"None"},{"def_id":6,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Ident":["Iter",0]}],"span":{"data":{"file_id":4,"beg":{"line":69,"col":0},"end":{"line":69,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Immutable slice iterator"},{"DocComment":""},{"DocComment":" This struct is created by the [`iter`] method on [slices]."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // First, we need a slice to call the `iter` method on:"},{"DocComment":" let slice = &[1, 2, 3];"},{"DocComment":""},{"DocComment":" // Then we call `iter` on the slice to get the `Iter` iterator,"},{"DocComment":" // and iterate over it:"},{"DocComment":" for element in slice.iter() {"},{"DocComment":" println!(\"{element}\");"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // This for loop actually already works without calling `iter`:"},{"DocComment":" for element in slice {"},{"DocComment":" println!(\"{element}\");"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`iter`]: slice::iter"},{"DocComment":" [slices]: slice"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"SliceIter"},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Shared"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":4,"beg":{"line":69,"col":20},"end":{"line":69,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[{"regions":[],"skip_binder":[{"Deduplicated":188},{"Var":{"Bound":[1,0]}}]},{"regions":[],"skip_binder":[{"Deduplicated":188},{"Var":{"Bound":[1,0]}}]}],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[{"key":"aarch64-apple-darwin","value":{"size":16,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0,8,16],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":7,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Ident":["Option",0]}],"span":{"data":{"file_id":6,"beg":{"line":600,"col":0},"end":{"line":600,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The `Option` type. See [the module level documentation](self) for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Option"},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":600,"col":16},"end":{"line":600,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":6,"beg":{"line":604,"col":4},"end":{"line":604,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" No value."}],"inline":null,"rename":null,"public":true},"name":"None","fields":[],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":6,"beg":{"line":608,"col":4},"end":{"line":608,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Some value of type `T`."}],"inline":null,"rename":null,"public":true},"name":"Some","fields":[{"span":{"data":{"file_id":6,"beg":{"line":608,"col":55},"end":{"line":608,"col":56}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":220}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}}]},"layout":[],"ptr_metadata":"None"},{"def_id":8,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]}],"span":{"data":{"file_id":8,"beg":{"line":20,"col":0},"end":{"line":20,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A by-value [array] iterator."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"ArrayIntoIter"},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":20,"col":20},"end":{"line":20,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":9,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["control_flow",0]},{"Ident":["ControlFlow",0]}],"span":{"data":{"file_id":10,"beg":{"line":89,"col":0},"end":{"line":89,"col":31}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used to tell an operation whether it should exit early or go on as usual."},{"DocComment":""},{"DocComment":" This is used when exposing things (like graph traversals or visitors) where"},{"DocComment":" you want the user to be able to choose whether to exit early."},{"DocComment":" Having the enum makes it clearer -- no more wondering \"wait, what did `false`"},{"DocComment":" mean again?\" -- and allows including a value."},{"DocComment":""},{"DocComment":" Similar to [`Option`] and [`Result`], this enum can be used with the `?` operator"},{"DocComment":" to return immediately if the [`Break`] variant is present or otherwise continue normally"},{"DocComment":" with the value inside the [`Continue`] variant."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Early-exiting from [`Iterator::try_for_each`]:"},{"DocComment":" ```"},{"DocComment":" use std::ops::ControlFlow;"},{"DocComment":""},{"DocComment":" let r = (2..100).try_for_each(|x| {"},{"DocComment":" if 403 % x == 0 {"},{"DocComment":" return ControlFlow::Break(x)"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" ControlFlow::Continue(())"},{"DocComment":" });"},{"DocComment":" assert_eq!(r, ControlFlow::Break(13));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" A basic tree traversal:"},{"DocComment":" ```"},{"DocComment":" use std::ops::ControlFlow;"},{"DocComment":""},{"DocComment":" pub struct TreeNode {"},{"DocComment":" value: T,"},{"DocComment":" left: Option>>,"},{"DocComment":" right: Option>>,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl TreeNode {"},{"DocComment":" pub fn traverse_inorder(&self, f: &mut impl FnMut(&T) -> ControlFlow) -> ControlFlow {"},{"DocComment":" if let Some(left) = &self.left {"},{"DocComment":" left.traverse_inorder(f)?;"},{"DocComment":" }"},{"DocComment":" f(&self.value)?;"},{"DocComment":" if let Some(right) = &self.right {"},{"DocComment":" right.traverse_inorder(f)?;"},{"DocComment":" }"},{"DocComment":" ControlFlow::Continue(())"},{"DocComment":" }"},{"DocComment":" fn leaf(value: T) -> Option>> {"},{"DocComment":" Some(Box::new(Self { value, left: None, right: None }))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let node = TreeNode {"},{"DocComment":" value: 0,"},{"DocComment":" left: TreeNode::leaf(1),"},{"DocComment":" right: Some(Box::new(TreeNode {"},{"DocComment":" value: -1,"},{"DocComment":" left: TreeNode::leaf(5),"},{"DocComment":" right: TreeNode::leaf(2),"},{"DocComment":" }))"},{"DocComment":" };"},{"DocComment":" let mut sum = 0;"},{"DocComment":""},{"DocComment":" let res = node.traverse_inorder(&mut |val| {"},{"DocComment":" if *val < 0 {"},{"DocComment":" ControlFlow::Break(*val)"},{"DocComment":" } else {"},{"DocComment":" sum += *val;"},{"DocComment":" ControlFlow::Continue(())"},{"DocComment":" }"},{"DocComment":" });"},{"DocComment":" assert_eq!(res, ControlFlow::Break(-1));"},{"DocComment":" assert_eq!(sum, 6);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`Break`]: ControlFlow::Break"},{"DocComment":" [`Continue`]: ControlFlow::Continue"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"ControlFlow"},"generics":{"regions":[],"types":[{"index":0,"name":"B"},{"index":1,"name":"C"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":10,"beg":{"line":89,"col":21},"end":{"line":89,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":10,"beg":{"line":89,"col":24},"end":{"line":89,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":10,"beg":{"line":93,"col":4},"end":{"line":93,"col":12}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Move on to the next phase of the operation as normal."}],"inline":null,"rename":null,"public":true},"name":"Continue","fields":[{"span":{"data":{"file_id":10,"beg":{"line":93,"col":13},"end":{"line":93,"col":14}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":2027}}],"discriminant":{"Scalar":{"Signed":["Isize","0"]}}},{"id":1,"span":{"data":{"file_id":10,"beg":{"line":97,"col":4},"end":{"line":97,"col":9}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" Exit the operation without running subsequent phases."}],"inline":null,"rename":null,"public":true},"name":"Break","fields":[{"span":{"data":{"file_id":10,"beg":{"line":97,"col":10},"end":{"line":97,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"name":null,"ty":{"Deduplicated":220}}],"discriminant":{"Scalar":{"Signed":["Isize","1"]}}}]},"layout":[],"ptr_metadata":"None"},{"def_id":10,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["Infallible",0]}],"span":{"data":{"file_id":12,"beg":{"line":930,"col":0},"end":{"line":930,"col":19}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The error type for errors that can never happen."},{"DocComment":""},{"DocComment":" Since this enum has no variant, a value of this type can never actually exist."},{"DocComment":" This can be useful for generic APIs that use [`Result`] and parameterize the error type,"},{"DocComment":" to indicate that the result is always [`Ok`]."},{"DocComment":""},{"DocComment":" For example, the [`TryFrom`] trait (conversion that returns a [`Result`])"},{"DocComment":" has a blanket implementation for all types where a reverse [`Into`] implementation exists."},{"DocComment":""},{"DocComment":" ```ignore (illustrates std code, duplicating the impl in a doctest would be an error)"},{"DocComment":" impl TryFrom for T where U: Into {"},{"DocComment":" type Error = Infallible;"},{"DocComment":""},{"DocComment":" fn try_from(value: U) -> Result {"},{"DocComment":" Ok(U::into(value)) // Never returns `Err`"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Future compatibility"},{"DocComment":""},{"DocComment":" This enum has the same role as [the `!` “never” type][never],"},{"DocComment":" which is unstable in this version of Rust."},{"DocComment":" When `!` is stabilized, we plan to make `Infallible` a type alias to it:"},{"DocComment":""},{"DocComment":" ```ignore (illustrates future std change)"},{"DocComment":" pub type Infallible = !;"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" … and eventually deprecate `Infallible`."},{"DocComment":""},{"DocComment":" However there is one case where `!` syntax can be used"},{"DocComment":" before `!` is stabilized as a full-fledged type: in the position of a function’s return type."},{"DocComment":" Specifically, it is possible to have implementations for two different function pointer types:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" trait MyTrait {}"},{"DocComment":" impl MyTrait for fn() -> ! {}"},{"DocComment":" impl MyTrait for fn() -> std::convert::Infallible {}"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" With `Infallible` being an enum, this code is valid."},{"DocComment":" However when `Infallible` becomes an alias for the never type,"},{"DocComment":" the two `impl`s will start to overlap"},{"DocComment":" and therefore will be disallowed by the language’s trait coherence rules."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":0,"align":1,"discriminator":null,"uninhabited":true,"variant_layouts":[],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},{"def_id":11,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]}],"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":{"Closure":{"info":{"kind":"FnOnce","fn_once_impl":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}}},"fn_mut_impl":null,"fn_impl":null,"signature":{"regions":[],"skip_binder":{"is_unsafe":false,"inputs":[],"output":{"Deduplicated":231}}}}}},"kind":{"Struct":[{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"name":null,"ty":{"HashConsedValue":[774,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":231},"Shared"]}]}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":8,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":false}}}],"ptr_metadata":"None"},null,null,{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["NonZero",0]}],"span":{"data":{"file_id":19,"beg":{"line":127,"col":0},"end":{"line":127,"col":40}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A value that is known not to equal zero."},{"DocComment":""},{"DocComment":" This enables some memory layout optimization."},{"DocComment":" For example, `Option>` is the same size as `u32`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use core::{num::NonZero};"},{"DocComment":""},{"DocComment":" assert_eq!(size_of::>>(), size_of::());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Layout"},{"DocComment":""},{"DocComment":" `NonZero` is guaranteed to have the same layout and bit validity as `T`"},{"DocComment":" with the exception that the all-zero bit pattern is invalid."},{"DocComment":" `Option>` is guaranteed to be compatible with `T`, including in"},{"DocComment":" FFI."},{"DocComment":""},{"DocComment":" Thanks to the [null pointer optimization], `NonZero` and"},{"DocComment":" `Option>` are guaranteed to have the same size and alignment:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::num::NonZero;"},{"DocComment":""},{"DocComment":" assert_eq!(size_of::>(), size_of::>>());"},{"DocComment":" assert_eq!(align_of::>(), align_of::>>());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [null pointer optimization]: crate::option#representation"},{"DocComment":""},{"DocComment":" # Note on generic usage"},{"DocComment":""},{"DocComment":" `NonZero` can only be used with some standard library primitive types"},{"DocComment":" (such as `u8`, `i32`, and etc.). The type parameter `T` must implement the"},{"DocComment":" internal trait [`ZeroablePrimitive`], which is currently permanently unstable"},{"DocComment":" and cannot be implemented by users. Therefore, you cannot use `NonZero`"},{"DocComment":" with your own types, nor can you implement traits for all `NonZero`,"},{"DocComment":" only for concrete types."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"NonZero"},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":19,"beg":{"line":127,"col":19},"end":{"line":127,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":19,"beg":{"line":127,"col":22},"end":{"line":127,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["step_by",0]},{"Ident":["StepBy",0]}],"span":{"data":{"file_id":21,"beg":{"line":16,"col":0},"end":{"line":16,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator for stepping iterators by a custom amount."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`step_by`] method on [`Iterator`]. See"},{"DocComment":" its documentation for more."},{"DocComment":""},{"DocComment":" [`step_by`]: Iterator::step_by"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":21,"beg":{"line":16,"col":18},"end":{"line":16,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["chain",0]},{"Ident":["Chain",0]}],"span":{"data":{"file_id":23,"beg":{"line":23,"col":0},"end":{"line":23,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that links two iterators together, in a chain."},{"DocComment":""},{"DocComment":" This `struct` is created by [`chain`] or [`Iterator::chain`]. See their"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::iter::Chain;"},{"DocComment":" use std::slice::Iter;"},{"DocComment":""},{"DocComment":" let a1 = [1, 2, 3];"},{"DocComment":" let a2 = [4, 5, 6];"},{"DocComment":" let iter: Chain, Iter<'_, _>> = a1.iter().chain(a2.iter());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"A"},{"index":1,"name":"B"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":23,"beg":{"line":23,"col":17},"end":{"line":23,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":23,"beg":{"line":23,"col":20},"end":{"line":23,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["Zip",0]}],"span":{"data":{"file_id":24,"beg":{"line":15,"col":0},"end":{"line":15,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that iterates two other iterators simultaneously."},{"DocComment":""},{"DocComment":" This `struct` is created by [`zip`] or [`Iterator::zip`]."},{"DocComment":" See their documentation for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"A"},{"index":1,"name":"B"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":24,"beg":{"line":15,"col":15},"end":{"line":15,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":24,"beg":{"line":15,"col":18},"end":{"line":15,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["Intersperse",0]}],"span":{"data":{"file_id":26,"beg":{"line":10,"col":0},"end":{"line":10,"col":35}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator adapter that places a separator between all elements."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::intersperse`]. See its documentation"},{"DocComment":" for more information."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":26,"beg":{"line":10,"col":23},"end":{"line":10,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":26,"beg":{"line":10,"col":26},"end":{"line":10,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":26,"beg":{"line":12,"col":13},"end":{"line":12,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"HashConsedValue":[5172,{"TraitType":[{"HashConsedValue":[5171,{"kind":{"Clause":{"Bound":[1,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"HashConsedValue":[2049,{"TypeVar":{"Bound":[2,0]}}]}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":19,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["intersperse",0]},{"Ident":["IntersperseWith",0]}],"span":{"data":{"file_id":26,"beg":{"line":91,"col":0},"end":{"line":91,"col":32}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator adapter that places a separator between all elements."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::intersperse_with`]. See its"},{"DocComment":" documentation for more information."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"G"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":26,"beg":{"line":91,"col":27},"end":{"line":91,"col":28}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":26,"beg":{"line":91,"col":30},"end":{"line":91,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":26,"beg":{"line":93,"col":7},"end":{"line":93,"col":15}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":20,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map",0]},{"Ident":["Map",0]}],"span":{"data":{"file_id":27,"beg":{"line":61,"col":0},"end":{"line":61,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that maps the values of `iter` with `f`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`map`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`map`]: Iterator::map"},{"DocComment":" [`Iterator`]: trait.Iterator.html"},{"DocComment":""},{"DocComment":" # Notes about side effects"},{"DocComment":""},{"DocComment":" The [`map`] iterator implements [`DoubleEndedIterator`], meaning that"},{"DocComment":" you can also [`map`] backwards:"},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" let v: Vec = [1, 2, 3].into_iter().map(|x| x + 1).rev().collect();"},{"DocComment":""},{"DocComment":" assert_eq!(v, [4, 3, 2]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html"},{"DocComment":""},{"DocComment":" But if your closure has state, iterating backwards may act in a way you do"},{"DocComment":" not expect. Let's go through an example. First, in the forward direction:"},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" let mut c = 0;"},{"DocComment":""},{"DocComment":" for pair in ['a', 'b', 'c'].into_iter()"},{"DocComment":" .map(|letter| { c += 1; (letter, c) }) {"},{"DocComment":" println!(\"{pair:?}\");"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" This will print `('a', 1), ('b', 2), ('c', 3)`."},{"DocComment":""},{"DocComment":" Now consider this twist where we add a call to `rev`. This version will"},{"DocComment":" print `('c', 1), ('b', 2), ('a', 3)`. Note that the letters are reversed,"},{"DocComment":" but the values of the counter still go in order. This is because `map()` is"},{"DocComment":" still being called lazily on each item, but we are popping items off the"},{"DocComment":" back of the vector now, instead of shifting them from the front."},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" let mut c = 0;"},{"DocComment":""},{"DocComment":" for pair in ['a', 'b', 'c'].into_iter()"},{"DocComment":" .map(|letter| { c += 1; (letter, c) })"},{"DocComment":" .rev() {"},{"DocComment":" println!(\"{pair:?}\");"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":27,"beg":{"line":61,"col":15},"end":{"line":61,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":27,"beg":{"line":61,"col":18},"end":{"line":61,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":21,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter",0]},{"Ident":["Filter",0]}],"span":{"data":{"file_id":28,"beg":{"line":21,"col":0},"end":{"line":21,"col":23}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that filters the elements of `iter` with `predicate`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`filter`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`filter`]: Iterator::filter"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":28,"beg":{"line":21,"col":18},"end":{"line":21,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":28,"beg":{"line":21,"col":21},"end":{"line":21,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":22,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["filter_map",0]},{"Ident":["FilterMap",0]}],"span":{"data":{"file_id":29,"beg":{"line":18,"col":0},"end":{"line":18,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that uses `f` to both filter and map elements from `iter`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`filter_map`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`filter_map`]: Iterator::filter_map"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":29,"beg":{"line":18,"col":21},"end":{"line":18,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":29,"beg":{"line":18,"col":24},"end":{"line":18,"col":25}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":23,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["enumerate",0]},{"Ident":["Enumerate",0]}],"span":{"data":{"file_id":30,"beg":{"line":18,"col":0},"end":{"line":18,"col":23}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that yields the current count and the element during iteration."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`enumerate`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`enumerate`]: Iterator::enumerate"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Enumerate"},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":30,"beg":{"line":18,"col":21},"end":{"line":18,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":24,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["peekable",0]},{"Ident":["Peekable",0]}],"span":{"data":{"file_id":31,"beg":{"line":17,"col":0},"end":{"line":17,"col":32}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator with a `peek()` that returns an optional reference to the next"},{"DocComment":" element."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`peekable`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`peekable`]: Iterator::peekable"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"IterPeekable"},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":31,"beg":{"line":17,"col":20},"end":{"line":17,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":31,"beg":{"line":17,"col":23},"end":{"line":17,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":25,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip_while",0]},{"Ident":["SkipWhile",0]}],"span":{"data":{"file_id":32,"beg":{"line":17,"col":0},"end":{"line":17,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that rejects elements while `predicate` returns `true`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`skip_while`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`skip_while`]: Iterator::skip_while"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":32,"beg":{"line":17,"col":21},"end":{"line":17,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":32,"beg":{"line":17,"col":24},"end":{"line":17,"col":25}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":26,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take_while",0]},{"Ident":["TakeWhile",0]}],"span":{"data":{"file_id":33,"beg":{"line":17,"col":0},"end":{"line":17,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that only accepts elements while `predicate` returns `true`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`take_while`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`take_while`]: Iterator::take_while"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":33,"beg":{"line":17,"col":21},"end":{"line":17,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":33,"beg":{"line":17,"col":24},"end":{"line":17,"col":25}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":27,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_while",0]},{"Ident":["MapWhile",0]}],"span":{"data":{"file_id":34,"beg":{"line":17,"col":0},"end":{"line":17,"col":25}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that only accepts elements while `predicate` returns `Some(_)`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`map_while`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`map_while`]: Iterator::map_while"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"P"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":34,"beg":{"line":17,"col":20},"end":{"line":17,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":34,"beg":{"line":17,"col":23},"end":{"line":17,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":28,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["skip",0]},{"Ident":["Skip",0]}],"span":{"data":{"file_id":35,"beg":{"line":21,"col":0},"end":{"line":21,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that skips over `n` elements of `iter`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`skip`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`skip`]: Iterator::skip"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":35,"beg":{"line":21,"col":16},"end":{"line":21,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":29,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["take",0]},{"Ident":["Take",0]}],"span":{"data":{"file_id":36,"beg":{"line":17,"col":0},"end":{"line":17,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that only iterates over the first `n` iterations of `iter`."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`take`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`take`]: Iterator::take"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":36,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":30,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["scan",0]},{"Ident":["Scan",0]}],"span":{"data":{"file_id":37,"beg":{"line":17,"col":0},"end":{"line":17,"col":25}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator to maintain state while iterating another iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`scan`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`scan`]: Iterator::scan"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"St"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":37,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":37,"beg":{"line":17,"col":19},"end":{"line":17,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":37,"beg":{"line":17,"col":23},"end":{"line":17,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[3001,{"TypeVar":{"Bound":[1,2]}}]}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":31,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["FlatMap",0]}],"span":{"data":{"file_id":38,"beg":{"line":17,"col":0},"end":{"line":17,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that maps each element to an iterator, and yields the elements"},{"DocComment":" of the produced iterators."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::flat_map`]. See its documentation"},{"DocComment":" for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"U"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":38,"beg":{"line":17,"col":19},"end":{"line":17,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":38,"beg":{"line":17,"col":22},"end":{"line":17,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":38,"beg":{"line":17,"col":39},"end":{"line":17,"col":40}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":38,"beg":{"line":17,"col":25},"end":{"line":17,"col":37}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":32,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["flatten",0]},{"Ident":["Flatten",0]}],"span":{"data":{"file_id":38,"beg":{"line":184,"col":0},"end":{"line":184,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that flattens one level of nesting in an iterator of things"},{"DocComment":" that can be turned into iterators."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`flatten`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`flatten`]: Iterator::flatten()"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":38,"beg":{"line":184,"col":19},"end":{"line":184,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":38,"beg":{"line":184,"col":22},"end":{"line":184,"col":50}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":38,"beg":{"line":184,"col":37},"end":{"line":184,"col":49}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":5172}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":33,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["map_windows",0]},{"Ident":["MapWindows",0]}],"span":{"data":{"file_id":39,"beg":{"line":11,"col":0},"end":{"line":11,"col":53}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator over the mapped windows of another iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`Iterator::map_windows`]. See its"},{"DocComment":" documentation for more information."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":39,"beg":{"line":11,"col":22},"end":{"line":11,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":39,"beg":{"line":11,"col":35},"end":{"line":11,"col":36}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":39,"beg":{"line":11,"col":25},"end":{"line":11,"col":33}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":34,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["fuse",0]},{"Ident":["Fuse",0]}],"span":{"data":{"file_id":40,"beg":{"line":17,"col":0},"end":{"line":17,"col":18}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that yields `None` forever after the underlying iterator"},{"DocComment":" yields `None` once."},{"DocComment":""},{"DocComment":" This `struct` is created by [`Iterator::fuse`]. See its documentation"},{"DocComment":" for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":40,"beg":{"line":17,"col":16},"end":{"line":17,"col":17}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":35,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["inspect",0]},{"Ident":["Inspect",0]}],"span":{"data":{"file_id":41,"beg":{"line":18,"col":0},"end":{"line":18,"col":24}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that calls a function with a reference to each element before"},{"DocComment":" yielding it."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`inspect`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`inspect`]: Iterator::inspect"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":41,"beg":{"line":18,"col":19},"end":{"line":18,"col":20}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":41,"beg":{"line":18,"col":22},"end":{"line":18,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":36,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ordering",0]}],"span":{"data":{"file_id":46,"beg":{"line":396,"col":0},"end":{"line":396,"col":17}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An `Ordering` is the result of a comparison between two values."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" assert_eq!(1.cmp(&2), Ordering::Less);"},{"DocComment":""},{"DocComment":" assert_eq!(1.cmp(&1), Ordering::Equal);"},{"DocComment":""},{"DocComment":" assert_eq!(2.cmp(&1), Ordering::Greater);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Ordering"},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":{"Enum":[{"id":0,"span":{"data":{"file_id":46,"beg":{"line":399,"col":4},"end":{"line":399,"col":8}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" An ordering where a compared value is less than another."}],"inline":null,"rename":null,"public":true},"name":"Less","fields":[],"discriminant":{"Scalar":{"Signed":["I8","-1"]}}},{"id":1,"span":{"data":{"file_id":46,"beg":{"line":402,"col":4},"end":{"line":402,"col":9}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" An ordering where a compared value is equal to another."}],"inline":null,"rename":null,"public":true},"name":"Equal","fields":[],"discriminant":{"Scalar":{"Signed":["I8","0"]}}},{"id":2,"span":{"data":{"file_id":46,"beg":{"line":405,"col":4},"end":{"line":405,"col":11}},"generated_from_span":null},"attr_info":{"attributes":[{"DocComment":" An ordering where a compared value is greater than another."}],"inline":null,"rename":null,"public":true},"name":"Greater","fields":[],"discriminant":{"Scalar":{"Signed":["I8","1"]}}}]},"layout":[{"key":"aarch64-apple-darwin","value":{"size":1,"align":1,"discriminator":{"Branch":{"offset":0,"int_ty":{"Signed":"I8"},"children":[[{"start":{"Signed":["I8","-1"]},"end":{"Signed":["I8","-1"]}},{"Known":0}],[{"start":{"Signed":["I8","0"]},"end":{"Signed":["I8","0"]}},{"Known":1}],[{"start":{"Signed":["I8","1"]},"end":{"Signed":["I8","1"]}},{"Known":2}]],"fallback":"Invalid"}},"uninhabited":false,"variant_layouts":[{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Signed":["I8","-1"]}]]},{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Signed":["I8","0"]}]]},{"field_offsets":[],"uninhabited":false,"tagger":[[0,{"Signed":["I8","1"]}]]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":false,"explicit_discr_type":true}}}],"ptr_metadata":"None"},{"def_id":37,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["rev",0]},{"Ident":["Rev",0]}],"span":{"data":{"file_id":47,"beg":{"line":15,"col":0},"end":{"line":15,"col":17}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A double-ended iterator with the direction inverted."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`rev`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`rev`]: Iterator::rev"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":47,"beg":{"line":15,"col":15},"end":{"line":15,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":38,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["copied",0]},{"Ident":["Copied",0]}],"span":{"data":{"file_id":48,"beg":{"line":19,"col":0},"end":{"line":19,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that copies the elements of an underlying iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`copied`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`copied`]: Iterator::copied"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":48,"beg":{"line":19,"col":18},"end":{"line":19,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":39,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cloned",0]},{"Ident":["Cloned",0]}],"span":{"data":{"file_id":49,"beg":{"line":18,"col":0},"end":{"line":18,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that clones the elements of an underlying iterator."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`cloned`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`cloned`]: Iterator::cloned"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":49,"beg":{"line":18,"col":18},"end":{"line":18,"col":19}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":40,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["cycle",0]},{"Ident":["Cycle",0]}],"span":{"data":{"file_id":50,"beg":{"line":15,"col":0},"end":{"line":15,"col":19}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that repeats endlessly."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`cycle`] method on [`Iterator`]. See its"},{"DocComment":" documentation for more."},{"DocComment":""},{"DocComment":" [`cycle`]: Iterator::cycle"},{"DocComment":" [`Iterator`]: trait.Iterator.html"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":50,"beg":{"line":15,"col":17},"end":{"line":15,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},{"def_id":41,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["array_chunks",0]},{"Ident":["ArrayChunks",0]}],"span":{"data":{"file_id":51,"beg":{"line":19,"col":0},"end":{"line":19,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator over `N` elements of the iterator at a time."},{"DocComment":""},{"DocComment":" The chunks do not overlap. If `N` does not divide the length of the"},{"DocComment":" iterator, then the last up to `N-1` elements will be omitted."},{"DocComment":""},{"DocComment":" This `struct` is created by the [`array_chunks`][Iterator::array_chunks]"},{"DocComment":" method on [`Iterator`]. See its documentation for more."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":51,"beg":{"line":19,"col":23},"end":{"line":19,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":51,"beg":{"line":19,"col":26},"end":{"line":19,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[],"ptr_metadata":"None"},null,null,{"def_id":44,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Ident":["NonZeroUsizeInner",0]}],"span":{"data":{"file_id":53,"beg":{"line":20,"col":8},"end":{"line":20,"col":55}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"src":"TopLevel","kind":"Opaque","layout":[{"key":"aarch64-apple-darwin","value":{"size":8,"align":8,"discriminator":{"Known":0},"uninhabited":false,"variant_layouts":[{"field_offsets":[0],"uninhabited":false,"tagger":[]}],"repr":{"repr_algo":"Rust","align_modif":null,"transparent":true,"explicit_discr_type":false}}}],"ptr_metadata":"None"},null,null,null,null,null,null],"fun_decls":[{"def_id":0,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["straight_line_add",0]}],"span":{"data":{"file_id":0,"beg":{"line":14,"col":0},"end":{"line":18,"col":1}},"generated_from_span":null},"source_text":"pub fn straight_line_add(a: i64, b: i64, c: i64) -> i64 {\n let s = a + b;\n let t = s * 2;\n t + c\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":231},{"Deduplicated":231},{"Deduplicated":231}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":14,"col":0},"end":{"line":18,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":3,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":14,"col":52},"end":{"line":14,"col":55}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"a","span":{"data":{"file_id":0,"beg":{"line":14,"col":25},"end":{"line":14,"col":26}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":2,"name":"b","span":{"data":{"file_id":0,"beg":{"line":14,"col":33},"end":{"line":14,"col":34}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":"c","span":{"data":{"file_id":0,"beg":{"line":14,"col":41},"end":{"line":14,"col":42}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":4,"name":"s","span":{"data":{"file_id":0,"beg":{"line":15,"col":8},"end":{"line":15,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":13}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":15,"col":16},"end":{"line":15,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[236,{"Adt":{"id":"Tuple","generics":{"regions":[],"types":[{"Deduplicated":231},{"Deduplicated":235}],"const_generics":[],"trait_refs":[]}}}]}},{"index":8,"name":"t","span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":13}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":236}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":15,"col":8},"end":{"line":15,"col":9}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":8},"end":{"line":15,"col":9}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":8},"end":{"line":15,"col":9}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":8},"end":{"line":15,"col":9}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":13}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":13}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":16},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":16},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":5},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":6},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":231}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":14,"col":0},"end":{"line":18,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":15,"col":12},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":16},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":15,"col":16},"end":{"line":15,"col":17}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":8},"end":{"line":16,"col":9}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":13}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":13}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":4},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":236}},{"BinaryOp":["MulChecked",{"Copy":{"kind":{"Local":9},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","2"]}}},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":10},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Mul":"Wrap"},{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","2"]}}},"ty":{"Deduplicated":231}}}]}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":16,"col":12},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":10},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":16,"col":16},"end":{"line":16,"col":17}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":5}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":5}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":8},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":11},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":12},"ty":{"Deduplicated":231}}}]}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":17,"col":4},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":17,"col":8},"end":{"line":17,"col":9}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":0},"end":{"line":18,"col":1}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":18,"col":0},"end":{"line":18,"col":1}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":18,"col":1},"end":{"line":18,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":1,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["branch_loop_sum",0]}],"span":{"data":{"file_id":0,"beg":{"line":22,"col":0},"end":{"line":32,"col":1}},"generated_from_span":null},"source_text":"pub fn branch_loop_sum(slice: &[i64], threshold: i64) -> i64 {\n let mut acc: i64 = 0;\n for &v in slice {\n if v > threshold {\n acc += v;\n } else {\n acc -= v;\n }\n }\n acc\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[238,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[237,{"Slice":{"Deduplicated":231}}]},"Shared"]}]},{"Deduplicated":231}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":22,"col":0},"end":{"line":32,"col":1}},"generated_from_span":null},"bound_body_regions":30,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":22,"col":57},"end":{"line":22,"col":60}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"slice","span":{"data":{"file_id":0,"beg":{"line":22,"col":23},"end":{"line":22,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[241,{"Ref":[{"Body":1},{"Deduplicated":237},"Shared"]}]}},{"index":2,"name":"threshold","span":{"data":{"file_id":0,"beg":{"line":22,"col":38},"end":{"line":22,"col":47}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":"acc","span":{"data":{"file_id":0,"beg":{"line":23,"col":8},"end":{"line":23,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[358,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":3}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"HashConsedValue":[356,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[355,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[359,{"Ref":[{"Body":4},{"Deduplicated":237},"Shared"]}]}},{"index":6,"name":"iter","span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[360,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":5}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[5996,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[398,{"Ref":[{"Body":12},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5995,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5994,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":398}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":398}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[408,{"Ref":[{"Body":17},{"HashConsedValue":[407,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":18}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]},"Mut"]}]}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[410,{"Ref":[{"Body":19},{"HashConsedValue":[409,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":20}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]},"Mut"]}]}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":24,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"ty":{"HashConsedValue":[411,{"Literal":{"Int":"Isize"}}]}},{"index":11,"name":"v","span":{"data":{"file_id":0,"beg":{"line":24,"col":9},"end":{"line":24,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":12}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":25,"col":15},"end":{"line":25,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":19},"end":{"line":26,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":26,"col":12},"end":{"line":26,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":236}},{"index":17,"name":null,"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":18,"name":null,"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":23,"col":8},"end":{"line":23,"col":15}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":23,"col":8},"end":{"line":23,"col":15}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":23,"col":8},"end":{"line":23,"col":15}},"generated_from_span":null},"kind":{"StorageLive":18},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":23,"col":8},"end":{"line":23,"col":15}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":23,"col":23},"end":{"line":23,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":231}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":359}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":241}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":14}},"generics":{"regions":[{"Body":21}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"args":[{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":359}}}],"dest":{"kind":{"Local":4},"ty":{"Deduplicated":358}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":22,"col":0},"end":{"line":32,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":24,"col":18},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":360}},{"Use":{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":358}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":410}},{"Ref":{"place":{"kind":{"Local":6},"ty":{"Deduplicated":360}},"kind":"Mut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"HashConsedValue":[245,{"Adt":{"id":"Tuple","generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":408}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":9},"ty":{"Deduplicated":410}},"Deref"]},"ty":{"HashConsedValue":[7065,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":22}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},"kind":"TwoPhaseMut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":15}},"generics":{"regions":[{"Body":23},{"Body":25}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"args":[{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":408}}}],"dest":{"kind":{"Local":7},"ty":{"Deduplicated":5996}}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":24,"col":18},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":7},"ty":{"Deduplicated":5996}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},5],[{"Scalar":{"Signed":["Isize","1"]}},6]],7]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":31,"col":4},"end":{"line":31,"col":7}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":32,"col":0},"end":{"line":32,"col":1}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":32,"col":1},"end":{"line":32,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":24,"col":9},"end":{"line":24,"col":10}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":24,"col":9},"end":{"line":24,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":5996}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"HashConsedValue":[7066,{"Ref":[{"Body":29},{"Deduplicated":231},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":12}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":12}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":15},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":15},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":235}},{"BinaryOp":["Gt",{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":14},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":25,"col":11},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":12},"ty":{"Deduplicated":235}}},"targets":{"If":[8,9]}}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":14},"end":{"line":24,"col":19}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":25,"col":23},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":23},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":19},"end":{"line":26,"col":20}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":19},"end":{"line":26,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":12},"end":{"line":26,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":26,"col":12},"end":{"line":26,"col":20}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":19},"ty":{"Deduplicated":231}}}]}},"target":10,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":25,"col":23},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":25,"col":23},"end":{"line":25,"col":24}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"StorageLive":17},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":17},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":18},"ty":{"Deduplicated":236}},{"BinaryOp":["SubChecked",{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":17},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":18},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Sub":"Wrap"},{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":21},"ty":{"Deduplicated":231}}}]}},"target":11,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":26,"col":12},"end":{"line":26,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":26,"col":19},"end":{"line":26,"col":20}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":29,"col":9}},"generated_from_span":null},"kind":{"Goto":{"target":12}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":28,"col":12},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":18},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":28,"col":19},"end":{"line":28,"col":20}},"generated_from_span":null},"kind":{"StorageDead":17},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":25,"col":8},"end":{"line":29,"col":9}},"generated_from_span":null},"kind":{"Goto":{"target":12}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":29,"col":8},"end":{"line":29,"col":9}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":30,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":24,"col":4},"end":{"line":30,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}}],"comments":[]}}},{"def_id":2,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["slice_of_refs_sum",0]}],"span":{"data":{"file_id":0,"beg":{"line":42,"col":0},"end":{"line":48,"col":1}},"generated_from_span":null},"source_text":"pub fn slice_of_refs_sum(slice: &[&i64]) -> i64 {\n let mut acc: i64 = 0;\n for r in slice {\n acc += **r;\n }\n acc\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7069,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[7068,{"Slice":{"HashConsedValue":[7067,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":231},"Shared"]}]}}]},"Shared"]}]}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":42,"col":0},"end":{"line":48,"col":1}},"generated_from_span":null},"bound_body_regions":86,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":42,"col":44},"end":{"line":42,"col":47}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"slice","span":{"data":{"file_id":0,"beg":{"line":42,"col":25},"end":{"line":42,"col":30}},"generated_from_span":null},"ty":{"HashConsedValue":[648,{"Ref":[{"Body":4},{"HashConsedValue":[647,{"Slice":{"HashConsedValue":[646,{"Ref":[{"Body":5},{"Deduplicated":231},"Shared"]}]}}]},"Shared"]}]}},{"index":2,"name":"acc","span":{"data":{"file_id":0,"beg":{"line":43,"col":8},"end":{"line":43,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"ty":{"HashConsedValue":[6004,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":12}],"types":[{"HashConsedValue":[399,{"Ref":[{"Body":13},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6003,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[400,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":399}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":399}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"ty":{"HashConsedValue":[658,{"Ref":[{"Body":16},{"HashConsedValue":[657,{"Slice":{"HashConsedValue":[656,{"Ref":[{"Body":17},{"Deduplicated":231},"Shared"]}]}}]},"Shared"]}]}},{"index":5,"name":"iter","span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"ty":{"HashConsedValue":[6006,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":18}],"types":[{"HashConsedValue":[659,{"Ref":[{"Body":19},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6005,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[867,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":659}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":659}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"ty":{"HashConsedValue":[6009,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[688,{"Ref":[{"Body":36},{"HashConsedValue":[687,{"Ref":[{"Body":37},{"Deduplicated":231},"Shared"]}]},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6008,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6007,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":688}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":688}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"ty":{"HashConsedValue":[6013,{"Ref":[{"Body":47},{"HashConsedValue":[6012,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":48}],"types":[{"HashConsedValue":[704,{"Ref":[{"Body":49},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6011,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6010,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":704}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":704}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]},"Mut"]}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"ty":{"HashConsedValue":[6017,{"Ref":[{"Body":52},{"HashConsedValue":[6016,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":53}],"types":[{"HashConsedValue":[711,{"Ref":[{"Body":54},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6015,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6014,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":711}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":711}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]},"Mut"]}]}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":44,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":10,"name":"r","span":{"data":{"file_id":0,"beg":{"line":44,"col":8},"end":{"line":44,"col":9}},"generated_from_span":null},"ty":{"HashConsedValue":[719,{"Ref":[{"Body":57},{"HashConsedValue":[718,{"Ref":[{"Body":58},{"Deduplicated":231},"Shared"]}]},"Shared"]}]}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":45,"col":15},"end":{"line":45,"col":18}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":45,"col":8},"end":{"line":45,"col":18}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":43,"col":8},"end":{"line":43,"col":15}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":43,"col":8},"end":{"line":43,"col":15}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":43,"col":8},"end":{"line":43,"col":15}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":43,"col":23},"end":{"line":43,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":658}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":648}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":14}},"generics":{"regions":[{"Body":59}],"types":[{"HashConsedValue":[733,{"Ref":[{"Body":60},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6019,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6018,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":733}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":733}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":658}}}],"dest":{"kind":{"Local":3},"ty":{"Deduplicated":6004}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":42,"col":0},"end":{"line":48,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":44,"col":17},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":6006}},{"Use":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":6004}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":44,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":6017}},{"Ref":{"place":{"kind":{"Local":5},"ty":{"Deduplicated":6006}},"kind":"Mut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":6013}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":8},"ty":{"Deduplicated":6017}},"Deref"]},"ty":{"HashConsedValue":[7074,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":65}],"types":[{"HashConsedValue":[738,{"Ref":[{"Body":66},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7073,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7072,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7071,{"Ref":[{"Body":67},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[741,{"Ref":[{"Body":68},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"kind":"TwoPhaseMut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":15}},"generics":{"regions":[{"Body":69},{"Body":76}],"types":[{"HashConsedValue":[757,{"Ref":[{"Body":70},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7075,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1020,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":757}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":757}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":7},"ty":{"Deduplicated":6013}}}],"dest":{"kind":{"Local":6},"ty":{"Deduplicated":6009}}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":44,"col":17},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":6},"ty":{"Deduplicated":6009}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},5],[{"Scalar":{"Signed":["Isize","1"]}},6]],7]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":47,"col":4},"end":{"line":47,"col":7}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":48,"col":0},"end":{"line":48,"col":1}},"generated_from_span":null},"kind":{"StorageDead":2},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":48,"col":1},"end":{"line":48,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":44,"col":8},"end":{"line":44,"col":9}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":44,"col":8},"end":{"line":44,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":719}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":6},"ty":{"Deduplicated":6009}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"HashConsedValue":[7076,{"Ref":[{"Body":83},{"HashConsedValue":[771,{"Ref":[{"Body":84},{"Deduplicated":231},"Shared"]}]},"Shared"]}]}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":45,"col":15},"end":{"line":45,"col":18}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":45,"col":15},"end":{"line":45,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":10},"ty":{"Deduplicated":719}},"Deref"]},"ty":{"HashConsedValue":[7077,{"Ref":[{"Body":85},{"Deduplicated":231},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":45,"col":8},"end":{"line":45,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":45,"col":8},"end":{"line":45,"col":18}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}]}},"target":8,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":44,"col":13},"end":{"line":44,"col":18}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":45,"col":8},"end":{"line":45,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":45,"col":17},"end":{"line":45,"col":18}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":46,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":44,"col":4},"end":{"line":46,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}}],"comments":[]}}},{"def_id":3,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["array_of_refs_sum",0]}],"span":{"data":{"file_id":0,"beg":{"line":51,"col":0},"end":{"line":57,"col":1}},"generated_from_span":null},"source_text":"pub fn array_of_refs_sum(refs: [&i64; 3]) -> i64 {\n let mut acc: i64 = 0;\n for r in refs {\n acc += *r;\n }\n acc\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7078,{"Array":[{"Deduplicated":774},{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}]}]}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":51,"col":0},"end":{"line":57,"col":1}},"generated_from_span":null},"bound_body_regions":111,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":51,"col":45},"end":{"line":51,"col":48}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"refs","span":{"data":{"file_id":0,"beg":{"line":51,"col":25},"end":{"line":51,"col":29}},"generated_from_span":null},"ty":{"HashConsedValue":[781,{"Array":[{"HashConsedValue":[641,{"Ref":[{"Body":2},{"Deduplicated":231},"Shared"]}]},{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}]}]}},{"index":2,"name":"acc","span":{"data":{"file_id":0,"beg":{"line":52,"col":8},"end":{"line":52,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[6062,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[391,{"Ref":[{"Body":8},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[6061,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6060,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":391}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":391}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[863,{"Array":[{"HashConsedValue":[394,{"Ref":[{"Body":11},{"Deduplicated":231},"Shared"]}]},{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}]}]}},{"index":5,"name":"iter","span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[6063,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"Deduplicated":398}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":5995}]}}}]}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[6066,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[660,{"Ref":[{"Body":20},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6065,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6064,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":660}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":660}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[6070,{"Ref":[{"Body":27},{"HashConsedValue":[6069,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[630,{"Ref":[{"Body":28},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[6068,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6067,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":630}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":630}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]},"Mut"]}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"ty":{"HashConsedValue":[6074,{"Ref":[{"Body":31},{"HashConsedValue":[6073,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[679,{"Ref":[{"Body":32},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[6072,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6071,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":679}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":679}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]},"Mut"]}]}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":53,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":10,"name":"r","span":{"data":{"file_id":0,"beg":{"line":53,"col":8},"end":{"line":53,"col":9}},"generated_from_span":null},"ty":{"HashConsedValue":[682,{"Ref":[{"Body":35},{"Deduplicated":231},"Shared"]}]}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":54,"col":15},"end":{"line":54,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":54,"col":8},"end":{"line":54,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":52,"col":8},"end":{"line":52,"col":15}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":52,"col":8},"end":{"line":52,"col":15}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":52,"col":8},"end":{"line":52,"col":15}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":52,"col":23},"end":{"line":52,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":863}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":781}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":16}},"generics":{"regions":[],"types":[{"HashConsedValue":[6075,{"Ref":[{"Body":36},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[7084,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7083,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6075}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6075}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":863}}}],"dest":{"kind":{"Local":3},"ty":{"Deduplicated":6062}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":51,"col":0},"end":{"line":57,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":53,"col":16},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":6063}},{"Use":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":6062}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":53,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":6074}},{"Ref":{"place":{"kind":{"Local":5},"ty":{"Deduplicated":6063}},"kind":"Mut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":6070}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":8},"ty":{"Deduplicated":6074}},"Deref"]},"ty":{"HashConsedValue":[7090,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"HashConsedValue":[7085,{"Ref":[{"Body":41},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[7089,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7087,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7086,{"Ref":[{"Body":42},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7088,{"Ref":[{"Body":43},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"kind":"TwoPhaseMut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":17}},"generics":{"regions":[{"Body":50}],"types":[{"HashConsedValue":[697,{"Ref":[{"Body":44},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[7092,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7091,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":697}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":697}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":7},"ty":{"Deduplicated":6070}}}],"dest":{"kind":{"Local":6},"ty":{"Deduplicated":6066}}},"target":5,"on_unwind":4}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Drop":{"kind":"Conditional","place":{"kind":{"Local":5},"ty":{"Deduplicated":6063}},"fn_ptr":{"kind":{"Fun":{"Regular":256}},"generics":{"regions":[],"types":[{"Deduplicated":733}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":6019}]}},"target":6,"on_unwind":7}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":53,"col":16},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":6},"ty":{"Deduplicated":6066}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},8],[{"Scalar":{"Signed":["Isize","1"]}},9]],10]}}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Drop":{"kind":"Conditional","place":{"kind":{"Local":3},"ty":{"Deduplicated":6062}},"fn_ptr":{"kind":{"Fun":{"Regular":256}},"generics":{"regions":[],"types":[{"HashConsedValue":[6090,{"Ref":[{"Body":74},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[6314,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6313,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6090}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6090}],"const_generics":[],"trait_refs":[]}}}}]}]}},"target":1,"on_unwind":11}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Abort":"UnwindTerminate"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Drop":{"kind":"Conditional","place":{"kind":{"Local":5},"ty":{"Deduplicated":6063}},"fn_ptr":{"kind":{"Fun":{"Regular":256}},"generics":{"regions":[],"types":[{"HashConsedValue":[6097,{"Ref":[{"Body":92},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[6320,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6319,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6097}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6097}],"const_generics":[],"trait_refs":[]}}}}]}]}},"target":13,"on_unwind":6}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":53,"col":8},"end":{"line":53,"col":9}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":53,"col":8},"end":{"line":53,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":682}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":6},"ty":{"Deduplicated":6066}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"HashConsedValue":[767,{"Ref":[{"Body":82},{"Deduplicated":231},"Shared"]}]}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":54,"col":15},"end":{"line":54,"col":17}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":54,"col":15},"end":{"line":54,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":10},"ty":{"Deduplicated":682}},"Deref"]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":54,"col":8},"end":{"line":54,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":54,"col":8},"end":{"line":54,"col":17}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}]}},"target":12,"on_unwind":4}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":53,"col":13},"end":{"line":53,"col":17}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Abort":"UnwindTerminate"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":54,"col":8},"end":{"line":54,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":54,"col":16},"end":{"line":54,"col":17}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":53,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"Drop":{"kind":"Conditional","place":{"kind":{"Local":3},"ty":{"Deduplicated":6062}},"fn_ptr":{"kind":{"Fun":{"Regular":256}},"generics":{"regions":[],"types":[{"HashConsedValue":[6104,{"Ref":[{"Body":106},{"Deduplicated":231},"Shared"]}]}],"const_generics":[{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","3"]}}},"ty":{"Deduplicated":775}}],"trait_refs":[{"HashConsedValue":[6326,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6325,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6104}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6104}],"const_generics":[],"trait_refs":[]}}}}]}]}},"target":14,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":55,"col":4},"end":{"line":55,"col":5}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":56,"col":4},"end":{"line":56,"col":7}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":57,"col":0},"end":{"line":57,"col":1}},"generated_from_span":null},"kind":{"StorageDead":2},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":57,"col":1},"end":{"line":57,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":4,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["strategy_len",0]}],"span":{"data":{"file_id":0,"beg":{"line":67,"col":0},"end":{"line":73,"col":1}},"generated_from_span":null},"source_text":"pub fn strategy_len(s: &Strategy) -> usize {\n match s {\n Strategy::Empty => 0,\n Strategy::IntKeyed { len } => *len,\n Strategy::StrKeyed { len, capacity: _ } => *len,\n }\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7093,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[1087,{"Adt":{"id":{"Adt":1},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]}],"output":{"Deduplicated":775}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":67,"col":0},"end":{"line":73,"col":1}},"generated_from_span":null},"bound_body_regions":5,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":67,"col":37},"end":{"line":67,"col":42}},"generated_from_span":null},"ty":{"Deduplicated":775}},{"index":1,"name":"s","span":{"data":{"file_id":0,"beg":{"line":67,"col":20},"end":{"line":67,"col":21}},"generated_from_span":null},"ty":{"HashConsedValue":[1091,{"Ref":[{"Body":1},{"Deduplicated":1087},"Shared"]}]}},{"index":2,"name":null,"span":{"data":{"file_id":0,"beg":{"line":69,"col":8},"end":{"line":69,"col":23}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":3,"name":"len","span":{"data":{"file_id":0,"beg":{"line":70,"col":29},"end":{"line":70,"col":32}},"generated_from_span":null},"ty":{"HashConsedValue":[1094,{"Ref":[{"Body":3},{"Deduplicated":775},"Shared"]}]}},{"index":4,"name":"len","span":{"data":{"file_id":0,"beg":{"line":71,"col":29},"end":{"line":71,"col":32}},"generated_from_span":null},"ty":{"HashConsedValue":[1095,{"Ref":[{"Body":4},{"Deduplicated":775},"Shared"]}]}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":68,"col":10},"end":{"line":68,"col":11}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":68,"col":10},"end":{"line":68,"col":11}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1091}},"Deref"]},"ty":{"Deduplicated":1087}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":68,"col":4},"end":{"line":68,"col":11}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":2},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},1],[{"Scalar":{"Signed":["Isize","1"]}},2],[{"Scalar":{"Signed":["Isize","2"]}},3]],4]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":69,"col":27},"end":{"line":69,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":775}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Unsigned":["Usize","0"]}}},"ty":{"Deduplicated":775}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":1},"end":{"line":73,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":70,"col":29},"end":{"line":70,"col":32}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":70,"col":29},"end":{"line":70,"col":32}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":1094}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1091}},"Deref"]},"ty":{"Deduplicated":1087}},{"Field":[{"Adt":[1,1]},0]}]},"ty":{"Deduplicated":775}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":70,"col":38},"end":{"line":70,"col":42}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":775}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":3},"ty":{"Deduplicated":1094}},"Deref"]},"ty":{"Deduplicated":775}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":70,"col":41},"end":{"line":70,"col":42}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":1},"end":{"line":73,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":71,"col":29},"end":{"line":71,"col":32}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":71,"col":29},"end":{"line":71,"col":32}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":1095}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1091}},"Deref"]},"ty":{"Deduplicated":1087}},{"Field":[{"Adt":[1,2]},0]}]},"ty":{"Deduplicated":775}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":71,"col":51},"end":{"line":71,"col":55}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":775}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":4},"ty":{"Deduplicated":1095}},"Deref"]},"ty":{"Deduplicated":775}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":71,"col":54},"end":{"line":71,"col":55}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":73,"col":1},"end":{"line":73,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":68,"col":10},"end":{"line":68,"col":11}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}}],"comments":[]}}},{"def_id":5,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["parse_one",0]}],"span":{"data":{"file_id":0,"beg":{"line":82,"col":0},"end":{"line":89,"col":1}},"generated_from_span":null},"source_text":"fn parse_one(raw: i64) -> PyResult {\n match raw {\n i64::MIN => Ok(Token::Halt),\n 0 => Err(\"halt-zero forbidden\"),\n v if v > 0 => Ok(Token::Add(v)),\n v => Ok(Token::Sub(-v)),\n }\n}","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":231}],"output":{"HashConsedValue":[7094,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"HashConsedValue":[1101,{"Adt":{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},{"Deduplicated":222}],"const_generics":[],"trait_refs":[{"HashConsedValue":[1103,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1102,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1101}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1101}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":229}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":82,"col":0},"end":{"line":89,"col":1}},"generated_from_span":null},"bound_body_regions":35,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":82,"col":26},"end":{"line":82,"col":41}},"generated_from_span":null},"ty":{"HashConsedValue":[6115,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[1118,{"Ref":[{"Body":6},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[6114,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6113,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1118}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1118}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":1,"name":"raw","span":{"data":{"file_id":0,"beg":{"line":82,"col":13},"end":{"line":82,"col":16}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":2,"name":null,"span":{"data":{"file_id":0,"beg":{"line":83,"col":10},"end":{"line":83,"col":13}},"generated_from_span":null},"ty":{"HashConsedValue":[393,{"Ref":[{"Body":10},{"Deduplicated":231},"Shared"]}]}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":84,"col":23},"end":{"line":84,"col":34}},"generated_from_span":null},"ty":{"Deduplicated":1101}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":85,"col":17},"end":{"line":85,"col":38}},"generated_from_span":null},"ty":{"HashConsedValue":[1124,{"Ref":[{"Body":11},{"Deduplicated":221},"Shared"]}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":85,"col":17},"end":{"line":85,"col":38}},"generated_from_span":null},"ty":{"HashConsedValue":[1125,{"Ref":[{"Body":12},{"Deduplicated":221},"Shared"]}]}},{"index":6,"name":"v","span":{"data":{"file_id":0,"beg":{"line":86,"col":8},"end":{"line":86,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":7,"name":"v","span":{"data":{"file_id":0,"beg":{"line":86,"col":8},"end":{"line":86,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":399}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":18}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":14}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":86,"col":25},"end":{"line":86,"col":38}},"generated_from_span":null},"ty":{"Deduplicated":1101}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":86,"col":36},"end":{"line":86,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":12,"name":"v","span":{"data":{"file_id":0,"beg":{"line":87,"col":8},"end":{"line":87,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":87,"col":16},"end":{"line":87,"col":30}},"generated_from_span":null},"ty":{"Deduplicated":1101}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":87,"col":27},"end":{"line":87,"col":29}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":87,"col":28},"end":{"line":87,"col":29}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":87,"col":27},"end":{"line":87,"col":29}},"generated_from_span":null},"ty":{"Deduplicated":235}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":83,"col":4},"end":{"line":83,"col":13}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":83,"col":4},"end":{"line":83,"col":13}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":83,"col":4},"end":{"line":83,"col":13}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":231}}},"targets":{"SwitchInt":[{"Int":"I64"},[[{"Scalar":{"Signed":["I64","-9223372036854775808"]}},1],[{"Scalar":{"Signed":["I64","0"]}},2]],3]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":84,"col":23},"end":{"line":84,"col":34}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":84,"col":23},"end":{"line":84,"col":34}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":1101}},{"Aggregate":[{"Adt":[{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},2,null]},[]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":84,"col":20},"end":{"line":84,"col":35}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":6115}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[7095,{"Ref":[{"Body":14},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[7099,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7097,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7096,{"Ref":[{"Body":18},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7098,{"Ref":[{"Body":16},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":1101}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":84,"col":34},"end":{"line":84,"col":35}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":89,"col":1},"end":{"line":89,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":85,"col":17},"end":{"line":85,"col":38}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":85,"col":17},"end":{"line":85,"col":38}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":85,"col":17},"end":{"line":85,"col":38}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":1125}},{"Use":{"Const":{"kind":{"Literal":{"Str":"halt-zero forbidden"}},"ty":{"HashConsedValue":[7100,{"Ref":[{"Body":19},{"Deduplicated":221},"Shared"]}]}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":85,"col":17},"end":{"line":85,"col":38}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":1124}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":1125}},"Deref"]},"ty":{"Deduplicated":221}},"kind":"Shared","ptr_metadata":{"Copy":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":1125}},"PtrMetadata"]},"ty":{"Deduplicated":775}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":85,"col":13},"end":{"line":85,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":6115}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[7101,{"Ref":[{"Body":20},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[7105,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7103,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7102,{"Ref":[{"Body":24},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7104,{"Ref":[{"Body":22},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},1,null]},[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":1124}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":85,"col":38},"end":{"line":85,"col":39}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":85,"col":38},"end":{"line":85,"col":39}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":89,"col":1},"end":{"line":89,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":86,"col":8},"end":{"line":86,"col":9}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":8},"end":{"line":86,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":399}},{"Ref":{"place":{"kind":{"Local":1},"ty":{"Deduplicated":231}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":83,"col":10},"end":{"line":83,"col":13}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":393}},{"Ref":{"place":{"kind":{"Local":1},"ty":{"Deduplicated":231}},"kind":"Shallow","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":14}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":14}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":399}},"Deref"]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":235}},{"BinaryOp":["Gt",{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":86,"col":13},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":235}}},"targets":{"If":[4,5]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":86,"col":17},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":17},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":8},"end":{"line":86,"col":9}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":8},"end":{"line":86,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":25},"end":{"line":86,"col":38}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":36},"end":{"line":86,"col":37}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":36},"end":{"line":86,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":6},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":25},"end":{"line":86,"col":38}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":1101}},{"Aggregate":[{"Adt":[{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},0,null]},[{"Move":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":37},"end":{"line":86,"col":38}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":22},"end":{"line":86,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":6115}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[7106,{"Ref":[{"Body":25},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[7110,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7108,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7107,{"Ref":[{"Body":29},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7109,{"Ref":[{"Body":27},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":1101}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":38},"end":{"line":86,"col":39}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":38},"end":{"line":86,"col":39}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":38},"end":{"line":86,"col":39}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":89,"col":1},"end":{"line":89,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":86,"col":17},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":17},"end":{"line":86,"col":18}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":86,"col":38},"end":{"line":86,"col":39}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":8},"end":{"line":87,"col":9}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":8},"end":{"line":87,"col":9}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":16},"end":{"line":87,"col":30}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":27},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":28},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":28},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":27},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":235}},{"BinaryOp":["Eq",{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","-9223372036854775808"]}}},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":87,"col":27},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Local":16},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"OverflowNeg":{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}}},"target":7,"on_unwind":6}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":82,"col":0},"end":{"line":89,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":87,"col":27},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":231}},{"UnaryOp":[{"Neg":"Wrap"},{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":28},"end":{"line":87,"col":29}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":16},"end":{"line":87,"col":30}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":1101}},{"Aggregate":[{"Adt":[{"id":{"Adt":2},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},1,null]},[{"Move":{"kind":{"Local":14},"ty":{"Deduplicated":231}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":29},"end":{"line":87,"col":30}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":13},"end":{"line":87,"col":31}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":6115}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[7111,{"Ref":[{"Body":30},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[7115,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7113,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7112,{"Ref":[{"Body":34},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7114,{"Ref":[{"Body":32},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":1101}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":30},"end":{"line":87,"col":31}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":87,"col":30},"end":{"line":87,"col":31}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":89,"col":1},"end":{"line":89,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":6,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["desugar_mix",0]}],"span":{"data":{"file_id":0,"beg":{"line":92,"col":0},"end":{"line":103,"col":1}},"generated_from_span":null},"source_text":"pub fn desugar_mix(input: &[i64]) -> PyResult {\n let mut acc: i64 = 0;\n for &raw in input.iter() {\n let tok = parse_one(raw)?;\n match tok {\n Token::Add(v) => acc += v,\n Token::Sub(v) => acc -= v,\n Token::Halt => break,\n }\n }\n Ok(acc)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":238}],"output":{"HashConsedValue":[7116,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":231},{"Deduplicated":222}],"const_generics":[],"trait_refs":[{"Deduplicated":356},{"Deduplicated":229}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":92,"col":0},"end":{"line":103,"col":1}},"generated_from_span":null},"bound_body_regions":147,"locals":{"arg_count":1,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":92,"col":37},"end":{"line":92,"col":50}},"generated_from_span":null},"ty":{"HashConsedValue":[6169,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":231},{"Deduplicated":1118}],"const_generics":[],"trait_refs":[{"Deduplicated":356},{"Deduplicated":6114}]}}}]}},{"index":1,"name":"input","span":{"data":{"file_id":0,"beg":{"line":92,"col":19},"end":{"line":92,"col":24}},"generated_from_span":null},"ty":{"HashConsedValue":[1161,{"Ref":[{"Body":10},{"Deduplicated":237},"Shared"]}]}},{"index":2,"name":"acc","span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[1163,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":12}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[1164,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":13}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":21}},"generated_from_span":null},"ty":{"HashConsedValue":[1165,{"Ref":[{"Body":14},{"Deduplicated":237},"Shared"]}]}},{"index":6,"name":"iter","span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[1166,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":15}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[6172,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[871,{"Ref":[{"Body":22},{"Deduplicated":231},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6171,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6170,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":871}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":871}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[1175,{"Ref":[{"Body":27},{"HashConsedValue":[1174,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":28}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]},"Mut"]}]}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"ty":{"HashConsedValue":[1177,{"Ref":[{"Body":29},{"HashConsedValue":[1176,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":30}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]},"Mut"]}]}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":11,"name":"raw","span":{"data":{"file_id":0,"beg":{"line":94,"col":9},"end":{"line":94,"col":12}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":12,"name":"tok","span":{"data":{"file_id":0,"beg":{"line":95,"col":12},"end":{"line":95,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":1101}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[6178,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[{"HashConsedValue":[6175,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"HashConsedValue":[1283,{"Adt":{"id":{"Adt":10},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},{"HashConsedValue":[1329,{"Ref":[{"Body":57},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[1285,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1284,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1283}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1283}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6174,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6173,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1329}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1329}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]},{"Deduplicated":1101}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6177,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6176,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6175}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6175}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":1103}]}}}]}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":32}},"generated_from_span":null},"ty":{"HashConsedValue":[6181,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[1358,{"Ref":[{"Body":71},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[6180,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6179,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1358}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1358}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":95,"col":28},"end":{"line":95,"col":31}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":17,"name":"residual","span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[6184,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1283},{"HashConsedValue":[1364,{"Ref":[{"Body":74},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1285},{"HashConsedValue":[6183,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6182,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1364}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1364}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":18,"name":null,"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[6187,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1283},{"HashConsedValue":[1370,{"Ref":[{"Body":77},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1285},{"HashConsedValue":[6186,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6185,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1370}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1370}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},{"index":19,"name":"val","span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"ty":{"Deduplicated":1101}},{"index":20,"name":null,"span":{"data":{"file_id":0,"beg":{"line":97,"col":12},"end":{"line":97,"col":25}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":21,"name":"v","span":{"data":{"file_id":0,"beg":{"line":97,"col":23},"end":{"line":97,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":22,"name":null,"span":{"data":{"file_id":0,"beg":{"line":97,"col":36},"end":{"line":97,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":23,"name":null,"span":{"data":{"file_id":0,"beg":{"line":97,"col":29},"end":{"line":97,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":236}},{"index":24,"name":"v","span":{"data":{"file_id":0,"beg":{"line":98,"col":23},"end":{"line":98,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":25,"name":null,"span":{"data":{"file_id":0,"beg":{"line":98,"col":36},"end":{"line":98,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":26,"name":null,"span":{"data":{"file_id":0,"beg":{"line":98,"col":29},"end":{"line":98,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":236}},{"index":27,"name":null,"span":{"data":{"file_id":0,"beg":{"line":102,"col":7},"end":{"line":102,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":231}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"kind":{"StorageLive":20},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"kind":{"StorageLive":23},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"kind":{"StorageLive":26},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":8},"end":{"line":93,"col":15}},"generated_from_span":null},"kind":{"StorageLive":2},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":93,"col":23},"end":{"line":93,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":21}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":1165}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1161}},"Deref"]},"ty":{"Deduplicated":237}},"kind":"Shared","ptr_metadata":{"Copy":{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":1161}},"PtrMetadata"]},"ty":{"Deduplicated":775}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":19}},"generics":{"regions":[{"Body":81}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"args":[{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":1165}}}],"dest":{"kind":{"Local":4},"ty":{"Deduplicated":1164}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":92,"col":0},"end":{"line":103,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":94,"col":27},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":20}},"generics":{"regions":[],"types":[{"HashConsedValue":[6188,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":82}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7124,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7123,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6188}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6188}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7125,{"kind":{"TraitImpl":{"id":1,"generics":{"regions":[{"Body":82}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":6188}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":1164}}}],"dest":{"kind":{"Local":3},"ty":{"Deduplicated":1163}}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":94,"col":27},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":1166}},{"Use":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":1163}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":4}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":1177}},{"Ref":{"place":{"kind":{"Local":6},"ty":{"Deduplicated":1166}},"kind":"Mut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":1175}},{"Ref":{"place":{"kind":{"Projection":[{"kind":{"Local":9},"ty":{"Deduplicated":1177}},"Deref"]},"ty":{"HashConsedValue":[7126,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Body":90}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},"kind":"TwoPhaseMut","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":15}},"generics":{"regions":[{"Body":91},{"Body":93}],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"args":[{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":1175}}}],"dest":{"kind":{"Local":7},"ty":{"Deduplicated":6172}}},"target":5,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":94,"col":27},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":7},"ty":{"Deduplicated":6172}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},9],[{"Scalar":{"Signed":["Isize","1"]}},6]],7]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":94,"col":9},"end":{"line":94,"col":12}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":94,"col":9},"end":{"line":94,"col":12}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":6172}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"HashConsedValue":[7127,{"Ref":[{"Body":97},{"Deduplicated":231},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":12},"end":{"line":95,"col":15}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":32}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":28},"end":{"line":95,"col":31}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":28},"end":{"line":95,"col":31}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":11},"ty":{"Deduplicated":231}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":32}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":5}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"args":[{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}],"dest":{"kind":{"Local":14},"ty":{"Deduplicated":6181}}},"target":8,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":16},"end":{"line":94,"col":28}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":95,"col":31},"end":{"line":95,"col":32}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":21}},"generics":{"regions":[],"types":[{"Deduplicated":1101},{"HashConsedValue":[6194,{"Ref":[{"Body":98},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1103},{"HashConsedValue":[7129,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7128,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6194}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6194}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":14},"ty":{"Deduplicated":6181}}}],"dest":{"kind":{"Local":13},"ty":{"Deduplicated":6178}}},"target":10,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":102,"col":7},"end":{"line":102,"col":10}},"generated_from_span":null},"kind":{"StorageLive":27},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":102,"col":7},"end":{"line":102,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":27},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":102,"col":4},"end":{"line":102,"col":11}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":6169}},{"Aggregate":[{"Adt":[{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":231},{"HashConsedValue":[7130,{"Ref":[{"Body":103},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":356},{"HashConsedValue":[7134,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7132,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7131,{"Ref":[{"Body":107},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7133,{"Ref":[{"Body":105},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}},0,null]},[{"Move":{"kind":{"Local":27},"ty":{"Deduplicated":231}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":102,"col":10},"end":{"line":102,"col":11}},"generated_from_span":null},"kind":{"StorageDead":27},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":103,"col":0},"end":{"line":103,"col":1}},"generated_from_span":null},"kind":{"StorageDead":2},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":103,"col":1},"end":{"line":103,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":13},"ty":{"Deduplicated":6178}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":16},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},11],[{"Scalar":{"Signed":["Isize","1"]}},12]],13]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageLive":19},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":19},"ty":{"Deduplicated":1101}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":6178}},{"Field":[{"Adt":[9,0]},0]}]},"ty":{"Deduplicated":1101}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":1101}},{"Use":{"Move":{"kind":{"Local":19},"ty":{"Deduplicated":1101}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageDead":19},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":33},"end":{"line":95,"col":34}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":96,"col":14},"end":{"line":96,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":20},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":12},"ty":{"Deduplicated":1101}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":96,"col":8},"end":{"line":96,"col":17}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":20},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},14],[{"Scalar":{"Signed":["Isize","1"]}},15],[{"Scalar":{"Signed":["Isize","2"]}},16]],17]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageLive":17},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":17},"ty":{"Deduplicated":6184}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":13},"ty":{"Deduplicated":6178}},{"Field":[{"Adt":[9,1]},0]}]},"ty":{"HashConsedValue":[7140,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1283},{"HashConsedValue":[7135,{"Ref":[{"Body":126},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[{"Deduplicated":1285},{"HashConsedValue":[7139,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7137,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7136,{"Ref":[{"Body":127},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7138,{"Ref":[{"Body":128},{"Deduplicated":221},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageLive":18},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":18},"ty":{"Deduplicated":6187}},{"Use":{"Copy":{"kind":{"Local":17},"ty":{"Deduplicated":6184}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":22}},"generics":{"regions":[],"types":[{"Deduplicated":231},{"HashConsedValue":[6208,{"Ref":[{"Body":129},{"Deduplicated":221},"Shared"]}]},{"Deduplicated":6208}],"const_generics":[],"trait_refs":[{"Deduplicated":356},{"HashConsedValue":[6210,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6209,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6208}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6208}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":6210},{"HashConsedValue":[7141,{"kind":{"TraitImpl":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":6208}],"const_generics":[],"trait_refs":[{"Deduplicated":6210}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":6208},{"Deduplicated":6208}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":18},"ty":{"Deduplicated":6187}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":6169}}},"target":18,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":95,"col":18},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":97,"col":23},"end":{"line":97,"col":24}},"generated_from_span":null},"kind":{"StorageLive":21},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":97,"col":23},"end":{"line":97,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":21},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":1101}},{"Field":[{"Adt":[2,0]},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":97,"col":36},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"StorageLive":22},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":97,"col":36},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":22},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":21},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":97,"col":29},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":23},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":22},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":97,"col":29},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":23},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":27},"ty":{"Deduplicated":231}}}]}},"target":19,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":98,"col":23},"end":{"line":98,"col":24}},"generated_from_span":null},"kind":{"StorageLive":24},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":98,"col":23},"end":{"line":98,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":24},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":12},"ty":{"Deduplicated":1101}},{"Field":[{"Adt":[2,1]},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":98,"col":36},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"StorageLive":25},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":98,"col":36},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":25},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":24},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":98,"col":29},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":26},"ty":{"Deduplicated":236}},{"BinaryOp":["SubChecked",{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":25},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":98,"col":29},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":26},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Sub":"Wrap"},{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":30},"ty":{"Deduplicated":231}}}]}},"target":20,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"kind":{"Goto":{"target":9}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":96,"col":14},"end":{"line":96,"col":17}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageDead":18},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":32},"end":{"line":95,"col":33}},"generated_from_span":null},"kind":{"StorageDead":17},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":95,"col":33},"end":{"line":95,"col":34}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":103,"col":0},"end":{"line":103,"col":1}},"generated_from_span":null},"kind":{"StorageDead":2},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":103,"col":1},"end":{"line":103,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":97,"col":29},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":23},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":97,"col":36},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"StorageDead":22},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":97,"col":36},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"StorageDead":21},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":97,"col":36},"end":{"line":97,"col":37}},"generated_from_span":null},"kind":{"Goto":{"target":21}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":98,"col":29},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":2},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":26},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":98,"col":36},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"StorageDead":25},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":98,"col":36},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"StorageDead":24},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":98,"col":36},"end":{"line":98,"col":37}},"generated_from_span":null},"kind":{"Goto":{"target":21}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":101,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":94,"col":4},"end":{"line":101,"col":5}},"generated_from_span":null},"kind":{"Goto":{"target":4}},"comments_before":[]}}],"comments":[]}}},{"def_id":7,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["tuple_roundtrip",0]}],"span":{"data":{"file_id":0,"beg":{"line":113,"col":0},"end":{"line":116,"col":1}},"generated_from_span":null},"source_text":"pub fn tuple_roundtrip(a: i64, b: i64) -> i64 {\n let pair = (a + b, a - b);\n pair.0 * pair.1\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":231},{"Deduplicated":231}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":113,"col":0},"end":{"line":116,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":113,"col":42},"end":{"line":113,"col":45}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"a","span":{"data":{"file_id":0,"beg":{"line":113,"col":23},"end":{"line":113,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":2,"name":"b","span":{"data":{"file_id":0,"beg":{"line":113,"col":31},"end":{"line":113,"col":32}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":"pair","span":{"data":{"file_id":0,"beg":{"line":114,"col":8},"end":{"line":114,"col":12}},"generated_from_span":null},"ty":{"HashConsedValue":[1861,{"Adt":{"id":"Tuple","generics":{"regions":[],"types":[{"Deduplicated":231},{"Deduplicated":231}],"const_generics":[],"trait_refs":[]}}}]}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":20},"end":{"line":114,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":236}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":28}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":10,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":27},"end":{"line":114,"col":28}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":28}},"generated_from_span":null},"ty":{"Deduplicated":236}},{"index":12,"name":null,"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":115,"col":13},"end":{"line":115,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":114,"col":8},"end":{"line":114,"col":12}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":8},"end":{"line":114,"col":12}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":8},"end":{"line":114,"col":12}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":8},"end":{"line":114,"col":12}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":17}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":20},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":20},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":5},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":6},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":231}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":113,"col":0},"end":{"line":116,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":114,"col":16},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":7},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":20},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":20},"end":{"line":114,"col":21}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":24}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":27},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":27},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":236}},{"BinaryOp":["SubChecked",{"Copy":{"kind":{"Local":9},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":10},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":11},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Sub":"Wrap"},{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":10},"ty":{"Deduplicated":231}}}]}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":114,"col":23},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":11},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":27},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":27},"end":{"line":114,"col":28}},"generated_from_span":null},"kind":{"StorageDead":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":15},"end":{"line":114,"col":29}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":1861}},{"Aggregate":[{"Adt":[{"id":"Tuple","generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},null,null]},[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":231}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":28},"end":{"line":114,"col":29}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":114,"col":28},"end":{"line":114,"col":29}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":10}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":3},"ty":{"Deduplicated":1861}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":13},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":13},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":3},"ty":{"Deduplicated":1861}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":236}},{"BinaryOp":["MulChecked",{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":13},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":14},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Mul":"Wrap"},{"Move":{"kind":{"Local":12},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":231}}}]}},"target":4,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":115,"col":4},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":14},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":18},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":115,"col":18},"end":{"line":115,"col":19}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":116,"col":0},"end":{"line":116,"col":1}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":116,"col":1},"end":{"line":116,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":8,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]}],"span":{"data":{"file_id":0,"beg":{"line":125,"col":0},"end":{"line":127,"col":1}},"generated_from_span":null},"source_text":"pub fn bool_then_closure(c: bool, x: i64) -> Option {\n c.then(|| x + 1)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":235},{"Deduplicated":231}],"output":{"HashConsedValue":[1862,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}}]}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":125,"col":0},"end":{"line":127,"col":1}},"generated_from_span":null},"bound_body_regions":16,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":125,"col":45},"end":{"line":125,"col":56}},"generated_from_span":null},"ty":{"Deduplicated":1862}},{"index":1,"name":"c","span":{"data":{"file_id":0,"beg":{"line":125,"col":25},"end":{"line":125,"col":26}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":125,"col":34},"end":{"line":125,"col":35}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":4},"end":{"line":126,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[1879,{"Adt":{"id":{"Adt":11},"generics":{"regions":[{"Body":1}],"types":[],"const_generics":[],"trait_refs":[]}}}]}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"ty":{"HashConsedValue":[643,{"Ref":[{"Body":3},{"Deduplicated":231},"Shared"]}]}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":126,"col":4},"end":{"line":126,"col":5}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":4},"end":{"line":126,"col":5}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":235}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":235}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":643}},{"Ref":{"place":{"kind":{"Local":2},"ty":{"Deduplicated":231}},"kind":"Shared","ptr_metadata":{"Const":{"kind":{"Adt":[null,[]]},"ty":{"Deduplicated":245}}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":1879}},{"Aggregate":[{"Adt":[{"id":{"Adt":11},"generics":{"regions":[{"Body":4}],"types":[],"const_generics":[],"trait_refs":[]}},null,null]},[{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":643}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":12},"end":{"line":126,"col":13}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":126,"col":4},"end":{"line":126,"col":20}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":23}},"generics":{"regions":[],"types":[{"Deduplicated":231},{"HashConsedValue":[6223,{"Adt":{"id":{"Adt":11},"generics":{"regions":[{"Body":5}],"types":[],"const_generics":[],"trait_refs":[]}}}]}],"const_generics":[],"trait_refs":[{"Deduplicated":356},{"HashConsedValue":[7147,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[7146,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":6223}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6223}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7148,{"kind":{"TraitImpl":{"id":9,"generics":{"regions":[{"Body":5}],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":6223},{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7149,{"kind":{"TraitImpl":{"id":10,"generics":{"regions":[{"Body":5}],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":6223}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":235}}},{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":1879}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":1862}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":125,"col":0},"end":{"line":127,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":126,"col":19},"end":{"line":126,"col":20}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":19},"end":{"line":126,"col":20}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":127,"col":1},"end":{"line":127,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":9,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_some",0]}],"span":{"data":{"file_id":0,"beg":{"line":133,"col":0},"end":{"line":135,"col":1}},"generated_from_span":null},"source_text":"pub fn bool_then_some(c: bool, x: i64) -> Option {\n c.then_some(x + 1)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":235},{"Deduplicated":231}],"output":{"Deduplicated":1862}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":133,"col":0},"end":{"line":135,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":133,"col":42},"end":{"line":133,"col":53}},"generated_from_span":null},"ty":{"Deduplicated":1862}},{"index":1,"name":"c","span":{"data":{"file_id":0,"beg":{"line":133,"col":22},"end":{"line":133,"col":23}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":133,"col":31},"end":{"line":133,"col":32}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":134,"col":4},"end":{"line":134,"col":5}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":17}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":134,"col":4},"end":{"line":134,"col":5}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":4},"end":{"line":134,"col":5}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":4},"end":{"line":134,"col":5}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":235}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":235}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":21}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":17}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":5},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":21}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":6},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":231}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":133,"col":0},"end":{"line":135,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":134,"col":16},"end":{"line":134,"col":21}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":6},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":20},"end":{"line":134,"col":21}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":134,"col":4},"end":{"line":134,"col":22}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":24}},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356},{"HashConsedValue":[7151,{"kind":{"BuiltinOrAuto":{"builtin_data":"NoopDestruct","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"args":[{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":235}}},{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":231}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":1862}}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":134,"col":21},"end":{"line":134,"col":22}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":134,"col":21},"end":{"line":134,"col":22}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":135,"col":1},"end":{"line":135,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":10,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["option_source",0]}],"span":{"data":{"file_id":0,"beg":{"line":142,"col":0},"end":{"line":144,"col":1}},"generated_from_span":null},"source_text":"fn option_source(keep: bool, value: i64) -> Option {\n if keep { Some(value) } else { None }\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":235},{"Deduplicated":231}],"output":{"Deduplicated":1862}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":142,"col":0},"end":{"line":144,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":142,"col":44},"end":{"line":142,"col":55}},"generated_from_span":null},"ty":{"Deduplicated":1862}},{"index":1,"name":"keep","span":{"data":{"file_id":0,"beg":{"line":142,"col":17},"end":{"line":142,"col":21}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":2,"name":"value","span":{"data":{"file_id":0,"beg":{"line":142,"col":29},"end":{"line":142,"col":34}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":143,"col":7},"end":{"line":143,"col":11}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":143,"col":19},"end":{"line":143,"col":24}},"generated_from_span":null},"ty":{"Deduplicated":231}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":143,"col":7},"end":{"line":143,"col":11}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":143,"col":7},"end":{"line":143,"col":11}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":235}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":235}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":143,"col":7},"end":{"line":143,"col":11}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":235}}},"targets":{"If":[1,2]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":143,"col":19},"end":{"line":143,"col":24}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":143,"col":19},"end":{"line":143,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":143,"col":14},"end":{"line":143,"col":25}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":1862}},{"Aggregate":[{"Adt":[{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}},1,null]},[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":231}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":143,"col":24},"end":{"line":143,"col":25}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":143,"col":4},"end":{"line":143,"col":41}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":143,"col":35},"end":{"line":143,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":1862}},{"Aggregate":[{"Adt":[{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}},0,null]},[]]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":143,"col":4},"end":{"line":143,"col":41}},"generated_from_span":null},"kind":{"Goto":{"target":3}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":143,"col":40},"end":{"line":143,"col":41}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":144,"col":1},"end":{"line":144,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":11,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["option_question_mark",0]}],"span":{"data":{"file_id":0,"beg":{"line":147,"col":0},"end":{"line":150,"col":1}},"generated_from_span":null},"source_text":"pub fn option_question_mark(keep: bool, value: i64, addend: i64) -> Option {\n let v = option_source(keep, value)?;\n Some(v + addend)\n}","attr_info":{"attributes":[],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":235},{"Deduplicated":231},{"Deduplicated":231}],"output":{"Deduplicated":1862}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":147,"col":0},"end":{"line":150,"col":1}},"generated_from_span":null},"bound_body_regions":0,"locals":{"arg_count":3,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":147,"col":68},"end":{"line":147,"col":79}},"generated_from_span":null},"ty":{"Deduplicated":1862}},{"index":1,"name":"keep","span":{"data":{"file_id":0,"beg":{"line":147,"col":28},"end":{"line":147,"col":32}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":2,"name":"value","span":{"data":{"file_id":0,"beg":{"line":147,"col":40},"end":{"line":147,"col":45}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":"addend","span":{"data":{"file_id":0,"beg":{"line":147,"col":52},"end":{"line":147,"col":58}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":4,"name":"v","span":{"data":{"file_id":0,"beg":{"line":148,"col":8},"end":{"line":148,"col":9}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"ty":{"HashConsedValue":[1974,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[{"HashConsedValue":[1971,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":1283}],"const_generics":[],"trait_refs":[{"Deduplicated":1285}]}}}]},{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"HashConsedValue":[1973,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[1972,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":1971}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":1971}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":356}]}}}]}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":38}},"generated_from_span":null},"ty":{"Deduplicated":1862}},{"index":7,"name":null,"span":{"data":{"file_id":0,"beg":{"line":148,"col":26},"end":{"line":148,"col":30}},"generated_from_span":null},"ty":{"Deduplicated":235}},{"index":8,"name":null,"span":{"data":{"file_id":0,"beg":{"line":148,"col":32},"end":{"line":148,"col":37}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":9,"name":null,"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":10,"name":"residual","span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":1971}},{"index":11,"name":null,"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":1971}},{"index":12,"name":"val","span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":13,"name":null,"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":14,"name":null,"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":10}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":15,"name":null,"span":{"data":{"file_id":0,"beg":{"line":149,"col":13},"end":{"line":149,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":16,"name":null,"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":148,"col":8},"end":{"line":148,"col":9}},"generated_from_span":null},"kind":{"StorageLive":9},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":8},"end":{"line":148,"col":9}},"generated_from_span":null},"kind":{"StorageLive":16},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":8},"end":{"line":148,"col":9}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":38}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":26},"end":{"line":148,"col":30}},"generated_from_span":null},"kind":{"StorageLive":7},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":26},"end":{"line":148,"col":30}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":7},"ty":{"Deduplicated":235}},{"Use":{"Copy":{"kind":{"Local":1},"ty":{"Deduplicated":235}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":32},"end":{"line":148,"col":37}},"generated_from_span":null},"kind":{"StorageLive":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":32},"end":{"line":148,"col":37}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":8},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":38}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":10}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"args":[{"Move":{"kind":{"Local":7},"ty":{"Deduplicated":235}}},{"Move":{"kind":{"Local":8},"ty":{"Deduplicated":231}}}],"dest":{"kind":{"Local":6},"ty":{"Deduplicated":1862}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":147,"col":0},"end":{"line":150,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":148,"col":37},"end":{"line":148,"col":38}},"generated_from_span":null},"kind":{"StorageDead":8},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":37},"end":{"line":148,"col":38}},"generated_from_span":null},"kind":{"StorageDead":7},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":25}},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"args":[{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":1862}}}],"dest":{"kind":{"Local":5},"ty":{"Deduplicated":1974}}},"target":3,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":9},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Local":5},"ty":{"Deduplicated":1974}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":9},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},4],[{"Scalar":{"Signed":["Isize","1"]}},5]],6]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageLive":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":12},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":1974}},{"Field":[{"Adt":[9,0]},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":12},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageDead":12},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":39},"end":{"line":148,"col":40}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"StorageLive":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":10}},"generated_from_span":null},"kind":{"StorageLive":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":10}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":14},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":4},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":13},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"StorageLive":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":13},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":15},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":16},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":14},"ty":{"Deduplicated":231}}},{"Copy":{"kind":{"Local":15},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":15},"ty":{"Deduplicated":231}}},{"Move":{"kind":{"Local":16},"ty":{"Deduplicated":231}}}]}},"target":7,"on_unwind":1}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageLive":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":10},"ty":{"Deduplicated":1971}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Local":5},"ty":{"Deduplicated":1974}},{"Field":[{"Adt":[9,1]},0]}]},"ty":{"Deduplicated":1971}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageLive":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":11},"ty":{"Deduplicated":1971}},{"Use":{"Copy":{"kind":{"Local":10},"ty":{"Deduplicated":1971}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Regular":{"kind":{"Fun":{"Regular":26}},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}}},"args":[{"Move":{"kind":{"Local":11},"ty":{"Deduplicated":1971}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":1862}}},"target":8,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":148,"col":12},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":149,"col":9},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":13},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":16},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":18},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"StorageDead":15},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":18},"end":{"line":149,"col":19}},"generated_from_span":null},"kind":{"StorageDead":14},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":4},"end":{"line":149,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":1862}},{"Aggregate":[{"Adt":[{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":231}],"const_generics":[],"trait_refs":[{"Deduplicated":356}]}},1,null]},[{"Move":{"kind":{"Local":13},"ty":{"Deduplicated":231}}}]]}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":149,"col":19},"end":{"line":149,"col":20}},"generated_from_span":null},"kind":{"StorageDead":13},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":150,"col":0},"end":{"line":150,"col":1}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":150,"col":1},"end":{"line":150,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageDead":11},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":38},"end":{"line":148,"col":39}},"generated_from_span":null},"kind":{"StorageDead":10},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":148,"col":39},"end":{"line":148,"col":40}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":150,"col":0},"end":{"line":150,"col":1}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":150,"col":1},"end":{"line":150,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":12,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch",0]}],"span":{"data":{"file_id":0,"beg":{"line":171,"col":0},"end":{"line":173,"col":1}},"generated_from_span":null},"source_text":"pub fn host_registry_dispatch(reg: &HostRegistry, x: i64) -> i64 {\n (reg.slot)(x)\n}","attr_info":{"attributes":[{"DocComment":" Call through the registered callback. `front::mir` lowers this to"},{"DocComment":" `OpKind::IndirectCall { graphs: None }` — `indirect_call` with an"},{"DocComment":" unknown PBC family, which `guess_call_kind` answers `residual` for"},{"DocComment":" (`call.py:105`/`137`, `jtransform.py:410-412`). The `__dyn_call`"},{"DocComment":" placeholder it used to reach is an unregistered synthetic path with no"},{"DocComment":" continuation."}],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[2018,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[2017,{"Adt":{"id":{"Adt":4},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]},{"Deduplicated":231}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":171,"col":0},"end":{"line":173,"col":1}},"generated_from_span":null},"bound_body_regions":2,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":171,"col":61},"end":{"line":171,"col":64}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"reg","span":{"data":{"file_id":0,"beg":{"line":171,"col":30},"end":{"line":171,"col":33}},"generated_from_span":null},"ty":{"HashConsedValue":[2021,{"Ref":[{"Body":1},{"Deduplicated":2017},"Shared"]}]}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":171,"col":50},"end":{"line":171,"col":51}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":172,"col":4},"end":{"line":172,"col":14}},"generated_from_span":null},"ty":{"Deduplicated":2011}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":172,"col":15},"end":{"line":172,"col":16}},"generated_from_span":null},"ty":{"Deduplicated":231}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":172,"col":4},"end":{"line":172,"col":14}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":172,"col":4},"end":{"line":172,"col":14}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":2011}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":2021}},"Deref"]},"ty":{"Deduplicated":2017}},{"Field":[{"Adt":[4,null]},0]}]},"ty":{"Deduplicated":2011}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":172,"col":15},"end":{"line":172,"col":16}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":172,"col":15},"end":{"line":172,"col":16}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":172,"col":4},"end":{"line":172,"col":17}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Dynamic":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":2011}}}},"args":[{"Move":{"kind":{"Local":4},"ty":{"Deduplicated":231}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":231}}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":171,"col":0},"end":{"line":173,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":172,"col":16},"end":{"line":172,"col":17}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":172,"col":16},"end":{"line":172,"col":17}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":173,"col":1},"end":{"line":173,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":13,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["host_registry_dispatch_optional",0]}],"span":{"data":{"file_id":0,"beg":{"line":177,"col":0},"end":{"line":182,"col":1}},"generated_from_span":null},"source_text":"pub fn host_registry_dispatch_optional(reg: &HostRegistry, x: i64) -> i64 {\n match reg.maybe_slot {\n Some(f) => f(x),\n None => 0,\n }\n}","attr_info":{"attributes":[{"DocComment":" The one-hop `Option` spelling of the same shape."}],"inline":"Never","rename":null,"public":true},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2018},{"Deduplicated":231}],"output":{"Deduplicated":231}},"src":"TopLevel","is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":177,"col":0},"end":{"line":182,"col":1}},"generated_from_span":null},"bound_body_regions":2,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":177,"col":70},"end":{"line":177,"col":73}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":"reg","span":{"data":{"file_id":0,"beg":{"line":177,"col":39},"end":{"line":177,"col":42}},"generated_from_span":null},"ty":{"Deduplicated":2021}},{"index":2,"name":"x","span":{"data":{"file_id":0,"beg":{"line":177,"col":59},"end":{"line":177,"col":60}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":179,"col":8},"end":{"line":179,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":411}},{"index":4,"name":"f","span":{"data":{"file_id":0,"beg":{"line":179,"col":13},"end":{"line":179,"col":14}},"generated_from_span":null},"ty":{"Deduplicated":2011}},{"index":5,"name":null,"span":{"data":{"file_id":0,"beg":{"line":179,"col":19},"end":{"line":179,"col":20}},"generated_from_span":null},"ty":{"Deduplicated":2011}},{"index":6,"name":null,"span":{"data":{"file_id":0,"beg":{"line":179,"col":21},"end":{"line":179,"col":22}},"generated_from_span":null},"ty":{"Deduplicated":231}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":178,"col":10},"end":{"line":178,"col":24}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":178,"col":10},"end":{"line":178,"col":24}},"generated_from_span":null},"kind":{"PlaceMention":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":2021}},"Deref"]},"ty":{"Deduplicated":2017}},{"Field":[{"Adt":[4,null]},1]}]},"ty":{"Deduplicated":2015}}},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":178,"col":10},"end":{"line":178,"col":24}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":411}},{"Discriminant":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":2021}},"Deref"]},"ty":{"Deduplicated":2017}},{"Field":[{"Adt":[4,null]},1]}]},"ty":{"Deduplicated":2015}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":178,"col":4},"end":{"line":178,"col":24}},"generated_from_span":null},"kind":{"Switch":{"discr":{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":411}}},"targets":{"SwitchInt":[{"Int":"Isize"},[[{"Scalar":{"Signed":["Isize","0"]}},1],[{"Scalar":{"Signed":["Isize","1"]}},2]],3]}}},"comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":180,"col":16},"end":{"line":180,"col":17}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","0"]}}},"ty":{"Deduplicated":231}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":182,"col":1},"end":{"line":182,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":179,"col":13},"end":{"line":179,"col":14}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":13},"end":{"line":179,"col":14}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":2011}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":2021}},"Deref"]},"ty":{"Deduplicated":2017}},{"Field":[{"Adt":[4,null]},1]}]},"ty":{"Deduplicated":2015}},{"Field":[{"Adt":[7,1]},0]}]},"ty":{"Deduplicated":2011}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":19},"end":{"line":179,"col":20}},"generated_from_span":null},"kind":{"StorageLive":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":19},"end":{"line":179,"col":20}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":5},"ty":{"Deduplicated":2011}},{"Use":{"Copy":{"kind":{"Local":4},"ty":{"Deduplicated":2011}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":21},"end":{"line":179,"col":22}},"generated_from_span":null},"kind":{"StorageLive":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":21},"end":{"line":179,"col":22}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":6},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Local":2},"ty":{"Deduplicated":231}}}}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":179,"col":19},"end":{"line":179,"col":23}},"generated_from_span":null},"kind":{"Call":{"call":{"func":{"Dynamic":{"Move":{"kind":{"Local":5},"ty":{"Deduplicated":2011}}}},"args":[{"Move":{"kind":{"Local":6},"ty":{"Deduplicated":231}}}],"dest":{"kind":{"Local":0},"ty":{"Deduplicated":231}}},"target":5,"on_unwind":4}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":178,"col":10},"end":{"line":178,"col":24}},"generated_from_span":null},"kind":{"Abort":"UndefinedBehavior"},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":177,"col":0},"end":{"line":182,"col":1}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":179,"col":22},"end":{"line":179,"col":23}},"generated_from_span":null},"kind":{"StorageDead":6},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":22},"end":{"line":179,"col":23}},"generated_from_span":null},"kind":{"StorageDead":5},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":179,"col":22},"end":{"line":179,"col":23}},"generated_from_span":null},"kind":{"StorageDead":4},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":182,"col":1},"end":{"line":182,"col":1}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":4,"beg":{"line":25,"col":4},"end":{"line":25,"col":37}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":4,"beg":{"line":21,"col":9},"end":{"line":21,"col":10}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[2040,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":1511},"Shared"]}]}],"output":{"HashConsedValue":[2063,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":0,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2040}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}},{"Ident":["next",0]}],"span":{"data":{"file_id":7,"beg":{"line":157,"col":12},"end":{"line":157,"col":47}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":7,"beg":{"line":153,"col":17},"end":{"line":153,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7152,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":2063},"Mut"]}]}],"output":{"HashConsedValue":[7154,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[4926,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":220},"Shared"]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7153,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[6233,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6232,{"Ref":["Erased",{"Deduplicated":188},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2048,{"Ref":[{"Var":{"Bound":[1,0]}},{"Deduplicated":188},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":1,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2063}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":2}},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":8,"beg":{"line":54,"col":4},"end":{"line":54,"col":40}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Creates a consuming iterator, that is, one that moves each value out of"},{"DocComment":" the array (from start to end)."},{"DocComment":""},{"DocComment":" The array cannot be used after calling this unless `T` implements"},{"DocComment":" `Copy`, so the whole array is copied."},{"DocComment":""},{"DocComment":" Arrays have special behavior when calling `.into_iter()` prior to the"},{"DocComment":" 2021 edition -- see the [array] Editions section for more information."},{"DocComment":""},{"DocComment":" [array]: prim@array"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":39,"col":5},"end":{"line":39,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[4931,{"Array":[{"Deduplicated":220},{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}]}]}],"output":{"HashConsedValue":[4944,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":4931}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}},{"Ident":["next",0]}],"span":{"data":{"file_id":8,"beg":{"line":239,"col":4},"end":{"line":239,"col":44}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":235,"col":5},"end":{"line":235,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7155,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":4944},"Mut"]}]}],"output":{"HashConsedValue":[3736,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":4944}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]},{"Ident":["drop_in_place",0]}],"span":{"data":{"file_id":1,"beg":{"line":1063,"col":0},"end":{"line":1063,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[7156,{"RawPtr":[{"Deduplicated":220},"Mut"]}]}],"output":{"Deduplicated":245}},"src":{"TraitDecl":{"trait_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":19,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":5,"beg":{"line":101,"col":5},"end":{"line":101,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":1511},"kind":"InherentImplBlock"}}},{"Ident":["iter",0]}],"span":{"data":{"file_id":5,"beg":{"line":1040,"col":4},"end":{"line":1040,"col":43}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns an iterator over the slice."},{"DocComment":""},{"DocComment":" The iterator yields all items from start to end."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let x = &[1, 2, 4];"},{"DocComment":" let mut iterator = x.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(iterator.next(), Some(&1));"},{"DocComment":" assert_eq!(iterator.next(), Some(&2));"},{"DocComment":" assert_eq!(iterator.next(), Some(&4));"},{"DocComment":" assert_eq!(iterator.next(), None);"},{"DocComment":" ```"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"slice_iter"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":5,"beg":{"line":101,"col":5},"end":{"line":101,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2040}],"output":{"Deduplicated":2063}},"src":"TopLevel","is_global_initializer":null,"body":"Opaque"},{"def_id":20,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":5}},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":13,"beg":{"line":322,"col":4},"end":{"line":322,"col":27}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":317,"col":5},"end":{"line":317,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":317,"col":8},"end":{"line":317,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":220}},"src":{"TraitImpl":{"impl_ref":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"HashConsedValue":[5166,{"kind":{"Clause":{"Bound":[0,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]}]}},"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":21,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":6}},{"Ident":["branch",0]}],"span":{"data":{"file_id":3,"beg":{"line":2172,"col":4},"end":{"line":2172,"col":64}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":5},"end":{"line":2162,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":8},"end":{"line":2162,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[5178,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"HashConsedValue":[2650,{"kind":{"Clause":{"Bound":[0,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"output":{"HashConsedValue":[7157,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[{"HashConsedValue":[5198,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1283},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[{"Deduplicated":1285},{"Deduplicated":2650}]}}}]},{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"HashConsedValue":[5200,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5199,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5184,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":1283},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"Deduplicated":1285},{"HashConsedValue":[3039,{"kind":{"Clause":{"Bound":[1,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2621,{"TypeVar":{"Bound":[2,1]}}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5184}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"Deduplicated":2650}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":5178}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":1},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":22,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":7}},{"Ident":["from_residual",0]}],"span":{"data":{"file_id":3,"beg":{"line":2187,"col":4},"end":{"line":2187,"col":70}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":5},"end":{"line":2182,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":8},"end":{"line":2182,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":11},"end":{"line":2182,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":14},"end":{"line":2182,"col":29}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":3001},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":5198}],"output":{"HashConsedValue":[5202,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":220},{"HashConsedValue":[3014,{"TypeVar":{"Bound":[0,2]}}]}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"HashConsedValue":[3042,{"kind":{"Clause":{"Bound":[0,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027},{"Deduplicated":3014}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"Deduplicated":2650},{"Deduplicated":3042},{"HashConsedValue":[5203,{"kind":{"Clause":{"Bound":[0,3]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":3001},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]}]}},"trait_ref":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":5202},{"Deduplicated":5198}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":23,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":235},"kind":"InherentImplBlock"}}},{"Ident":["then",0]}],"span":{"data":{"file_id":17,"beg":{"line":65,"col":4},"end":{"line":65,"col":94}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns `Some(f())` if the `bool` is [`true`](../std/keyword.true.html),"},{"DocComment":" or `None` otherwise."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" assert_eq!(false.then(|| 0), None);"},{"DocComment":" assert_eq!(true.then(|| 0), Some(0));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let mut a = 0;"},{"DocComment":""},{"DocComment":" true.then(|| { a += 1; });"},{"DocComment":" false.then(|| { a += 1; });"},{"DocComment":""},{"DocComment":" // `a` is incremented once because the closure is evaluated lazily by"},{"DocComment":" // `then`."},{"DocComment":" assert_eq!(a, 1);"},{"DocComment":" ```"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"bool_then"},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":17,"beg":{"line":65,"col":22},"end":{"line":65,"col":23}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":17,"beg":{"line":65,"col":25},"end":{"line":65,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":17,"beg":{"line":65,"col":28},"end":{"line":65,"col":49}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":2023},{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":17,"beg":{"line":65,"col":52},"end":{"line":65,"col":68}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[6958,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":2621},{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":188}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":235},{"Deduplicated":2027}],"output":{"Deduplicated":3736}},"src":"TopLevel","is_global_initializer":null,"body":"Opaque"},{"def_id":24,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["bool",0]},{"Impl":{"Ty":{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"Deduplicated":235},"kind":"InherentImplBlock"}}},{"Ident":["then_some",0]}],"span":{"data":{"file_id":17,"beg":{"line":36,"col":4},"end":{"line":36,"col":72}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns `Some(t)` if the `bool` is [`true`](../std/keyword.true.html),"},{"DocComment":" or `None` otherwise."},{"DocComment":""},{"DocComment":" Arguments passed to `then_some` are eagerly evaluated; if you are"},{"DocComment":" passing the result of a function call, it is recommended to use"},{"DocComment":" [`then`], which is lazily evaluated."},{"DocComment":""},{"DocComment":" [`then`]: bool::then"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" assert_eq!(false.then_some(0), None);"},{"DocComment":" assert_eq!(true.then_some(0), Some(0));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let mut a = 0;"},{"DocComment":" let mut function_with_side_effects = || { a += 1; };"},{"DocComment":""},{"DocComment":" true.then_some(function_with_side_effects());"},{"DocComment":" false.then_some(function_with_side_effects());"},{"DocComment":""},{"DocComment":" // `a` is incremented twice because the value passed to `then_some` is"},{"DocComment":" // evaluated eagerly."},{"DocComment":" assert_eq!(a, 2);"},{"DocComment":" ```"}],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":17,"beg":{"line":36,"col":27},"end":{"line":36,"col":28}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":17,"beg":{"line":36,"col":30},"end":{"line":36,"col":46}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":235},{"Deduplicated":220}],"output":{"Deduplicated":3736}},"src":"TopLevel","is_global_initializer":null,"body":"Opaque"},{"def_id":25,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":11}},{"Ident":["branch",0]}],"span":{"data":{"file_id":6,"beg":{"line":2765,"col":4},"end":{"line":2765,"col":64}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2755,"col":5},"end":{"line":2755,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3736}],"output":{"HashConsedValue":[7158,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[{"Deduplicated":1971},{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":1973},{"Deduplicated":223}]}}}]}},"src":{"TraitImpl":{"impl_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":3736}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":1},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":26,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":12}},{"Ident":["from_residual",0]}],"span":{"data":{"file_id":6,"beg":{"line":2779,"col":4},"end":{"line":2779,"col":67}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2777,"col":5},"end":{"line":2777,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":1971}],"output":{"Deduplicated":3736}},"src":{"TraitImpl":{"impl_ref":{"id":12,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":3736},{"Deduplicated":1971}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,{"def_id":34,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]},{"Ident":["next",0]}],"span":{"data":{"file_id":16,"beg":{"line":77,"col":4},"end":{"line":77,"col":45}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Advances the iterator and returns the next value."},{"DocComment":""},{"DocComment":" Returns [`None`] when iteration is finished. Individual iterator"},{"DocComment":" implementations may choose to resume iteration, and so calling `next()`"},{"DocComment":" again may or may not eventually start returning [`Some(Item)`] again at some"},{"DocComment":" point."},{"DocComment":""},{"DocComment":" [`Some(Item)`]: Some"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let a = [1, 2, 3];"},{"DocComment":""},{"DocComment":" let mut iter = a.into_iter();"},{"DocComment":""},{"DocComment":" // A call to next() returns the next value..."},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":""},{"DocComment":" // ... and then None once it's over."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":""},{"DocComment":" // More calls may or may not return `None`. Here, they always will."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"next"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[3354,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":220},"Mut"]}]}],"output":{"HashConsedValue":[7162,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[7159,{"TraitType":[{"HashConsedValue":[5267,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7161,{"kind":{"ParentClause":[{"Deduplicated":5267},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7160,{"TraitType":[{"HashConsedValue":[6388,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,{"def_id":256,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]},{"Impl":{"Trait":4}},{"Ident":["drop_in_place",0]}],"span":{"data":{"file_id":8,"beg":{"line":20,"col":0},"end":{"line":20,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":20,"col":20},"end":{"line":20,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[7163,{"RawPtr":[{"Deduplicated":4944},"Mut"]}]}],"output":{"Deduplicated":245}},"src":{"TraitImpl":{"impl_ref":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":4944}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":257,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":6}},{"Ident":["from_output",0]}],"span":{"data":{"file_id":3,"beg":{"line":2167,"col":4},"end":{"line":2167,"col":48}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":5},"end":{"line":2162,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":8},"end":{"line":2162,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":5178}},"src":{"TraitImpl":{"impl_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"Deduplicated":2650}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":5178}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":258,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]},{"Ident":["from",0]}],"span":{"data":{"file_id":12,"beg":{"line":592,"col":4},"end":{"line":592,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Converts to this type from the input type."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_fn"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2027}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":259,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":8}},{"Ident":["from",0]}],"span":{"data":{"file_id":12,"beg":{"line":788,"col":4},"end":{"line":788,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns the argument unchanged."}],"inline":"Always","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":12,"beg":{"line":785,"col":5},"end":{"line":785,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":220}},"src":{"TraitImpl":{"impl_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":260,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":9}},{"Ident":["call_once",0]}],"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[5218,{"Adt":{"id":{"Adt":11},"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}}}]},{"Deduplicated":245}],"output":{"Deduplicated":231}},"src":{"TraitImpl":{"impl_ref":{"id":9,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":5218},{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":false}},"is_global_initializer":null,"body":{"Unstructured":{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"bound_body_regions":1,"locals":{"arg_count":2,"locals":[{"index":0,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":13},"end":{"line":126,"col":13}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":1,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":5218}},{"index":2,"name":"tupled_args","span":{"data":{"file_id":0,"beg":{"line":0,"col":0},"end":{"line":0,"col":0}},"generated_from_span":null},"ty":{"Deduplicated":245}},{"index":3,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":15}},"generated_from_span":null},"ty":{"Deduplicated":231}},{"index":4,"name":null,"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":19}},"generated_from_span":null},"ty":{"Deduplicated":236}}]},"body":[{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":15}},"generated_from_span":null},"kind":{"StorageLive":4},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":15}},"generated_from_span":null},"kind":{"StorageLive":3},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":15}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":3},"ty":{"Deduplicated":231}},{"Use":{"Copy":{"kind":{"Projection":[{"kind":{"Projection":[{"kind":{"Local":1},"ty":{"Deduplicated":5218}},{"Field":[{"Adt":[11,null]},0]}]},"ty":{"HashConsedValue":[7164,{"Ref":[{"Body":0},{"Deduplicated":231},"Shared"]}]}},"Deref"]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":4},"ty":{"Deduplicated":236}},{"BinaryOp":["AddChecked",{"Copy":{"kind":{"Local":3},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":231}}}]}]},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"Assert":{"assert":{"cond":{"Move":{"kind":{"Projection":[{"kind":{"Local":4},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},1]}]},"ty":{"Deduplicated":235}}},"expected":false,"check_kind":{"Overflow":[{"Add":"Wrap"},{"Move":{"kind":{"Local":3},"ty":{"Deduplicated":231}}},{"Const":{"kind":{"Literal":{"Scalar":{"Signed":["I64","1"]}}},"ty":{"Deduplicated":231}}}]}},"target":2,"on_unwind":1}},"comments_before":[]}},{"statements":[],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":"UnwindResume","comments_before":[]}},{"statements":[{"span":{"data":{"file_id":0,"beg":{"line":126,"col":14},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"Assign":[{"kind":{"Local":0},"ty":{"Deduplicated":231}},{"Use":{"Move":{"kind":{"Projection":[{"kind":{"Local":4},"ty":{"Deduplicated":236}},{"Field":[{"Tuple":2},0]}]},"ty":{"Deduplicated":231}}}}]},"comments_before":[]},{"span":{"data":{"file_id":0,"beg":{"line":126,"col":18},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":{"StorageDead":3},"comments_before":[]}],"terminator":{"span":{"data":{"file_id":0,"beg":{"line":126,"col":19},"end":{"line":126,"col":19}},"generated_from_span":null},"kind":"Return","comments_before":[]}}],"comments":[]}}},{"def_id":261,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]},{"Ident":["call_once",0]}],"span":{"data":{"file_id":18,"beg":{"line":250,"col":4},"end":{"line":250,"col":70}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220},{"Deduplicated":2027}],"output":{"HashConsedValue":[7166,{"TraitType":[{"HashConsedValue":[7165,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}},"src":{"TraitDecl":{"trait_ref":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":262,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":10}},{"Ident":["drop_in_place",0]}],"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[7167,{"RawPtr":[{"Deduplicated":5218},"Mut"]}]}],"output":{"Deduplicated":245}},"src":{"TraitImpl":{"impl_ref":{"id":10,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":5218}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":false}},"is_global_initializer":null,"body":"Missing"},{"def_id":263,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":11}},{"Ident":["from_output",0]}],"span":{"data":{"file_id":6,"beg":{"line":2760,"col":4},"end":{"line":2760,"col":48}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2755,"col":5},"end":{"line":2755,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":3736}},"src":{"TraitImpl":{"impl_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}},"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":3736}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},{"def_id":264,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]},{"Ident":["into_iter",0]}],"span":{"data":{"file_id":13,"beg":{"line":312,"col":4},"end":{"line":312,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Creates an iterator from a value."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let v = [1, 2, 3];"},{"DocComment":" let mut iter = v.into_iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"into_iter"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"HashConsedValue":[7168,{"TraitType":[{"HashConsedValue":[6397,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}},"src":{"TraitDecl":{"trait_ref":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":265,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]},{"Ident":["clone",0]}],"span":{"data":{"file_id":25,"beg":{"line":236,"col":4},"end":{"line":236,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns a duplicate of the value."},{"DocComment":""},{"DocComment":" Note that what \"duplicate\" means varies by type:"},{"DocComment":" - For most types, this creates a deep, independent copy"},{"DocComment":" - For reference types like `&T`, this creates another reference to the same value"},{"DocComment":" - For smart pointers like [`Arc`] or [`Rc`], this increments the reference count"},{"DocComment":" but still points to the same underlying data"},{"DocComment":""},{"DocComment":" [`Arc`]: ../../std/sync/struct.Arc.html"},{"DocComment":" [`Rc`]: ../../std/rc/struct.Rc.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(noop_method_call)]"},{"DocComment":" let hello = \"Hello\"; // &str implements Clone"},{"DocComment":""},{"DocComment":" assert_eq!(\"Hello\", hello.clone());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Example with a reference-counted type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::sync::{Arc, Mutex};"},{"DocComment":""},{"DocComment":" let data = Arc::new(Mutex::new(vec![1, 2, 3]));"},{"DocComment":" let data_clone = data.clone(); // Creates another Arc pointing to the same Mutex"},{"DocComment":""},{"DocComment":" {"},{"DocComment":" let mut lock = data.lock().unwrap();"},{"DocComment":" lock.push(4);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Changes are visible through the clone because they share the same underlying data"},{"DocComment":" assert_eq!(*data_clone.lock().unwrap(), vec![1, 2, 3, 4]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"clone_fn"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4926}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,{"def_id":267,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]},{"Ident":["call_mut",0]}],"span":{"data":{"file_id":18,"beg":{"line":166,"col":4},"end":{"line":166,"col":74}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3354},{"Deduplicated":2027}],"output":{"HashConsedValue":[7171,{"TraitType":[{"HashConsedValue":[7170,{"kind":{"ParentClause":[{"HashConsedValue":[7169,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}},"src":{"TraitDecl":{"trait_ref":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":268,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]},{"Ident":["from_iter",0]}],"span":{"data":{"file_id":13,"beg":{"line":152,"col":4},"end":{"line":152,"col":61}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Creates a value from an iterator."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v = Vec::from_iter(five_fives);"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_iter_fn"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":10,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":152,"col":17},"end":{"line":152,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":13,"beg":{"line":152,"col":20},"end":{"line":152,"col":42}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[5865,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"HashConsedValue":[3005,{"TypeVar":{"Bound":[2,2]}}]}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":2023}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3014}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":10,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":269,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["from_output",0]}],"span":{"data":{"file_id":42,"beg":{"line":192,"col":4},"end":{"line":192,"col":49}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Constructs the type from its `Output` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method"},{"DocComment":" such that applying the `?` operator will get back the original value:"},{"DocComment":" `Try::from_output(x).branch() --> ControlFlow::Continue(x)`."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::Try;"},{"DocComment":""},{"DocComment":" assert_eq!( as Try>::from_output(3), Ok(3));"},{"DocComment":" assert_eq!( as Try>::from_output(4), Some(4));"},{"DocComment":" assert_eq!("},{"DocComment":" as Try>::from_output(5),"},{"DocComment":" std::ops::ControlFlow::Continue(5),"},{"DocComment":" );"},{"DocComment":""},{"DocComment":" # fn make_question_mark_work() -> Option<()> {"},{"DocComment":" assert_eq!(Option::from_output(4)?, 4);"},{"DocComment":" # None }"},{"DocComment":" # make_question_mark_work();"},{"DocComment":""},{"DocComment":" // This is used, for example, on the accumulator in `try_fold`:"},{"DocComment":" let r = std::iter::empty().try_fold(4, |_, ()| -> Option<_> { unreachable!() });"},{"DocComment":" assert_eq!(r, Some(4));"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_output"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[5867,{"TraitType":[{"HashConsedValue":[5866,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":270,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]},{"Ident":["branch",0]}],"span":{"data":{"file_id":42,"beg":{"line":219,"col":4},"end":{"line":219,"col":65}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used in `?` to decide whether the operator should produce a value"},{"DocComment":" (because this returned [`ControlFlow::Continue`])"},{"DocComment":" or propagate a value back to the caller"},{"DocComment":" (because this returned [`ControlFlow::Break`])."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, Try};"},{"DocComment":""},{"DocComment":" assert_eq!(Ok::<_, String>(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(Err::(3).branch(), ControlFlow::Break(Err(3)));"},{"DocComment":""},{"DocComment":" assert_eq!(Some(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(None::.branch(), ControlFlow::Break(None));"},{"DocComment":""},{"DocComment":" assert_eq!(ControlFlow::::Continue(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::Break(3).branch(),"},{"DocComment":" ControlFlow::Break(ControlFlow::Break(3)),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"branch"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"HashConsedValue":[7177,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[{"HashConsedValue":[7172,{"TraitType":[{"Deduplicated":5866},1]}]},{"Deduplicated":5867}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7174,{"kind":{"ParentClause":[{"HashConsedValue":[7173,{"kind":{"ParentClause":[{"Deduplicated":5866},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":188},{"HashConsedValue":[5870,{"TraitType":[{"HashConsedValue":[5869,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5870}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7176,{"kind":{"ParentClause":[{"Deduplicated":5866},2]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7175,{"TraitType":[{"Deduplicated":5869},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":1},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":271,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]},{"Ident":["extend",0]}],"span":{"data":{"file_id":13,"beg":{"line":416,"col":4},"end":{"line":416,"col":61}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Extends a collection with the contents of an iterator."},{"DocComment":""},{"DocComment":" As this is the only required method for this trait, the [trait-level] docs"},{"DocComment":" contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: Extend"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // You can extend a String with some chars:"},{"DocComment":" let mut message = String::from(\"abc\");"},{"DocComment":""},{"DocComment":" message.extend(['d', 'e', 'f'].iter());"},{"DocComment":""},{"DocComment":" assert_eq!(\"abcdef\", &message);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":13,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":416,"col":14},"end":{"line":416,"col":15}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":13,"beg":{"line":416,"col":17},"end":{"line":416,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5865},"type_id":0,"ty":{"Deduplicated":2023}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3354},{"Deduplicated":3014}],"output":{"Deduplicated":245}},"src":{"TraitDecl":{"trait_ref":{"id":13,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,{"def_id":275,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]},{"Ident":["default",0]}],"span":{"data":{"file_id":43,"beg":{"line":139,"col":4},"end":{"line":139,"col":25}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Returns the \"default value\" for a type."},{"DocComment":""},{"DocComment":" Default values are often some kind of initial value, identity value, or anything else that"},{"DocComment":" may make sense as a default."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Using built-in default values:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let i: i8 = Default::default();"},{"DocComment":" let (x, y): (Option, f64) = Default::default();"},{"DocComment":" let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Making your own:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" enum Kind {"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Default for Kind {"},{"DocComment":" fn default() -> Self { Kind::A }"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"default_fn"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":14,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":14,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":276,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]},{"Ident":["next_back",0]}],"span":{"data":{"file_id":44,"beg":{"line":94,"col":4},"end":{"line":94,"col":50}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Removes and returns an element from the end of the iterator."},{"DocComment":""},{"DocComment":" Returns `None` when there are no more elements."},{"DocComment":""},{"DocComment":" The [trait-level] docs contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: DoubleEndedIterator"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let numbers = vec![1, 2, 3, 4, 5, 6];"},{"DocComment":""},{"DocComment":" let mut iter = numbers.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(&1), iter.next());"},{"DocComment":" assert_eq!(Some(&6), iter.next_back());"},{"DocComment":" assert_eq!(Some(&5), iter.next_back());"},{"DocComment":" assert_eq!(Some(&2), iter.next());"},{"DocComment":" assert_eq!(Some(&3), iter.next());"},{"DocComment":" assert_eq!(Some(&4), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next_back());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Remarks"},{"DocComment":""},{"DocComment":" The elements yielded by `DoubleEndedIterator`'s methods may differ from"},{"DocComment":" the ones yielded by [`Iterator`]'s methods:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let vec = vec![(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b')];"},{"DocComment":" let uniq_by_fst_comp = || {"},{"DocComment":" let mut seen = std::collections::HashSet::new();"},{"DocComment":" vec.iter().copied().filter(move |x| seen.insert(x.0))"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" assert_eq!(uniq_by_fst_comp().last(), Some((2, 'a')));"},{"DocComment":" assert_eq!(uniq_by_fst_comp().next_back(), Some((2, 'b')));"},{"DocComment":""},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().fold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(1, 'a'), (2, 'a')]"},{"DocComment":" );"},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().rfold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(2, 'b'), (1, 'c')]"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3354}],"output":{"HashConsedValue":[7181,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[7178,{"TraitType":[{"HashConsedValue":[5877,{"kind":{"ParentClause":[{"HashConsedValue":[5876,{"kind":{"Clause":{"Bound":[0,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7180,{"kind":{"ParentClause":[{"Deduplicated":5877},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7179,{"TraitType":[{"HashConsedValue":[6410,{"kind":{"ParentClause":[{"HashConsedValue":[6409,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,{"def_id":284,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]},{"Ident":["cmp",0]}],"span":{"data":{"file_id":46,"beg":{"line":991,"col":4},"end":{"line":991,"col":44}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" This method returns an [`Ordering`] between `self` and `other`."},{"DocComment":""},{"DocComment":" By convention, `self.cmp(&other)` returns the ordering matching the expression"},{"DocComment":" `self other` if true."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" assert_eq!(5.cmp(&10), Ordering::Less);"},{"DocComment":" assert_eq!(10.cmp(&5), Ordering::Greater);"},{"DocComment":" assert_eq!(5.cmp(&5), Ordering::Equal);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"ord_cmp_method"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4926},{"HashConsedValue":[7182,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":220},"Shared"]}]}],"output":{"HashConsedValue":[3978,{"Adt":{"id":{"Adt":36},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,{"def_id":288,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]},{"Ident":["sum",0]}],"span":{"data":{"file_id":52,"beg":{"line":21,"col":4},"end":{"line":21,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by \"summing up\""},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":19,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":21,"col":11},"end":{"line":21,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":52,"beg":{"line":21,"col":14},"end":{"line":21,"col":32}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[5892,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":3005}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":2023}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3014}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":19,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":289,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]},{"Ident":["product",0]}],"span":{"data":{"file_id":52,"beg":{"line":42,"col":4},"end":{"line":42,"col":55}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by multiplying"},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"},{"index":2,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":42,"col":15},"end":{"line":42,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":52,"beg":{"line":42,"col":18},"end":{"line":42,"col":36}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5892},"type_id":0,"ty":{"Deduplicated":2023}}}]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":3014}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},{"def_id":290,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]},{"Ident":["partial_cmp",0]}],"span":{"data":{"file_id":46,"beg":{"line":1387,"col":4},"end":{"line":1387,"col":59}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" This method returns an ordering between `self` and `other` values if one exists."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&2.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Less));"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Equal));"},{"DocComment":""},{"DocComment":" let result = 2.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Greater));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" When comparison is impossible:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let result = f64::NAN.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, None);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"cmp_partialord_cmp"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4926},{"HashConsedValue":[5893,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":2027},"Shared"]}]}],"output":{"HashConsedValue":[4347,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":3978}],"const_generics":[],"trait_refs":[{"HashConsedValue":[4346,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[4345,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":3978}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3978}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"src":{"TraitDecl":{"trait_ref":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,null,null,null,null,null,null,{"def_id":299,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]},{"Ident":["eq",0]}],"span":{"data":{"file_id":46,"beg":{"line":256,"col":4},"end":{"line":256,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Tests for `self` and `other` values to be equal, and is used by `==`."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"cmp_partialeq_eq"},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":4926},{"Deduplicated":5893}],"output":{"Deduplicated":235}},"src":{"TraitDecl":{"trait_ref":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,null,{"def_id":302,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]},{"Ident":["from_residual",0]}],"span":{"data":{"file_id":42,"beg":{"line":333,"col":4},"end":{"line":333,"col":42}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Constructs the type from a compatible `Residual` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method such"},{"DocComment":" that applying the `?` operator will get back an equivalent residual:"},{"DocComment":" `FromResidual::from_residual(r).branch() --> ControlFlow::Break(r)`."},{"DocComment":" (The residual is not mandated to be *identical* when interconversion is involved.)"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, FromResidual};"},{"DocComment":""},{"DocComment":" assert_eq!(Result::::from_residual(Err(3_u8)), Err(3));"},{"DocComment":" assert_eq!(Option::::from_residual(None), None);"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::from_residual(ControlFlow::Break(5)),"},{"DocComment":" ControlFlow::Break(5),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"from_residual"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"R"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":0,"beg":{"line":1,"col":0},"end":{"line":1,"col":0}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2027}],"output":{"Deduplicated":220}},"src":{"TraitDecl":{"trait_ref":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"has_default":false}},"is_global_initializer":null,"body":"Opaque"},null,{"def_id":304,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":17}},{"Ident":["clone",0]}],"span":{"data":{"file_id":25,"beg":{"line":614,"col":20},"end":{"line":614,"col":43}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Always","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7183,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":775},"Shared"]}]}],"output":{"Deduplicated":775}},"src":{"TraitImpl":{"impl_ref":{"id":17,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},null,{"def_id":306,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":18}},{"Ident":["clone",0]}],"span":{"data":{"file_id":53,"beg":{"line":17,"col":17},"end":{"line":17,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":"Hint","rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[7184,{"Ref":[{"Var":{"Bound":[0,0]}},{"HashConsedValue":[5342,{"Adt":{"id":{"Adt":44},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}}]},"Shared"]}]}],"output":{"Deduplicated":5342}},"src":{"TraitImpl":{"impl_ref":{"id":18,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}},"trait_ref":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}},"item_id":{"Method":0},"reuses_default":true}},"is_global_initializer":null,"body":"Opaque"},null],"global_decls":[null,null,null,null,null,null],"trait_decls":[{"def_id":0,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Sized",0]}],"span":{"data":{"file_id":1,"beg":{"line":161,"col":0},"end":{"line":161,"col":26}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Types with a constant size known at compile time."},{"DocComment":""},{"DocComment":" All type parameters have an implicit bound of `Sized`. The special syntax"},{"DocComment":" `?Sized` can be used to remove this bound if it's not appropriate."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" struct Foo(T);"},{"DocComment":" struct Bar(T);"},{"DocComment":""},{"DocComment":" // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]"},{"DocComment":" struct BarUse(Bar<[i32]>); // OK"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The one exception is the implicit `Self` type of a trait. A trait does not"},{"DocComment":" have an implicit `Sized` bound as this is incompatible with [trait object]s"},{"DocComment":" where, by definition, the trait needs to work with all possible implementors,"},{"DocComment":" and thus could be any size."},{"DocComment":""},{"DocComment":" Although Rust will let you bind `Sized` to a trait, you won't"},{"DocComment":" be able to use it to form a trait object later:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(unused_variables)]"},{"DocComment":" trait Foo { }"},{"DocComment":" trait Bar: Sized { }"},{"DocComment":""},{"DocComment":" struct Impl;"},{"DocComment":" impl Foo for Impl { }"},{"DocComment":" impl Bar for Impl { }"},{"DocComment":""},{"DocComment":" let x: &dyn Foo = &Impl; // OK"},{"DocComment":" // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot be made into an object"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [trait object]: ../../book/ch17-02-trait-objects.html"},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message =\n\"the size for values of type `{Self}` cannot be known at compilation time\",\nlabel = \"doesn't have a size known at compile-time\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"sized"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":1,"beg":{"line":161,"col":17},"end":{"line":161,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":1,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["MetaSized",0]}],"span":{"data":{"file_id":1,"beg":{"line":178,"col":0},"end":{"line":178,"col":33}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Types with a size that can be determined from pointer metadata."},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message = \"the size for values of type `{Self}` cannot be known\", label =\n\"doesn't have a known size\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"meta_sized"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[],"consts":[],"types":[],"methods":[],"vtable":{"id":{"Adt":12},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},{"def_id":2,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Destruct",0]}],"span":{"data":{"file_id":1,"beg":{"line":1063,"col":0},"end":{"line":1063,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A marker for types that can be dropped."},{"DocComment":""},{"DocComment":" This should be used for `[const]` bounds,"},{"DocComment":" as non-const bounds will always hold for every type."},{"Unknown":{"path":"rustc_on_unimplemented","args":"message = \"can't drop `{Self}`\", append_const_msg"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"destruct"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"drop_in_place","attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":true,"inputs":[{"HashConsedValue":[6987,{"RawPtr":[{"Deduplicated":188},"Mut"]}]}],"output":{"Deduplicated":245}},"item":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}},"kind":{"TraitMethod":[2,0]}}],"vtable":null},{"def_id":3,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["iterator",0]},{"Ident":["Iterator",0]}],"span":{"data":{"file_id":16,"beg":{"line":41,"col":0},"end":{"line":41,"col":24}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A trait for dealing with iterators."},{"DocComment":""},{"DocComment":" This is the main iterator trait. For more about the concept of iterators"},{"DocComment":" generally, please see the [module-level documentation]. In particular, you"},{"DocComment":" may want to know how to [implement `Iterator`][impl]."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":" [impl]: crate::iter#implementing-iterator"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Self = \"core::ops::range::RangeTo\", note =\n\"you might have meant to use a bounded `Range`\"),\non(Self = \"core::ops::range::RangeToInclusive\", note =\n\"you might have meant to use a bounded `RangeInclusive`\"), label =\n\"`{Self}` is not an iterator\", message = \"`{Self}` is not an iterator\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"iterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":16,"beg":{"line":41,"col":0},"end":{"line":4130,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":16,"beg":{"line":45,"col":4},"end":{"line":45,"col":14}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2166,{"TraitType":[{"HashConsedValue":[2165,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Item","attr_info":{"attributes":[{"DocComment":" The type of the elements being iterated over."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[3,0]}}],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"next","attr_info":{"attributes":[{"DocComment":" Advances the iterator and returns the next value."},{"DocComment":""},{"DocComment":" Returns [`None`] when iteration is finished. Individual iterator"},{"DocComment":" implementations may choose to resume iteration, and so calling `next()`"},{"DocComment":" again may or may not eventually start returning [`Some(Item)`] again at some"},{"DocComment":" point."},{"DocComment":""},{"DocComment":" [`Some(Item)`]: Some"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let a = [1, 2, 3];"},{"DocComment":""},{"DocComment":" let mut iter = a.into_iter();"},{"DocComment":""},{"DocComment":" // A call to next() returns the next value..."},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":""},{"DocComment":" // ... and then None once it's over."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":""},{"DocComment":" // More calls may or may not return `None`. Here, they always will."},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[2164,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":188},"Mut"]}]}],"output":{"HashConsedValue":[6989,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":2166}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6988,{"kind":{"ParentClause":[{"Deduplicated":2165},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[2144,{"TraitType":[{"HashConsedValue":[2143,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"HashConsedValue":[2057,{"TypeVar":{"Bound":[3,0]}}]}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"item":{"id":34,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2165}]}}},"kind":{"TraitMethod":[3,0]}},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"vtable":{"id":{"Adt":13},"generics":{"regions":[],"types":[{"HashConsedValue":[6991,{"TraitType":[{"HashConsedValue":[6990,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":4,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Ident":["From",0]}],"span":{"data":{"file_id":12,"beg":{"line":587,"col":0},"end":{"line":587,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used to do value-to-value conversions while consuming the input value. It is the reciprocal of"},{"DocComment":" [`Into`]."},{"DocComment":""},{"DocComment":" One should always prefer implementing `From` over [`Into`]"},{"DocComment":" because implementing `From` automatically provides one with an implementation of [`Into`]"},{"DocComment":" thanks to the blanket implementation in the standard library."},{"DocComment":""},{"DocComment":" Only implement [`Into`] when targeting a version prior to Rust 1.41 and converting to a type"},{"DocComment":" outside the current crate."},{"DocComment":" `From` was not able to do these types of conversions in earlier versions because of Rust's"},{"DocComment":" orphaning rules."},{"DocComment":" See [`Into`] for more details."},{"DocComment":""},{"DocComment":" Prefer using [`Into`] over [`From`] when specifying trait bounds on a generic function"},{"DocComment":" to ensure that types that only implement [`Into`] can be used as well."},{"DocComment":""},{"DocComment":" The `From` trait is also very useful when performing error handling. When constructing a function"},{"DocComment":" that is capable of failing, the return type will generally be of the form `Result`."},{"DocComment":" `From` simplifies error handling by allowing a function to return a single error type"},{"DocComment":" that encapsulates multiple error types. See the \"Examples\" section and [the book][book] for more"},{"DocComment":" details."},{"DocComment":""},{"DocComment":" **Note: This trait must not fail**. The `From` trait is intended for perfect conversions."},{"DocComment":" If the conversion can fail or is not perfect, use [`TryFrom`]."},{"DocComment":""},{"DocComment":" # Generic Implementations"},{"DocComment":""},{"DocComment":" - `From for U` implies [`Into`]` for T`"},{"DocComment":" - `From` is reflexive, which means that `From for T` is implemented"},{"DocComment":""},{"DocComment":" # When to implement `From`"},{"DocComment":""},{"DocComment":" While there's no technical restrictions on which conversions can be done using"},{"DocComment":" a `From` implementation, the general expectation is that the conversions"},{"DocComment":" should typically be restricted as follows:"},{"DocComment":""},{"DocComment":" * The conversion is *infallible*: if the conversion can fail, use [`TryFrom`]"},{"DocComment":" instead; don't provide a `From` impl that panics."},{"DocComment":""},{"DocComment":" * The conversion is *lossless*: semantically, it should not lose or discard"},{"DocComment":" information. For example, `i32: From` exists, where the original"},{"DocComment":" value can be recovered using `u16: TryFrom`. And `String: From<&str>`"},{"DocComment":" exists, where you can get something equivalent to the original value via"},{"DocComment":" `Deref`. But `From` cannot be used to convert from `u32` to `u16`, since"},{"DocComment":" that cannot succeed in a lossless way. (There's some wiggle room here for"},{"DocComment":" information not considered semantically relevant. For example,"},{"DocComment":" `Box<[T]>: From>` exists even though it might not preserve capacity,"},{"DocComment":" like how two vectors can be equal despite differing capacities.)"},{"DocComment":""},{"DocComment":" * The conversion is *value-preserving*: the conceptual kind and meaning of"},{"DocComment":" the resulting value is the same, even though the Rust type and technical"},{"DocComment":" representation might be different. For example `-1_i8 as u8` is *lossless*,"},{"DocComment":" since `as` casting back can recover the original value, but that conversion"},{"DocComment":" is *not* available via `From` because `-1` and `255` are different conceptual"},{"DocComment":" values (despite being identical bit patterns technically). But"},{"DocComment":" `f32: From` *is* available because `1_i16` and `1.0_f32` are conceptually"},{"DocComment":" the same real number (despite having very different bit patterns technically)."},{"DocComment":" `String: From` is available because they're both *text*, but"},{"DocComment":" `String: From` is *not* available, since `1` (a number) and `\"1\"`"},{"DocComment":" (text) are too different. (Converting values to text is instead covered"},{"DocComment":" by the [`Display`](crate::fmt::Display) trait.)"},{"DocComment":""},{"DocComment":" * The conversion is *obvious*: it's the only reasonable conversion between"},{"DocComment":" the two types. Otherwise it's better to have it be a named method or"},{"DocComment":" constructor, like how [`str::as_bytes`] is a method and how integers have"},{"DocComment":" methods like [`u32::from_ne_bytes`], [`u32::from_le_bytes`], and"},{"DocComment":" [`u32::from_be_bytes`], none of which are `From` implementations. Whereas"},{"DocComment":" there's only one reasonable way to wrap an [`Ipv6Addr`](crate::net::Ipv6Addr)"},{"DocComment":" into an [`IpAddr`](crate::net::IpAddr), thus `IpAddr: From` exists."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" [`String`] implements `From<&str>`:"},{"DocComment":""},{"DocComment":" An explicit conversion from a `&str` to a String is done as follows:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let string = \"hello\".to_string();"},{"DocComment":" let other_string = String::from(\"hello\");"},{"DocComment":""},{"DocComment":" assert_eq!(string, other_string);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" While performing error handling it is often useful to implement `From` for your own error type."},{"DocComment":" By converting underlying error types to our own custom error type that encapsulates the"},{"DocComment":" underlying error type, we can return a single error type without losing information on the"},{"DocComment":" underlying cause. The '?' operator automatically converts the underlying error type to our"},{"DocComment":" custom error type with `From::from`."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::fs;"},{"DocComment":" use std::io;"},{"DocComment":" use std::num;"},{"DocComment":""},{"DocComment":" enum CliError {"},{"DocComment":" IoError(io::Error),"},{"DocComment":" ParseError(num::ParseIntError),"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl From for CliError {"},{"DocComment":" fn from(error: io::Error) -> Self {"},{"DocComment":" CliError::IoError(error)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl From for CliError {"},{"DocComment":" fn from(error: num::ParseIntError) -> Self {"},{"DocComment":" CliError::ParseError(error)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn open_and_parse_file(file_name: &str) -> Result {"},{"DocComment":" let mut contents = fs::read_to_string(&file_name)?;"},{"DocComment":" let num: i32 = contents.trim().parse()?;"},{"DocComment":" Ok(num)"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`String`]: ../../std/string/struct.String.html"},{"DocComment":" [`from`]: From::from"},{"DocComment":" [book]: ../../book/ch09-00-error-handling.html"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(all(Self = \"&str\", T = \"alloc::string::String\"), note =\n\"to coerce a `{T}` into a `{Self}`, use `&*` as a prefix\",)"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"From"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"T"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":12,"beg":{"line":587,"col":25},"end":{"line":587,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":12,"beg":{"line":587,"col":21},"end":{"line":587,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"from","attr_info":{"attributes":[{"DocComment":" Converts to this type from the input type."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2023}],"output":{"Deduplicated":188}},"item":{"id":258,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6422,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[4,0]}}],"vtable":null},{"def_id":5,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnOnce",0]}],"span":{"data":{"file_id":18,"beg":{"line":242,"col":0},"end":{"line":242,"col":35}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The version of the call operator that takes a by-value receiver."},{"DocComment":""},{"DocComment":" Instances of `FnOnce` can be called, but might not be callable multiple"},{"DocComment":" times. Because of this, if the only thing known about a type is that it"},{"DocComment":" implements `FnOnce`, it can only be called once."},{"DocComment":""},{"DocComment":" `FnOnce` is implemented automatically by closures that might consume captured"},{"DocComment":" variables, as well as all types that implement [`FnMut`], e.g., (safe)"},{"DocComment":" [function pointers] (since `FnOnce` is a supertrait of [`FnMut`])."},{"DocComment":""},{"DocComment":" Since both [`Fn`] and [`FnMut`] are subtraits of `FnOnce`, any instance of"},{"DocComment":" [`Fn`] or [`FnMut`] can be used where a `FnOnce` is expected."},{"DocComment":""},{"DocComment":" Use `FnOnce` as a bound when you want to accept a parameter of function-like"},{"DocComment":" type and only need to call it once. If you need to call the parameter"},{"DocComment":" repeatedly, use [`FnMut`] as a bound; if you also need it to not mutate"},{"DocComment":" state, use [`Fn`]."},{"DocComment":""},{"DocComment":" See the [chapter on closures in *The Rust Programming Language*][book] for"},{"DocComment":" some more information on this topic."},{"DocComment":""},{"DocComment":" Also of note is the special syntax for `Fn` traits (e.g."},{"DocComment":" `Fn(usize, bool) -> usize`). Those interested in the technical details of"},{"DocComment":" this can refer to [the relevant section in the *Rustonomicon*][nomicon]."},{"DocComment":""},{"DocComment":" [book]: ../../book/ch13-01-closures.html"},{"DocComment":" [function pointers]: fn"},{"DocComment":" [nomicon]: ../../nomicon/hrtb.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ## Using a `FnOnce` parameter"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" fn consume_with_relish(func: F)"},{"DocComment":" where F: FnOnce() -> String"},{"DocComment":" {"},{"DocComment":" // `func` consumes its captured variables, so it cannot be run more"},{"DocComment":" // than once."},{"DocComment":" println!(\"Consumed: {}\", func());"},{"DocComment":""},{"DocComment":" println!(\"Delicious!\");"},{"DocComment":""},{"DocComment":" // Attempting to invoke `func()` again will throw a `use of moved"},{"DocComment":" // value` error for `func`."},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let x = String::from(\"x\");"},{"DocComment":" let consume_and_return_x = move || x;"},{"DocComment":" consume_with_relish(consume_and_return_x);"},{"DocComment":""},{"DocComment":" // `consume_and_return_x` can no longer be invoked at this point"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Args = \"()\", note =\n\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}`\"),\non(Self = \"unsafe fn\", note =\n\"unsafe function cannot be called generically without an unsafe block\", label\n= \"call the function in a closure: `|| unsafe {{ /* code */ }}`\"), message =\n\"expected a `{Trait}` closure, found `{Self}`\", label =\n\"expected an `{Trait}` closure, found `{Self}`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"fn_once"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":18,"beg":{"line":242,"col":0},"end":{"line":251,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":18,"beg":{"line":242,"col":23},"end":{"line":242,"col":27}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":18,"beg":{"line":242,"col":29},"end":{"line":242,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":18,"beg":{"line":246,"col":4},"end":{"line":246,"col":16}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5918,{"TraitType":[{"HashConsedValue":[5233,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Output","attr_info":{"attributes":[{"DocComment":" The returned type after the call operator is used."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[5,0]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"call_once","attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":188},{"Deduplicated":2023}],"output":{"Deduplicated":5918}},"item":{"id":261,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"Deduplicated":5233}]}}},"kind":{"TraitMethod":[5,0]}}],"vtable":{"id":{"Adt":42},"generics":{"regions":[],"types":[{"Deduplicated":2027},{"HashConsedValue":[6993,{"TraitType":[{"HashConsedValue":[6992,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":6,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["IntoIterator",0]}],"span":{"data":{"file_id":13,"beg":{"line":283,"col":0},"end":{"line":283,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Conversion into an [`Iterator`]."},{"DocComment":""},{"DocComment":" By implementing `IntoIterator` for a type, you define how it will be"},{"DocComment":" converted to an iterator. This is common for types which describe a"},{"DocComment":" collection of some kind."},{"DocComment":""},{"DocComment":" One benefit of implementing `IntoIterator` is that your type will [work"},{"DocComment":" with Rust's `for` loop syntax](crate::iter#for-loops-and-intoiterator)."},{"DocComment":""},{"DocComment":" See also: [`FromIterator`]."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let v = [1, 2, 3];"},{"DocComment":" let mut iter = v.into_iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"},{"DocComment":" Implementing `IntoIterator` for your type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // A sample collection, that's just a wrapper over Vec"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct MyCollection(Vec);"},{"DocComment":""},{"DocComment":" // Let's give it some methods so we can create one and add things"},{"DocComment":" // to it."},{"DocComment":" impl MyCollection {"},{"DocComment":" fn new() -> MyCollection {"},{"DocComment":" MyCollection(Vec::new())"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn add(&mut self, elem: i32) {"},{"DocComment":" self.0.push(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // and we'll implement IntoIterator"},{"DocComment":" impl IntoIterator for MyCollection {"},{"DocComment":" type Item = i32;"},{"DocComment":" type IntoIter = std::vec::IntoIter;"},{"DocComment":""},{"DocComment":" fn into_iter(self) -> Self::IntoIter {"},{"DocComment":" self.0.into_iter()"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Now we can make a new collection..."},{"DocComment":" let mut c = MyCollection::new();"},{"DocComment":""},{"DocComment":" // ... add some stuff to it ..."},{"DocComment":" c.add(0);"},{"DocComment":" c.add(1);"},{"DocComment":" c.add(2);"},{"DocComment":""},{"DocComment":" // ... and then turn it into an Iterator:"},{"DocComment":" for (i, n) in c.into_iter().enumerate() {"},{"DocComment":" assert_eq!(i as i32, n);"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" It is common to use `IntoIterator` as a trait bound. This allows"},{"DocComment":" the input collection type to change, so long as it is still an"},{"DocComment":" iterator. Additional bounds can be specified by restricting on"},{"DocComment":" `Item`:"},{"DocComment":""},{"DocComment":" ```rust"},{"DocComment":" fn collect_as_strings(collection: T) -> Vec"},{"DocComment":" where"},{"DocComment":" T: IntoIterator,"},{"DocComment":" T::Item: std::fmt::Debug,"},{"DocComment":" {"},{"DocComment":" collection"},{"DocComment":" .into_iter()"},{"DocComment":" .map(|item| format!(\"{item:?}\"))"},{"DocComment":" .collect()"},{"DocComment":" }"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Self = \"core::ops::range::RangeTo\", label =\n\"if you meant to iterate until a value, add a starting value\", note =\n\"`..end` is a `RangeTo`, which cannot be iterated on; you might have meant to have a \\\n bounded `Range`: `0..end`\"),\non(Self = \"core::ops::range::RangeToInclusive\", label =\n\"if you meant to iterate until a value (including it), add a starting value\",\nnote =\n\"`..=end` is a `RangeToInclusive`, which cannot be iterated on; you might have meant \\\n to have a bounded `RangeInclusive`: `0..=end`\"),\non(Self = \"[]\", label =\n\"`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`\"),\non(Self = \"&[]\", label =\n\"`{Self}` is not an iterator; try calling `.iter()`\"),\non(Self = \"alloc::vec::Vec\", label =\n\"`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`\"),\non(Self = \"&str\", label =\n\"`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`\"),\non(Self = \"alloc::string::String\", label =\n\"`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`\"),\non(Self = \"{integral}\", note =\n\"if you want to iterate between `start` until a value `end`, use the exclusive range \\\n syntax `start..end` or the inclusive range syntax `start..=end`\"),\non(Self = \"{float}\", note =\n\"if you want to iterate between `start` until a value `end`, use the exclusive range \\\n syntax `start..end` or the inclusive range syntax `start..=end`\"),\nlabel = \"`{Self}` is not an iterator\", message = \"`{Self}` is not an iterator\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"IntoIterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[6834,{"kind":{"ParentClause":[{"HashConsedValue":[5265,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},3]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"HashConsedValue":[6426,{"TraitType":[{"HashConsedValue":[6425,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2057}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"HashConsedValue":[6270,{"TraitType":[{"Deduplicated":5265},0]}]}}}]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":283,"col":0},"end":{"line":313,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":287,"col":4},"end":{"line":287,"col":14}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6270}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":13,"beg":{"line":291,"col":4},"end":{"line":291,"col":47}},"generated_from_span":null},"origin":{"TraitItem":1},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5921,{"TraitType":[{"Deduplicated":5265},1]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":13,"beg":{"line":291,"col":19},"end":{"line":291,"col":46}},"generated_from_span":null},"origin":{"TraitItem":1},"trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":5921}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Item","attr_info":{"attributes":[{"DocComment":" The type of the elements being iterated over."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"IntoIter","attr_info":{"attributes":[{"DocComment":" Which kind of iterator are we turning this into?"}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"into_iter","attr_info":{"attributes":[{"DocComment":" Creates an iterator from a value."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let v = [1, 2, 3];"},{"DocComment":" let mut iter = v.into_iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(1), iter.next());"},{"DocComment":" assert_eq!(Some(2), iter.next());"},{"DocComment":" assert_eq!(Some(3), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":188}],"output":{"Deduplicated":5921}},"item":{"id":264,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":5265}]}}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":{"Adt":43},"generics":{"regions":[],"types":[{"HashConsedValue":[6994,{"TraitType":[{"HashConsedValue":[5245,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]},{"HashConsedValue":[6995,{"TraitType":[{"Deduplicated":5245},1]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":7,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["ZeroablePrimitive",0]}],"span":{"data":{"file_id":19,"beg":{"line":33,"col":0},"end":{"line":33,"col":66}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A marker trait for primitive types which can be zero."},{"DocComment":""},{"DocComment":" This is an implementation detail for [NonZero]\\ which may disappear or be replaced at any time."},{"DocComment":""},{"DocComment":" # Safety"},{"DocComment":""},{"DocComment":" Types implementing this trait must be primitives that are valid when zeroed."},{"DocComment":""},{"DocComment":" The associated `Self::NonZeroInner` type must have the same size+align as `Self`,"},{"DocComment":" but with a niche and bit validity making it so the following `transmutes` are sound:"},{"DocComment":""},{"DocComment":" - `Self::NonZeroInner` to `Option`"},{"DocComment":" - `Option` to `Self`"},{"DocComment":""},{"DocComment":" (And, consequently, `Self::NonZeroInner` to `Self`.)"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":19,"beg":{"line":33,"col":36},"end":{"line":33,"col":41}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":19,"beg":{"line":33,"col":44},"end":{"line":33,"col":48}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":19,"beg":{"line":33,"col":51},"end":{"line":33,"col":66}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":19,"beg":{"line":35,"col":23},"end":{"line":35,"col":28}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6274,{"TraitType":[{"HashConsedValue":[6273,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":4,"span":{"data":{"file_id":19,"beg":{"line":35,"col":31},"end":{"line":35,"col":35}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":6274}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"NonZeroInner","attr_info":{"attributes":[{"DocComment":" A type like `Self` but with a niche that includes zero."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[7,0]}}],"methods":[],"vtable":null},{"def_id":8,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["Clone",0]}],"span":{"data":{"file_id":25,"beg":{"line":194,"col":0},"end":{"line":194,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A common trait that allows explicit creation of a duplicate value."},{"DocComment":""},{"DocComment":" Calling [`clone`] always produces a new value."},{"DocComment":" However, for types that are references to other data (such as smart pointers or references),"},{"DocComment":" the new value may still point to the same underlying data, rather than duplicating it."},{"DocComment":" See [`Clone::clone`] for more details."},{"DocComment":""},{"DocComment":" This distinction is especially important when using `#[derive(Clone)]` on structs containing"},{"DocComment":" smart pointers like `Arc>` - the cloned struct will share mutable state with the"},{"DocComment":" original."},{"DocComment":""},{"DocComment":" Differs from [`Copy`] in that [`Copy`] is implicit and an inexpensive bit-wise copy, while"},{"DocComment":" `Clone` is always explicit and may or may not be expensive. [`Copy`] has no methods, so you"},{"DocComment":" cannot change its behavior, but when implementing `Clone`, the `clone` method you provide"},{"DocComment":" may run arbitrary code."},{"DocComment":""},{"DocComment":" Since `Clone` is a supertrait of [`Copy`], any type that implements `Copy` must also implement"},{"DocComment":" `Clone`."},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d"},{"DocComment":" implementation of [`Clone`] calls [`clone`] on each field."},{"DocComment":""},{"DocComment":" [`clone`]: Clone::clone"},{"DocComment":""},{"DocComment":" For a generic struct, `#[derive]` implements `Clone` conditionally by adding bound `Clone` on"},{"DocComment":" generic parameters."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // `derive` implements Clone for Reading when T is Clone."},{"DocComment":" #[derive(Clone)]"},{"DocComment":" struct Reading {"},{"DocComment":" frequency: T,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## How can I implement `Clone`?"},{"DocComment":""},{"DocComment":" Types that are [`Copy`] should have a trivial implementation of `Clone`. More formally:"},{"DocComment":" if `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`."},{"DocComment":" Manual implementations should be careful to uphold this invariant; however, unsafe code"},{"DocComment":" must not rely on it to ensure memory safety."},{"DocComment":""},{"DocComment":" An example is a generic struct holding a function pointer. In this case, the"},{"DocComment":" implementation of `Clone` cannot be `derive`d, but can be implemented as:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" struct Generate(fn() -> T);"},{"DocComment":""},{"DocComment":" impl Copy for Generate {}"},{"DocComment":""},{"DocComment":" impl Clone for Generate {"},{"DocComment":" fn clone(&self) -> Self {"},{"DocComment":" *self"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" If we `derive`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct Generate(fn() -> T);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" the auto-derived implementations will have unnecessary `T: Copy` and `T: Clone` bounds:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # struct Generate(fn() -> T);"},{"DocComment":""},{"DocComment":" // Automatically derived"},{"DocComment":" impl Copy for Generate { }"},{"DocComment":""},{"DocComment":" // Automatically derived"},{"DocComment":" impl Clone for Generate {"},{"DocComment":" fn clone(&self) -> Generate {"},{"DocComment":" Generate(Clone::clone(&self.0))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The bounds are unnecessary because clearly the function itself should be"},{"DocComment":" copy- and cloneable even if its return type is not:"},{"DocComment":""},{"DocComment":" ```compile_fail,E0599"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct Generate(fn() -> T);"},{"DocComment":""},{"DocComment":" struct NotCloneable;"},{"DocComment":""},{"DocComment":" fn generate_not_cloneable() -> NotCloneable {"},{"DocComment":" NotCloneable"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" Generate(generate_not_cloneable).clone(); // error: trait bounds were not satisfied"},{"DocComment":" // Note: With the manual implementations the above line will compile."},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## `Clone` and `PartialEq`/`Eq`"},{"DocComment":" `Clone` is intended for the duplication of objects. Consequently, when implementing"},{"DocComment":" both `Clone` and [`PartialEq`], the following property is expected to hold:"},{"DocComment":" ```text"},{"DocComment":" x == x -> x.clone() == x"},{"DocComment":" ```"},{"DocComment":" In other words, if an object compares equal to itself,"},{"DocComment":" its clone must also compare equal to the original."},{"DocComment":""},{"DocComment":" For types that also implement [`Eq`] – for which `x == x` always holds –"},{"DocComment":" this implies that `x.clone() == x` must always be true."},{"DocComment":" Standard library collections such as"},{"DocComment":" [`HashMap`], [`HashSet`], [`BTreeMap`], [`BTreeSet`] and [`BinaryHeap`]"},{"DocComment":" rely on their keys respecting this property for correct behavior."},{"DocComment":" Furthermore, these collections require that cloning a key preserves the outcome of the"},{"DocComment":" [`Hash`] and [`Ord`] methods. Thankfully, this follows automatically from `x.clone() == x`"},{"DocComment":" if `Hash` and `Ord` are correctly implemented according to their own requirements."},{"DocComment":""},{"DocComment":" When deriving both `Clone` and [`PartialEq`] using `#[derive(Clone, PartialEq)]`"},{"DocComment":" or when additionally deriving [`Eq`] using `#[derive(Clone, PartialEq, Eq)]`,"},{"DocComment":" then this property is automatically upheld – provided that it is satisfied by"},{"DocComment":" the underlying types."},{"DocComment":""},{"DocComment":" Violating this property is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on this property"},{"DocComment":" being satisfied."},{"DocComment":""},{"DocComment":" ## Additional implementors"},{"DocComment":""},{"DocComment":" In addition to the [implementors listed below][impls],"},{"DocComment":" the following types also implement `Clone`:"},{"DocComment":""},{"DocComment":" * Function item types (i.e., the distinct types defined for each function)"},{"DocComment":" * Function pointer types (e.g., `fn() -> i32`)"},{"DocComment":" * Closure types, if they capture no value from the environment"},{"DocComment":" or if all such captured values implement `Clone` themselves."},{"DocComment":" Note that variables captured by shared reference always implement `Clone`"},{"DocComment":" (even if the referent doesn't),"},{"DocComment":" while variables captured by mutable reference never implement `Clone`."},{"DocComment":""},{"DocComment":" [`HashMap`]: ../../std/collections/struct.HashMap.html"},{"DocComment":" [`HashSet`]: ../../std/collections/struct.HashSet.html"},{"DocComment":" [`BTreeMap`]: ../../std/collections/struct.BTreeMap.html"},{"DocComment":" [`BTreeSet`]: ../../std/collections/struct.BTreeSet.html"},{"DocComment":" [`BinaryHeap`]: ../../std/collections/struct.BinaryHeap.html"},{"DocComment":" [impls]: #implementors"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"clone"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":25,"beg":{"line":194,"col":23},"end":{"line":194,"col":28}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"clone","attr_info":{"attributes":[{"DocComment":" Returns a duplicate of the value."},{"DocComment":""},{"DocComment":" Note that what \"duplicate\" means varies by type:"},{"DocComment":" - For most types, this creates a deep, independent copy"},{"DocComment":" - For reference types like `&T`, this creates another reference to the same value"},{"DocComment":" - For smart pointers like [`Arc`] or [`Rc`], this increments the reference count"},{"DocComment":" but still points to the same underlying data"},{"DocComment":""},{"DocComment":" [`Arc`]: ../../std/sync/struct.Arc.html"},{"DocComment":" [`Rc`]: ../../std/rc/struct.Rc.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(noop_method_call)]"},{"DocComment":" let hello = \"Hello\"; // &str implements Clone"},{"DocComment":""},{"DocComment":" assert_eq!(\"Hello\", hello.clone());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Example with a reference-counted type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::sync::{Arc, Mutex};"},{"DocComment":""},{"DocComment":" let data = Arc::new(Mutex::new(vec![1, 2, 3]));"},{"DocComment":" let data_clone = data.clone(); // Creates another Arc pointing to the same Mutex"},{"DocComment":""},{"DocComment":" {"},{"DocComment":" let mut lock = data.lock().unwrap();"},{"DocComment":" lock.push(4);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Changes are visible through the clone because they share the same underlying data"},{"DocComment":" assert_eq!(*data_clone.lock().unwrap(), vec![1, 2, 3, 4]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"HashConsedValue":[2229,{"Ref":[{"Var":{"Bound":[0,0]}},{"Deduplicated":188},"Shared"]}]}],"output":{"Deduplicated":188}},"item":{"id":265,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6430,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[8,0]}},null],"vtable":null},{"def_id":9,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["function",0]},{"Ident":["FnMut",0]}],"span":{"data":{"file_id":18,"beg":{"line":163,"col":0},"end":{"line":163,"col":48}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The version of the call operator that takes a mutable receiver."},{"DocComment":""},{"DocComment":" Instances of `FnMut` can be called repeatedly and may mutate state."},{"DocComment":""},{"DocComment":" `FnMut` is implemented automatically by closures which take mutable"},{"DocComment":" references to captured variables, as well as all types that implement"},{"DocComment":" [`Fn`], e.g., (safe) [function pointers] (since `FnMut` is a supertrait of"},{"DocComment":" [`Fn`]). Additionally, for any type `F` that implements `FnMut`, `&mut F`"},{"DocComment":" implements `FnMut`, too."},{"DocComment":""},{"DocComment":" Since [`FnOnce`] is a supertrait of `FnMut`, any instance of `FnMut` can be"},{"DocComment":" used where a [`FnOnce`] is expected, and since [`Fn`] is a subtrait of"},{"DocComment":" `FnMut`, any instance of [`Fn`] can be used where `FnMut` is expected."},{"DocComment":""},{"DocComment":" Use `FnMut` as a bound when you want to accept a parameter of function-like"},{"DocComment":" type and need to call it repeatedly, while allowing it to mutate state."},{"DocComment":" If you don't want the parameter to mutate state, use [`Fn`] as a"},{"DocComment":" bound; if you don't need to call it repeatedly, use [`FnOnce`]."},{"DocComment":""},{"DocComment":" See the [chapter on closures in *The Rust Programming Language*][book] for"},{"DocComment":" some more information on this topic."},{"DocComment":""},{"DocComment":" Also of note is the special syntax for `Fn` traits (e.g."},{"DocComment":" `Fn(usize, bool) -> usize`). Those interested in the technical details of"},{"DocComment":" this can refer to [the relevant section in the *Rustonomicon*][nomicon]."},{"DocComment":""},{"DocComment":" [book]: ../../book/ch13-01-closures.html"},{"DocComment":" [function pointers]: fn"},{"DocComment":" [nomicon]: ../../nomicon/hrtb.html"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ## Calling a mutably capturing closure"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let mut x = 5;"},{"DocComment":" {"},{"DocComment":" let mut square_x = || x *= x;"},{"DocComment":" square_x();"},{"DocComment":" }"},{"DocComment":" assert_eq!(x, 25);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Using a `FnMut` parameter"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" fn do_twice(mut func: F)"},{"DocComment":" where F: FnMut()"},{"DocComment":" {"},{"DocComment":" func();"},{"DocComment":" func();"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let mut x: usize = 1;"},{"DocComment":" {"},{"DocComment":" let add_two_to_x = || x += 2;"},{"DocComment":" do_twice(add_two_to_x);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert_eq!(x, 5);"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Args = \"()\", note =\n\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}`\"),\non(Self = \"unsafe fn\", note =\n\"unsafe function cannot be called generically without an unsafe block\", label\n= \"call the function in a closure: `|| unsafe {{ /* code */ }}`\"), message =\n\"expected a `{Trait}` closure, found `{Self}`\", label =\n\"expected an `{Trait}` closure, found `{Self}`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"fn_mut"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Args"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":18,"beg":{"line":163,"col":0},"end":{"line":167,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":18,"beg":{"line":163,"col":36},"end":{"line":163,"col":48}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":18,"beg":{"line":163,"col":22},"end":{"line":163,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":18,"beg":{"line":163,"col":28},"end":{"line":163,"col":33}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"call_mut","attr_info":{"attributes":[{"DocComment":" Performs the call operation."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2164},{"Deduplicated":2023}],"output":{"HashConsedValue":[6997,{"TraitType":[{"HashConsedValue":[6996,{"kind":{"ParentClause":[{"HashConsedValue":[5383,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}},"item":{"id":267,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"Deduplicated":5383}]}}},"kind":{"TraitMethod":[9,0]}}],"vtable":{"id":{"Adt":45},"generics":{"regions":[],"types":[{"Deduplicated":2027},{"HashConsedValue":[7000,{"TraitType":[{"HashConsedValue":[6999,{"kind":{"ParentClause":[{"HashConsedValue":[6998,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":9,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":10,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["FromIterator",0]}],"span":{"data":{"file_id":13,"beg":{"line":134,"col":0},"end":{"line":134,"col":32}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Conversion from an [`Iterator`]."},{"DocComment":""},{"DocComment":" By implementing `FromIterator` for a type, you define how it will be"},{"DocComment":" created from an iterator. This is common for types which describe a"},{"DocComment":" collection of some kind."},{"DocComment":""},{"DocComment":" If you want to create a collection from the contents of an iterator, the"},{"DocComment":" [`Iterator::collect()`] method is preferred. However, when you need to"},{"DocComment":" specify the container type, [`FromIterator::from_iter()`] can be more"},{"DocComment":" readable than using a turbofish (e.g. `::>()`). See the"},{"DocComment":" [`Iterator::collect()`] documentation for more examples of its use."},{"DocComment":""},{"DocComment":" See also: [`IntoIterator`]."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v = Vec::from_iter(five_fives);"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Using [`Iterator::collect()`] to implicitly use `FromIterator`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v: Vec = five_fives.collect();"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Using [`FromIterator::from_iter()`] as a more readable alternative to"},{"DocComment":" [`Iterator::collect()`]:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::collections::VecDeque;"},{"DocComment":" let first = (0..10).collect::>();"},{"DocComment":" let second = VecDeque::from_iter(0..10);"},{"DocComment":""},{"DocComment":" assert_eq!(first, second);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Implementing `FromIterator` for your type:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // A sample collection, that's just a wrapper over Vec"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct MyCollection(Vec);"},{"DocComment":""},{"DocComment":" // Let's give it some methods so we can create one and add things"},{"DocComment":" // to it."},{"DocComment":" impl MyCollection {"},{"DocComment":" fn new() -> MyCollection {"},{"DocComment":" MyCollection(Vec::new())"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn add(&mut self, elem: i32) {"},{"DocComment":" self.0.push(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // and we'll implement FromIterator"},{"DocComment":" impl FromIterator for MyCollection {"},{"DocComment":" fn from_iter>(iter: I) -> Self {"},{"DocComment":" let mut c = MyCollection::new();"},{"DocComment":""},{"DocComment":" for i in iter {"},{"DocComment":" c.add(i);"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" c"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Now we can make a new iterator..."},{"DocComment":" let iter = (0..5).into_iter();"},{"DocComment":""},{"DocComment":" // ... and make a MyCollection out of it"},{"DocComment":" let c = MyCollection::from_iter(iter);"},{"DocComment":""},{"DocComment":" assert_eq!(c.0, vec![0, 1, 2, 3, 4]);"},{"DocComment":""},{"DocComment":" // collect works too!"},{"DocComment":""},{"DocComment":" let iter = (0..5).into_iter();"},{"DocComment":" let c: MyCollection = iter.collect();"},{"DocComment":""},{"DocComment":" assert_eq!(c.0, vec![0, 1, 2, 3, 4]);"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(Self = \"&[{A}]\", message =\n\"a slice of type `{Self}` cannot be built since we need to store the elements somewhere\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(all(A = \"{integer}\", any(Self = \"&[{integral}]\",)), message =\n\"a slice of type `{Self}` cannot be built since we need to store the elements somewhere\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(Self = \"[{A}]\", message =\n\"a slice of type `{Self}` cannot be built since `{Self}` has no definite size\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(all(A = \"{integer}\", any(Self = \"[{integral}]\",)), message =\n\"a slice of type `{Self}` cannot be built since `{Self}` has no definite size\",\nlabel = \"try explicitly collecting into a `Vec<{A}>`\",),\non(Self = \"[{A}; _]\", message =\n\"an array of type `{Self}` cannot be built directly from an iterator\", label =\n\"try collecting into a `Vec<{A}>`, then using `.try_into()`\",),\non(all(A = \"{integer}\", any(Self = \"[{integral}; _]\",)), message =\n\"an array of type `{Self}` cannot be built directly from an iterator\", label =\n\"try collecting into a `Vec<{A}>`, then using `.try_into()`\",), message =\n\"a value of type `{Self}` cannot be built from an iterator \\\n over elements of type `{A}`\",\nlabel =\n\"value of type `{Self}` cannot be built from `std::iter::Iterator`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"FromIterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":134,"col":27},"end":{"line":134,"col":32}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":134,"col":23},"end":{"line":134,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":152,"col":17},"end":{"line":152,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":152,"col":20},"end":{"line":152,"col":42}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[4264,{"kind":{"Clause":{"Bound":[1,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":2621}}}]},"skip_binder":{"name":"from_iter","attr_info":{"attributes":[{"DocComment":" Creates a value from an iterator."},{"DocComment":""},{"DocComment":" See the [module-level documentation] for more."},{"DocComment":""},{"DocComment":" [module-level documentation]: crate::iter"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let five_fives = std::iter::repeat(5).take(5);"},{"DocComment":""},{"DocComment":" let v = Vec::from_iter(five_fives);"},{"DocComment":""},{"DocComment":" assert_eq!(v, vec![5, 5, 5, 5, 5]);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":188}},"item":{"id":268,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023},{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6436,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":10,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"HashConsedValue":[4265,{"kind":{"Clause":{"Bound":[0,1]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[10,0]}}],"vtable":null},{"def_id":11,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Try",0]}],"span":{"data":{"file_id":42,"beg":{"line":133,"col":0},"end":{"line":133,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" The `?` operator and `try {}` blocks."},{"DocComment":""},{"DocComment":" `try_*` methods typically involve a type implementing this trait. For"},{"DocComment":" example, the closures passed to [`Iterator::try_fold`] and"},{"DocComment":" [`Iterator::try_for_each`] must return such a type."},{"DocComment":""},{"DocComment":" `Try` types are typically those containing two or more categories of values,"},{"DocComment":" some subset of which are so commonly handled via early returns that it's"},{"DocComment":" worth providing a terse (but still visible) syntax to make that easy."},{"DocComment":""},{"DocComment":" This is most often seen for error handling with [`Result`] and [`Option`]."},{"DocComment":" The quintessential implementation of this trait is on [`ControlFlow`]."},{"DocComment":""},{"DocComment":" # Using `Try` in Generic Code"},{"DocComment":""},{"DocComment":" `Iterator::try_fold` was stabilized to call back in Rust 1.27, but"},{"DocComment":" this trait is much newer. To illustrate the various associated types and"},{"DocComment":" methods, let's implement our own version."},{"DocComment":""},{"DocComment":" As a reminder, an infallible version of a fold looks something like this:"},{"DocComment":" ```"},{"DocComment":" fn simple_fold("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> A,"},{"DocComment":" ) -> A {"},{"DocComment":" for x in iter {"},{"DocComment":" accum = f(accum, x);"},{"DocComment":" }"},{"DocComment":" accum"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" So instead of `f` returning just an `A`, we'll need it to return some other"},{"DocComment":" type that produces an `A` in the \"don't short circuit\" path. Conveniently,"},{"DocComment":" that's also the type we need to return from the function."},{"DocComment":""},{"DocComment":" Let's add a new generic parameter `R` for that type, and bound it to the"},{"DocComment":" output type that we want:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::Try;"},{"DocComment":" fn simple_try_fold_1>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" todo!()"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" If we get through the entire iterator, we need to wrap up the accumulator"},{"DocComment":" into the return type using [`Try::from_output`]:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::{ControlFlow, Try};"},{"DocComment":" fn simple_try_fold_2>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" for x in iter {"},{"DocComment":" let cf = f(accum, x).branch();"},{"DocComment":" match cf {"},{"DocComment":" ControlFlow::Continue(a) => accum = a,"},{"DocComment":" ControlFlow::Break(_) => todo!(),"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" R::from_output(accum)"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" We'll also need [`FromResidual::from_residual`] to turn the residual back"},{"DocComment":" into the original type. But because it's a supertrait of `Try`, we don't"},{"DocComment":" need to mention it in the bounds. All types which implement `Try` can be"},{"DocComment":" recreated from their corresponding residual, so we'll just call it:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::{ControlFlow, Try};"},{"DocComment":" pub fn simple_try_fold_3>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" for x in iter {"},{"DocComment":" let cf = f(accum, x).branch();"},{"DocComment":" match cf {"},{"DocComment":" ControlFlow::Continue(a) => accum = a,"},{"DocComment":" ControlFlow::Break(r) => return R::from_residual(r),"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" R::from_output(accum)"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" But this \"call `branch`, then `match` on it, and `return` if it was a"},{"DocComment":" `Break`\" is exactly what happens inside the `?` operator. So rather than"},{"DocComment":" do all this manually, we can just use `?` instead:"},{"DocComment":" ```"},{"DocComment":" # #![feature(try_trait_v2)]"},{"DocComment":" # use std::ops::Try;"},{"DocComment":" fn simple_try_fold>("},{"DocComment":" iter: impl Iterator,"},{"DocComment":" mut accum: A,"},{"DocComment":" mut f: impl FnMut(A, T) -> R,"},{"DocComment":" ) -> R {"},{"DocComment":" for x in iter {"},{"DocComment":" accum = f(accum, x)?;"},{"DocComment":" }"},{"DocComment":" R::from_output(accum)"},{"DocComment":" }"},{"DocComment":" ```"},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(all(from_desugaring = \"TryBlock\"), message =\n\"a `try` block must return `Result` or `Option` \\\n (or another type that implements `{This}`)\",\nlabel =\n\"could not wrap the final value of the block as `{Self}` doesn't implement `Try`\",),\non(all(from_desugaring = \"QuestionMark\"), message =\n\"the `?` operator can only be applied to values that implement `{This}`\",\nlabel = \"the `?` operator cannot be applied to type `{Self}`\")"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Try"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":42,"beg":{"line":133,"col":0},"end":{"line":220,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":42,"beg":{"line":133,"col":21},"end":{"line":133,"col":41}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":188},{"HashConsedValue":[5415,{"TraitType":[{"HashConsedValue":[5414,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":42,"beg":{"line":136,"col":4},"end":{"line":136,"col":16}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5428,{"TraitType":[{"Deduplicated":5414},0]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":42,"beg":{"line":160,"col":4},"end":{"line":160,"col":18}},"generated_from_span":null},"origin":{"TraitItem":1},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5415}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Output","attr_info":{"attributes":[{"DocComment":" The type of the value produced by `?` when *not* short-circuiting."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"Residual","attr_info":{"attributes":[{"DocComment":" The type of the value passed to [`FromResidual::from_residual`]"},{"DocComment":" as part of `?` when short-circuiting."},{"DocComment":""},{"DocComment":" This represents the possible values of the `Self` type which are *not*"},{"DocComment":" represented by the `Output` type."},{"DocComment":""},{"DocComment":" # Note to Implementors"},{"DocComment":""},{"DocComment":" The choice of this type is critical to interconversion."},{"DocComment":" Unlike the `Output` type, which will often be a raw generic type,"},{"DocComment":" this type is typically a newtype of some sort to \"color\" the type"},{"DocComment":" so that it's distinguishable from the residuals of other types."},{"DocComment":""},{"DocComment":" This is why `Result::Residual` is not `E`, but `Result`."},{"DocComment":" That way it's distinct from `ControlFlow::Residual`, for example,"},{"DocComment":" and thus `?` on `ControlFlow` cannot be used in a method returning `Result`."},{"DocComment":""},{"DocComment":" If you're making a generic type `Foo` that implements `Try`,"},{"DocComment":" then typically you can use `Foo` as its `Residual`"},{"DocComment":" type: that type will have a \"hole\" in the correct place, and will maintain the"},{"DocComment":" \"foo-ness\" of the residual so other types need to opt-in to interconversion."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[11,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"from_output","attr_info":{"attributes":[{"DocComment":" Constructs the type from its `Output` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method"},{"DocComment":" such that applying the `?` operator will get back the original value:"},{"DocComment":" `Try::from_output(x).branch() --> ControlFlow::Continue(x)`."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::Try;"},{"DocComment":""},{"DocComment":" assert_eq!( as Try>::from_output(3), Ok(3));"},{"DocComment":" assert_eq!( as Try>::from_output(4), Some(4));"},{"DocComment":" assert_eq!("},{"DocComment":" as Try>::from_output(5),"},{"DocComment":" std::ops::ControlFlow::Continue(5),"},{"DocComment":" );"},{"DocComment":""},{"DocComment":" # fn make_question_mark_work() -> Option<()> {"},{"DocComment":" assert_eq!(Option::from_output(4)?, 4);"},{"DocComment":" # None }"},{"DocComment":" # make_question_mark_work();"},{"DocComment":""},{"DocComment":" // This is used, for example, on the accumulator in `try_fold`:"},{"DocComment":" let r = std::iter::empty().try_fold(4, |_, ()| -> Option<_> { unreachable!() });"},{"DocComment":" assert_eq!(r, Some(4));"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":5428}],"output":{"Deduplicated":188}},"item":{"id":269,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":5414}]}}},"kind":{"TraitMethod":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"branch","attr_info":{"attributes":[{"DocComment":" Used in `?` to decide whether the operator should produce a value"},{"DocComment":" (because this returned [`ControlFlow::Continue`])"},{"DocComment":" or propagate a value back to the caller"},{"DocComment":" (because this returned [`ControlFlow::Break`])."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, Try};"},{"DocComment":""},{"DocComment":" assert_eq!(Ok::<_, String>(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(Err::(3).branch(), ControlFlow::Break(Err(3)));"},{"DocComment":""},{"DocComment":" assert_eq!(Some(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!(None::.branch(), ControlFlow::Break(None));"},{"DocComment":""},{"DocComment":" assert_eq!(ControlFlow::::Continue(3).branch(), ControlFlow::Continue(3));"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::Break(3).branch(),"},{"DocComment":" ControlFlow::Break(ControlFlow::Break(3)),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":188}],"output":{"HashConsedValue":[7005,{"Adt":{"id":{"Adt":9},"generics":{"regions":[],"types":[{"Deduplicated":5415},{"Deduplicated":5428}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7002,{"kind":{"ParentClause":[{"HashConsedValue":[7001,{"kind":{"ParentClause":[{"Deduplicated":5414},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"HashConsedValue":[5422,{"TraitType":[{"HashConsedValue":[5420,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":2057}],"const_generics":[],"trait_refs":[]}}}}]},1]}]}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5422}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7004,{"kind":{"ParentClause":[{"Deduplicated":5414},2]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[7003,{"TraitType":[{"Deduplicated":5420},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"item":{"id":270,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":5414}]}}},"kind":{"TraitMethod":[11,1]}}],"vtable":null},{"def_id":12,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["Residual",0]}],"span":{"data":{"file_id":42,"beg":{"line":364,"col":0},"end":{"line":364,"col":34}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Allows retrieving the canonical type implementing [`Try`] that has this type"},{"DocComment":" as its residual and allows it to hold an `O` as its output."},{"DocComment":""},{"DocComment":" If you think of the `Try` trait as splitting a type into its [`Try::Output`]"},{"DocComment":" and [`Try::Residual`] components, this allows putting them back together."},{"DocComment":""},{"DocComment":" For example,"},{"DocComment":" `Result: Try>`,"},{"DocComment":" and in the other direction,"},{"DocComment":" ` as Residual>::TryType = Result`."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"O"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"HashConsedValue":[6442,{"kind":{"ParentClause":[{"HashConsedValue":[6275,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":12,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},3]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"HashConsedValue":[6277,{"TraitType":[{"HashConsedValue":[5454,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":12,"generics":{"regions":[],"types":[{"Deduplicated":2057},{"HashConsedValue":[5191,{"TypeVar":{"Bound":[3,1]}}]}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]},"type_id":0,"ty":{"Deduplicated":2023}}},{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":6442},"type_id":1,"ty":{"Deduplicated":188}}}]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":42,"beg":{"line":364,"col":29},"end":{"line":364,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":42,"beg":{"line":364,"col":25},"end":{"line":364,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":42,"beg":{"line":368,"col":4},"end":{"line":368,"col":59}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[6276,{"TraitType":[{"Deduplicated":6275},0]}]}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":42,"beg":{"line":368,"col":18},"end":{"line":368,"col":58}},"generated_from_span":null},"origin":{"TraitItem":0},"trait_":{"regions":[],"skip_binder":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":6276}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"TryType","attr_info":{"attributes":[{"DocComment":" The \"return\" type of this meta-function."}],"inline":null,"rename":null,"public":false},"default":null,"implied_clauses":[]},"kind":{"TraitType":[12,0]}}],"methods":[],"vtable":null},{"def_id":13,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Ident":["Extend",0]}],"span":{"data":{"file_id":13,"beg":{"line":397,"col":0},"end":{"line":397,"col":19}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Extend a collection with the contents of an iterator."},{"DocComment":""},{"DocComment":" Iterators produce a series of values, and collections can also be thought"},{"DocComment":" of as a series of values. The `Extend` trait bridges this gap, allowing you"},{"DocComment":" to extend a collection by including the contents of that iterator. When"},{"DocComment":" extending a collection with an already existing key, that entry is updated"},{"DocComment":" or, in the case of collections that permit multiple entries with equal"},{"DocComment":" keys, that entry is inserted."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // You can extend a String with some chars:"},{"DocComment":" let mut message = String::from(\"The first three letters are: \");"},{"DocComment":""},{"DocComment":" message.extend(&['a', 'b', 'c']);"},{"DocComment":""},{"DocComment":" assert_eq!(\"abc\", &message[29..32]);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Implementing `Extend`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // A sample collection, that's just a wrapper over Vec"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct MyCollection(Vec);"},{"DocComment":""},{"DocComment":" // Let's give it some methods so we can create one and add things"},{"DocComment":" // to it."},{"DocComment":" impl MyCollection {"},{"DocComment":" fn new() -> MyCollection {"},{"DocComment":" MyCollection(Vec::new())"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn add(&mut self, elem: i32) {"},{"DocComment":" self.0.push(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // since MyCollection has a list of i32s, we implement Extend for i32"},{"DocComment":" impl Extend for MyCollection {"},{"DocComment":""},{"DocComment":" // This is a bit simpler with the concrete type signature: we can call"},{"DocComment":" // extend on anything which can be turned into an Iterator which gives"},{"DocComment":" // us i32s. Because we need i32s to put into MyCollection."},{"DocComment":" fn extend>(&mut self, iter: T) {"},{"DocComment":""},{"DocComment":" // The implementation is very straightforward: loop through the"},{"DocComment":" // iterator, and add() each element to ourselves."},{"DocComment":" for elem in iter {"},{"DocComment":" self.add(elem);"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let mut c = MyCollection::new();"},{"DocComment":""},{"DocComment":" c.add(5);"},{"DocComment":" c.add(6);"},{"DocComment":" c.add(7);"},{"DocComment":""},{"DocComment":" // let's extend our collection with three more numbers"},{"DocComment":" c.extend(vec![1, 2, 3]);"},{"DocComment":""},{"DocComment":" // we've added these elements onto the end"},{"DocComment":" assert_eq!(\"MyCollection([5, 6, 7, 1, 2, 3])\", format!(\"{c:?}\"));"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":397,"col":0},"end":{"line":451,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":397,"col":17},"end":{"line":397,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":416,"col":14},"end":{"line":416,"col":15}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":416,"col":17},"end":{"line":416,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":4264},"type_id":0,"ty":{"Deduplicated":2621}}}]},"skip_binder":{"name":"extend","attr_info":{"attributes":[{"DocComment":" Extends a collection with the contents of an iterator."},{"DocComment":""},{"DocComment":" As this is the only required method for this trait, the [trait-level] docs"},{"DocComment":" contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: Extend"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // You can extend a String with some chars:"},{"DocComment":" let mut message = String::from(\"abc\");"},{"DocComment":""},{"DocComment":" message.extend(['d', 'e', 'f'].iter());"},{"DocComment":""},{"DocComment":" assert_eq!(\"abcdef\", &message);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2164},{"Deduplicated":220}],"output":{"Deduplicated":245}},"item":{"id":271,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188},{"Deduplicated":2023},{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6443,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":13,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"Deduplicated":4265}]}}},"kind":{"TraitMethod":[13,0]}},null,null,null],"vtable":null},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["default",0]},{"Ident":["Default",0]}],"span":{"data":{"file_id":43,"beg":{"line":107,"col":0},"end":{"line":107,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A trait for giving a type a useful default value."},{"DocComment":""},{"DocComment":" Sometimes, you want to fall back to some kind of default value, and"},{"DocComment":" don't particularly care what it is. This comes up often with `struct`s"},{"DocComment":" that define a set of options:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" struct SomeOptions {"},{"DocComment":" foo: i32,"},{"DocComment":" bar: f32,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" How can we define some default values? You can use `Default`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" #[derive(Default)]"},{"DocComment":" struct SomeOptions {"},{"DocComment":" foo: i32,"},{"DocComment":" bar: f32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn main() {"},{"DocComment":" let options: SomeOptions = Default::default();"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Now, you get all of the default values. Rust implements `Default` for various primitive types."},{"DocComment":""},{"DocComment":" If you want to override a particular option, but still retain the other defaults:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" # #[derive(Default)]"},{"DocComment":" # struct SomeOptions {"},{"DocComment":" # foo: i32,"},{"DocComment":" # bar: f32,"},{"DocComment":" # }"},{"DocComment":" fn main() {"},{"DocComment":" let options = SomeOptions { foo: 42, ..Default::default() };"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]` if all of the type's fields implement"},{"DocComment":" `Default`. When `derive`d, it will use the default value for each field's type."},{"DocComment":""},{"DocComment":" ### `enum`s"},{"DocComment":""},{"DocComment":" When using `#[derive(Default)]` on an `enum`, you need to choose which unit variant will be"},{"DocComment":" default. You do this by placing the `#[default]` attribute on the variant."},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Default)]"},{"DocComment":" enum Kind {"},{"DocComment":" #[default]"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" You cannot use the `#[default]` attribute on non-unit or non-exhaustive variants."},{"DocComment":""},{"DocComment":" The `#[default]` attribute was stabilized in Rust 1.62.0."},{"DocComment":""},{"DocComment":" ## How can I implement `Default`?"},{"DocComment":""},{"DocComment":" Provide an implementation for the `default()` method that returns the value of"},{"DocComment":" your type that should be the default:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" enum Kind {"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Default for Kind {"},{"DocComment":" fn default() -> Self { Kind::A }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" #[derive(Default)]"},{"DocComment":" struct SomeOptions {"},{"DocComment":" foo: i32,"},{"DocComment":" bar: f32,"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Default"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":43,"beg":{"line":107,"col":25},"end":{"line":107,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"default","attr_info":{"attributes":[{"DocComment":" Returns the \"default value\" for a type."},{"DocComment":""},{"DocComment":" Default values are often some kind of initial value, identity value, or anything else that"},{"DocComment":" may make sense as a default."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Using built-in default values:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let i: i8 = Default::default();"},{"DocComment":" let (x, y): (Option, f64) = Default::default();"},{"DocComment":" let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Making your own:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" enum Kind {"},{"DocComment":" A,"},{"DocComment":" B,"},{"DocComment":" C,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Default for Kind {"},{"DocComment":" fn default() -> Self { Kind::A }"},{"DocComment":" }"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[],"output":{"Deduplicated":188}},"item":{"id":275,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6444,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":14,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[14,0]}}],"vtable":null},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["double_ended",0]},{"Ident":["DoubleEndedIterator",0]}],"span":{"data":{"file_id":44,"beg":{"line":41,"col":0},"end":{"line":41,"col":39}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator able to yield elements from both ends."},{"DocComment":""},{"DocComment":" Something that implements `DoubleEndedIterator` has one extra capability"},{"DocComment":" over something that implements [`Iterator`]: the ability to also take"},{"DocComment":" `Item`s from the back, as well as the front."},{"DocComment":""},{"DocComment":" It is important to note that both back and forth work on the same range,"},{"DocComment":" and do not cross: iteration is over when they meet in the middle."},{"DocComment":""},{"DocComment":" In a similar fashion to the [`Iterator`] protocol, once a"},{"DocComment":" `DoubleEndedIterator` returns [`None`] from a [`next_back()`], calling it"},{"DocComment":" again may or may not ever return [`Some`] again. [`next()`] and"},{"DocComment":" [`next_back()`] are interchangeable for this purpose."},{"DocComment":""},{"DocComment":" [`next_back()`]: DoubleEndedIterator::next_back"},{"DocComment":" [`next()`]: Iterator::next"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let numbers = vec![1, 2, 3, 4, 5, 6];"},{"DocComment":""},{"DocComment":" let mut iter = numbers.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(&1), iter.next());"},{"DocComment":" assert_eq!(Some(&6), iter.next_back());"},{"DocComment":" assert_eq!(Some(&5), iter.next_back());"},{"DocComment":" assert_eq!(Some(&2), iter.next());"},{"DocComment":" assert_eq!(Some(&3), iter.next());"},{"DocComment":" assert_eq!(Some(&4), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next_back());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"DoubleEndedIterator"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":44,"beg":{"line":41,"col":0},"end":{"line":380,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":44,"beg":{"line":41,"col":31},"end":{"line":41,"col":39}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"next_back","attr_info":{"attributes":[{"DocComment":" Removes and returns an element from the end of the iterator."},{"DocComment":""},{"DocComment":" Returns `None` when there are no more elements."},{"DocComment":""},{"DocComment":" The [trait-level] docs contain more details."},{"DocComment":""},{"DocComment":" [trait-level]: DoubleEndedIterator"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let numbers = vec![1, 2, 3, 4, 5, 6];"},{"DocComment":""},{"DocComment":" let mut iter = numbers.iter();"},{"DocComment":""},{"DocComment":" assert_eq!(Some(&1), iter.next());"},{"DocComment":" assert_eq!(Some(&6), iter.next_back());"},{"DocComment":" assert_eq!(Some(&5), iter.next_back());"},{"DocComment":" assert_eq!(Some(&2), iter.next());"},{"DocComment":" assert_eq!(Some(&3), iter.next());"},{"DocComment":" assert_eq!(Some(&4), iter.next());"},{"DocComment":" assert_eq!(None, iter.next());"},{"DocComment":" assert_eq!(None, iter.next_back());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Remarks"},{"DocComment":""},{"DocComment":" The elements yielded by `DoubleEndedIterator`'s methods may differ from"},{"DocComment":" the ones yielded by [`Iterator`]'s methods:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let vec = vec![(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b')];"},{"DocComment":" let uniq_by_fst_comp = || {"},{"DocComment":" let mut seen = std::collections::HashSet::new();"},{"DocComment":" vec.iter().copied().filter(move |x| seen.insert(x.0))"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" assert_eq!(uniq_by_fst_comp().last(), Some((2, 'a')));"},{"DocComment":" assert_eq!(uniq_by_fst_comp().next_back(), Some((2, 'b')));"},{"DocComment":""},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().fold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(1, 'a'), (2, 'a')]"},{"DocComment":" );"},{"DocComment":" assert_eq!("},{"DocComment":" uniq_by_fst_comp().rfold(vec![], |mut v, x| {v.push(x); v}),"},{"DocComment":" vec![(2, 'b'), (1, 'c')]"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2164}],"output":{"HashConsedValue":[7008,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"HashConsedValue":[7006,{"TraitType":[{"HashConsedValue":[5518,{"kind":{"ParentClause":[{"HashConsedValue":[5517,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7007,{"kind":{"ParentClause":[{"Deduplicated":5518},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"HashConsedValue":[5522,{"TraitType":[{"HashConsedValue":[5521,{"kind":{"ParentClause":[{"HashConsedValue":[5520,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":2057}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2057}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}},"item":{"id":276,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":5517}]}}},"kind":{"TraitMethod":[15,0]}},null,null,null,null,null],"vtable":{"id":{"Adt":46},"generics":{"regions":[],"types":[{"HashConsedValue":[7011,{"TraitType":[{"HashConsedValue":[7010,{"kind":{"ParentClause":[{"HashConsedValue":[7009,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":15,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["exact_size",0]},{"Ident":["ExactSizeIterator",0]}],"span":{"data":{"file_id":45,"beg":{"line":86,"col":0},"end":{"line":86,"col":37}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" An iterator that knows its exact length."},{"DocComment":""},{"DocComment":" Many [`Iterator`]s don't know how many times they will iterate, but some do."},{"DocComment":" If an iterator knows how many times it can iterate, providing access to"},{"DocComment":" that information can be useful. For example, if you want to iterate"},{"DocComment":" backwards, a good start is to know where the end is."},{"DocComment":""},{"DocComment":" When implementing an `ExactSizeIterator`, you must also implement"},{"DocComment":" [`Iterator`]. When doing so, the implementation of [`Iterator::size_hint`]"},{"DocComment":" *must* return the exact size of the iterator."},{"DocComment":""},{"DocComment":" The [`len`] method has a default implementation, so you usually shouldn't"},{"DocComment":" implement it. However, you may be able to provide a more performant"},{"DocComment":" implementation than the default, so overriding it in this case makes sense."},{"DocComment":""},{"DocComment":" Note that this trait is a safe trait and as such does *not* and *cannot*"},{"DocComment":" guarantee that the returned length is correct. This means that `unsafe`"},{"DocComment":" code **must not** rely on the correctness of [`Iterator::size_hint`]. The"},{"DocComment":" unstable and unsafe [`TrustedLen`](super::marker::TrustedLen) trait gives"},{"DocComment":" this additional guarantee."},{"DocComment":""},{"DocComment":" [`len`]: ExactSizeIterator::len"},{"DocComment":""},{"DocComment":" # When *shouldn't* an adapter be `ExactSizeIterator`?"},{"DocComment":""},{"DocComment":" If an adapter makes an iterator *longer*, then it's usually incorrect for"},{"DocComment":" that adapter to implement `ExactSizeIterator`. The inner exact-sized"},{"DocComment":" iterator might already be `usize::MAX`-long, and thus the length of the"},{"DocComment":" longer adapted iterator would no longer be exactly representable in `usize`."},{"DocComment":""},{"DocComment":" This is why [`Chain`](crate::iter::Chain) isn't `ExactSizeIterator`,"},{"DocComment":" even when `A` and `B` are both `ExactSizeIterator`."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" Basic usage:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // a finite range knows exactly how many times it will iterate"},{"DocComment":" let five = 0..5;"},{"DocComment":""},{"DocComment":" assert_eq!(5, five.len());"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" In the [module-level docs], we implemented an [`Iterator`], `Counter`."},{"DocComment":" Let's implement `ExactSizeIterator` for it as well:"},{"DocComment":""},{"DocComment":" [module-level docs]: crate::iter"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # struct Counter {"},{"DocComment":" # count: usize,"},{"DocComment":" # }"},{"DocComment":" # impl Counter {"},{"DocComment":" # fn new() -> Counter {"},{"DocComment":" # Counter { count: 0 }"},{"DocComment":" # }"},{"DocComment":" # }"},{"DocComment":" # impl Iterator for Counter {"},{"DocComment":" # type Item = usize;"},{"DocComment":" # fn next(&mut self) -> Option {"},{"DocComment":" # self.count += 1;"},{"DocComment":" # if self.count < 6 {"},{"DocComment":" # Some(self.count)"},{"DocComment":" # } else {"},{"DocComment":" # None"},{"DocComment":" # }"},{"DocComment":" # }"},{"DocComment":" # }"},{"DocComment":" impl ExactSizeIterator for Counter {"},{"DocComment":" // We can easily calculate the remaining number of iterations."},{"DocComment":" fn len(&self) -> usize {"},{"DocComment":" 5 - self.count"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // And now we can use it!"},{"DocComment":""},{"DocComment":" let mut counter = Counter::new();"},{"DocComment":""},{"DocComment":" assert_eq!(5, counter.len());"},{"DocComment":" let _ = counter.next();"},{"DocComment":" assert_eq!(4, counter.len());"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":45,"beg":{"line":86,"col":0},"end":{"line":151,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":45,"beg":{"line":86,"col":29},"end":{"line":86,"col":37}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[null,null],"vtable":{"id":{"Adt":47},"generics":{"regions":[],"types":[{"HashConsedValue":[7014,{"TraitType":[{"HashConsedValue":[7013,{"kind":{"ParentClause":[{"HashConsedValue":[7012,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":16,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},0]}]}],"const_generics":[],"trait_refs":[]}}},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Ord",0]}],"span":{"data":{"file_id":46,"beg":{"line":973,"col":0},"end":{"line":973,"col":73}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order)."},{"DocComment":""},{"DocComment":" Implementations must be consistent with the [`PartialOrd`] implementation, and ensure `max`,"},{"DocComment":" `min`, and `clamp` are consistent with `cmp`:"},{"DocComment":""},{"DocComment":" - `partial_cmp(a, b) == Some(cmp(a, b))`."},{"DocComment":" - `max(a, b) == max_by(a, b, cmp)` (ensured by the default implementation)."},{"DocComment":" - `min(a, b) == min_by(a, b, cmp)` (ensured by the default implementation)."},{"DocComment":" - For `a.clamp(min, max)`, see the [method docs](#method.clamp) (ensured by the default"},{"DocComment":" implementation)."},{"DocComment":""},{"DocComment":" Violating these requirements is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" ## Corollaries"},{"DocComment":""},{"DocComment":" From the above and the requirements of `PartialOrd`, it follows that for all `a`, `b` and `c`:"},{"DocComment":""},{"DocComment":" - exactly one of `a < b`, `a == b` or `a > b` is true; and"},{"DocComment":" - `<` is transitive: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and"},{"DocComment":" `>`."},{"DocComment":""},{"DocComment":" Mathematically speaking, the `<` operator defines a strict [weak order]. In cases where `==`"},{"DocComment":" conforms to mathematical equality, it also defines a strict [total order]."},{"DocComment":""},{"DocComment":" [weak order]: https://en.wikipedia.org/wiki/Weak_ordering"},{"DocComment":" [total order]: https://en.wikipedia.org/wiki/Total_order"},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`."},{"DocComment":""},{"DocComment":" When `derive`d on structs, it will produce a"},{"DocComment":" [lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering based on the"},{"DocComment":" top-to-bottom declaration order of the struct's members."},{"DocComment":""},{"DocComment":" When `derive`d on enums, variants are ordered primarily by their discriminants. Secondarily,"},{"DocComment":" they are ordered by their fields. By default, the discriminant is smallest for variants at the"},{"DocComment":" top, and largest for variants at the bottom. Here's an example:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, Eq, PartialOrd, Ord)]"},{"DocComment":" enum E {"},{"DocComment":" Top,"},{"DocComment":" Bottom,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Top < E::Bottom);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" However, manually setting the discriminants can override this default behavior:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, Eq, PartialOrd, Ord)]"},{"DocComment":" enum E {"},{"DocComment":" Top = 2,"},{"DocComment":" Bottom = 1,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Bottom < E::Top);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Lexicographical comparison"},{"DocComment":""},{"DocComment":" Lexicographical comparison is an operation with the following properties:"},{"DocComment":" - Two sequences are compared element by element."},{"DocComment":" - The first mismatching element defines which sequence is lexicographically less or greater"},{"DocComment":" than the other."},{"DocComment":" - If one sequence is a prefix of another, the shorter sequence is lexicographically less than"},{"DocComment":" the other."},{"DocComment":" - If two sequences have equivalent elements and are of the same length, then the sequences are"},{"DocComment":" lexicographically equal."},{"DocComment":" - An empty sequence is lexicographically less than any non-empty sequence."},{"DocComment":" - Two empty sequences are lexicographically equal."},{"DocComment":""},{"DocComment":" ## How can I implement `Ord`?"},{"DocComment":""},{"DocComment":" `Ord` requires that the type also be [`PartialOrd`], [`PartialEq`], and [`Eq`]."},{"DocComment":""},{"DocComment":" Because `Ord` implies a stronger ordering relationship than [`PartialOrd`], and both `Ord` and"},{"DocComment":" [`PartialOrd`] must agree, you must choose how to implement `Ord` **first**. You can choose to"},{"DocComment":" derive it, or implement it manually. If you derive it, you should derive all four traits. If you"},{"DocComment":" implement it manually, you should manually implement all four traits, based on the"},{"DocComment":" implementation of `Ord`."},{"DocComment":""},{"DocComment":" Here's an example where you want to define the `Character` comparison by `health` and"},{"DocComment":" `experience` only, disregarding the field `mana`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" struct Character {"},{"DocComment":" health: u32,"},{"DocComment":" experience: u32,"},{"DocComment":" mana: f32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Character {"},{"DocComment":" fn cmp(&self, other: &Self) -> Ordering {"},{"DocComment":" self.experience"},{"DocComment":" .cmp(&other.experience)"},{"DocComment":" .then(self.health.cmp(&other.health))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Character {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.health == other.health && self.experience == other.experience"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Character {}"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" If all you need is to `slice::sort` a type by a field value, it can be simpler to use"},{"DocComment":" `slice::sort_by_key`."},{"DocComment":""},{"DocComment":" ## Examples of incorrect `Ord` implementations"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct Character {"},{"DocComment":" health: f32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Character {"},{"DocComment":" fn cmp(&self, other: &Self) -> std::cmp::Ordering {"},{"DocComment":" if self.health < other.health {"},{"DocComment":" Ordering::Less"},{"DocComment":" } else if self.health > other.health {"},{"DocComment":" Ordering::Greater"},{"DocComment":" } else {"},{"DocComment":" Ordering::Equal"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Character {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.health == other.health"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Character {}"},{"DocComment":""},{"DocComment":" let a = Character { health: 4.5 };"},{"DocComment":" let b = Character { health: f32::NAN };"},{"DocComment":""},{"DocComment":" // Mistake: floating-point values do not form a total order and using the built-in comparison"},{"DocComment":" // operands to implement `Ord` irregardless of that reality does not change it. Use"},{"DocComment":" // `f32::total_cmp` if you need a total order for floating-point values."},{"DocComment":""},{"DocComment":" // Reflexivity requirement of `Ord` is not given."},{"DocComment":" assert!(a == a);"},{"DocComment":" assert!(b != b);"},{"DocComment":""},{"DocComment":" // Antisymmetry requirement of `Ord` is not given. Only one of a < c and c < a is allowed to be"},{"DocComment":" // true, not both or neither."},{"DocComment":" assert_eq!((a < b) as u8 + (b < a) as u8, 0);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct Character {"},{"DocComment":" health: u32,"},{"DocComment":" experience: u32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Character {"},{"DocComment":" fn cmp(&self, other: &Self) -> std::cmp::Ordering {"},{"DocComment":" if self.health < 50 {"},{"DocComment":" self.health.cmp(&other.health)"},{"DocComment":" } else {"},{"DocComment":" self.experience.cmp(&other.experience)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // For performance reasons implementing `PartialEq` this way is not the idiomatic way, but it"},{"DocComment":" // ensures consistent behavior between `PartialEq`, `PartialOrd` and `Ord` in this example."},{"DocComment":" impl PartialEq for Character {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.cmp(other) == Ordering::Equal"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Character {}"},{"DocComment":""},{"DocComment":" let a = Character {"},{"DocComment":" health: 3,"},{"DocComment":" experience: 5,"},{"DocComment":" };"},{"DocComment":" let b = Character {"},{"DocComment":" health: 10,"},{"DocComment":" experience: 77,"},{"DocComment":" };"},{"DocComment":" let c = Character {"},{"DocComment":" health: 143,"},{"DocComment":" experience: 2,"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" // Mistake: The implementation of `Ord` compares different fields depending on the value of"},{"DocComment":" // `self.health`, the resulting order is not total."},{"DocComment":""},{"DocComment":" // Transitivity requirement of `Ord` is not given. If a is smaller than b and b is smaller than"},{"DocComment":" // c, by transitive property a must also be smaller than c."},{"DocComment":" assert!(a < b && b < c && c < a);"},{"DocComment":""},{"DocComment":" // Antisymmetry requirement of `Ord` is not given. Only one of a < c and c < a is allowed to be"},{"DocComment":" // true, not both or neither."},{"DocComment":" assert_eq!((a < c) as u8 + (c < a) as u8, 2);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The documentation of [`PartialOrd`] contains further examples, for example it's wrong for"},{"DocComment":" [`PartialOrd`] and [`PartialEq`] to disagree."},{"DocComment":""},{"DocComment":" [`cmp`]: Ord::cmp"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Ord"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":46,"beg":{"line":973,"col":21},"end":{"line":973,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":27,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":46,"beg":{"line":973,"col":34},"end":{"line":973,"col":58}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"cmp","attr_info":{"attributes":[{"DocComment":" This method returns an [`Ordering`] between `self` and `other`."},{"DocComment":""},{"DocComment":" By convention, `self.cmp(&other)` returns the ordering matching the expression"},{"DocComment":" `self other` if true."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" assert_eq!(5.cmp(&10), Ordering::Less);"},{"DocComment":" assert_eq!(10.cmp(&5), Ordering::Greater);"},{"DocComment":" assert_eq!(5.cmp(&5), Ordering::Equal);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2229},{"HashConsedValue":[7015,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":188},"Shared"]}]}],"output":{"Deduplicated":3978}},"item":{"id":284,"generics":{"regions":[{"Var":{"Bound":[0,0]}},{"Var":{"Bound":[0,1]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6455,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":17,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[17,0]}},null,null,null],"vtable":null},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Copy",0]}],"span":{"data":{"file_id":1,"beg":{"line":457,"col":0},"end":{"line":457,"col":21}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Types whose values can be duplicated simply by copying bits."},{"DocComment":""},{"DocComment":" By default, variable bindings have 'move semantics.' In other"},{"DocComment":" words:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Debug)]"},{"DocComment":" struct Foo;"},{"DocComment":""},{"DocComment":" let x = Foo;"},{"DocComment":""},{"DocComment":" let y = x;"},{"DocComment":""},{"DocComment":" // `x` has moved into `y`, and so cannot be used"},{"DocComment":""},{"DocComment":" // println!(\"{x:?}\"); // error: use of moved value"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" However, if a type implements `Copy`, it instead has 'copy semantics':"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // We can derive a `Copy` implementation. `Clone` is also required, as it's"},{"DocComment":" // a supertrait of `Copy`."},{"DocComment":" #[derive(Debug, Copy, Clone)]"},{"DocComment":" struct Foo;"},{"DocComment":""},{"DocComment":" let x = Foo;"},{"DocComment":""},{"DocComment":" let y = x;"},{"DocComment":""},{"DocComment":" // `y` is a copy of `x`"},{"DocComment":""},{"DocComment":" println!(\"{x:?}\"); // A-OK!"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" It's important to note that in these two examples, the only difference is whether you"},{"DocComment":" are allowed to access `x` after the assignment. Under the hood, both a copy and a move"},{"DocComment":" can result in bits being copied in memory, although this is sometimes optimized away."},{"DocComment":""},{"DocComment":" ## How can I implement `Copy`?"},{"DocComment":""},{"DocComment":" There are two ways to implement `Copy` on your type. The simplest is to use `derive`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct MyStruct;"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" You can also implement `Copy` and `Clone` manually:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" struct MyStruct;"},{"DocComment":""},{"DocComment":" impl Copy for MyStruct { }"},{"DocComment":""},{"DocComment":" impl Clone for MyStruct {"},{"DocComment":" fn clone(&self) -> MyStruct {"},{"DocComment":" *self"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" There is a small difference between the two. The `derive` strategy will also place a `Copy`"},{"DocComment":" bound on type parameters:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(Clone)]"},{"DocComment":" struct MyStruct(T);"},{"DocComment":""},{"DocComment":" impl Copy for MyStruct { }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" This isn't always desired. For example, shared references (`&T`) can be copied regardless of"},{"DocComment":" whether `T` is `Copy`. Likewise, a generic struct containing markers such as [`PhantomData`]"},{"DocComment":" could potentially be duplicated with a bit-wise copy."},{"DocComment":""},{"DocComment":" ## What's the difference between `Copy` and `Clone`?"},{"DocComment":""},{"DocComment":" Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of"},{"DocComment":" `Copy` is not overloadable; it is always a simple bit-wise copy."},{"DocComment":""},{"DocComment":" Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can"},{"DocComment":" provide any type-specific behavior necessary to duplicate values safely. For example,"},{"DocComment":" the implementation of [`Clone`] for [`String`] needs to copy the pointed-to string"},{"DocComment":" buffer in the heap. A simple bitwise copy of [`String`] values would merely copy the"},{"DocComment":" pointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]"},{"DocComment":" but not `Copy`."},{"DocComment":""},{"DocComment":" [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement"},{"DocComment":" [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`"},{"DocComment":" (see the example above)."},{"DocComment":""},{"DocComment":" ## When can my type be `Copy`?"},{"DocComment":""},{"DocComment":" A type can implement `Copy` if all of its components implement `Copy`. For example, this"},{"DocComment":" struct can be `Copy`:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #[allow(dead_code)]"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct Point {"},{"DocComment":" x: i32,"},{"DocComment":" y: i32,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`."},{"DocComment":" By contrast, consider"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" # struct Point;"},{"DocComment":" struct PointList {"},{"DocComment":" points: Vec,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" The struct `PointList` cannot implement `Copy`, because [`Vec`] is not `Copy`. If we"},{"DocComment":" attempt to derive a `Copy` implementation, we'll get an error:"},{"DocComment":""},{"DocComment":" ```text"},{"DocComment":" the trait `Copy` cannot be implemented for this type; field `points` does not implement `Copy`"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" Shared references (`&T`) are also `Copy`, so a type can be `Copy`, even when it holds"},{"DocComment":" shared references of types `T` that are *not* `Copy`. Consider the following struct,"},{"DocComment":" which can implement `Copy`, because it only holds a *shared reference* to our non-`Copy`"},{"DocComment":" type `PointList` from above:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" # #![allow(dead_code)]"},{"DocComment":" # struct PointList;"},{"DocComment":" #[derive(Copy, Clone)]"},{"DocComment":" struct PointListWrapper<'a> {"},{"DocComment":" point_list_ref: &'a PointList,"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## When *can't* my type be `Copy`?"},{"DocComment":""},{"DocComment":" Some types can't be copied safely. For example, copying `&mut T` would create an aliased"},{"DocComment":" mutable reference. Copying [`String`] would duplicate responsibility for managing the"},{"DocComment":" [`String`]'s buffer, leading to a double free."},{"DocComment":""},{"DocComment":" Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's"},{"DocComment":" managing some resource besides its own [`size_of::`] bytes."},{"DocComment":""},{"DocComment":" If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get"},{"DocComment":" the error [E0204]."},{"DocComment":""},{"DocComment":" [E0204]: ../../error_codes/E0204.html"},{"DocComment":""},{"DocComment":" ## When *should* my type be `Copy`?"},{"DocComment":""},{"DocComment":" Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,"},{"DocComment":" that implementing `Copy` is part of the public API of your type. If the type might become"},{"DocComment":" non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to"},{"DocComment":" avoid a breaking API change."},{"DocComment":""},{"DocComment":" ## Additional implementors"},{"DocComment":""},{"DocComment":" In addition to the [implementors listed below][impls],"},{"DocComment":" the following types also implement `Copy`:"},{"DocComment":""},{"DocComment":" * Function item types (i.e., the distinct types defined for each function)"},{"DocComment":" * Function pointer types (e.g., `fn() -> i32`)"},{"DocComment":" * Closure types, if they capture no value from the environment"},{"DocComment":" or if all such captured values implement `Copy` themselves."},{"DocComment":" Note that variables captured by shared reference always implement `Copy`"},{"DocComment":" (even if the referent doesn't),"},{"DocComment":" while variables captured by mutable reference never implement `Copy`."},{"DocComment":""},{"DocComment":" [`Vec`]: ../../std/vec/struct.Vec.html"},{"DocComment":" [`String`]: ../../std/string/struct.String.html"},{"DocComment":" [`size_of::`]: size_of"},{"DocComment":" [impls]: #implementors"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"copy"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":1,"beg":{"line":457,"col":0},"end":{"line":459,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":1,"beg":{"line":457,"col":16},"end":{"line":457,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":19,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Sum",0]}],"span":{"data":{"file_id":52,"beg":{"line":17,"col":0},"end":{"line":17,"col":30}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait to represent types that can be created by summing up an iterator."},{"DocComment":""},{"DocComment":" This trait is used to implement [`Iterator::sum()`]. Types which implement"},{"DocComment":" this trait can be generated by using the [`sum()`] method on an iterator."},{"DocComment":" Like [`FromIterator`], this trait should rarely be called directly."},{"DocComment":""},{"DocComment":" [`sum()`]: Iterator::sum"},{"DocComment":" [`FromIterator`]: iter::FromIterator"},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message =\n\"a value of type `{Self}` cannot be made by summing an iterator over elements of type `{A}`\",\nlabel =\n\"value of type `{Self}` cannot be made by summing a `std::iter::Iterator`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":17,"col":25},"end":{"line":17,"col":30}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":17,"col":14},"end":{"line":17,"col":22}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":21,"col":11},"end":{"line":21,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":21,"col":14},"end":{"line":21,"col":32}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5171},"type_id":0,"ty":{"Deduplicated":2621}}}]},"skip_binder":{"name":"sum","attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by \"summing up\""},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":188}},"item":{"id":288,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023},{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6456,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":19,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"Deduplicated":5166}]}}},"kind":{"TraitMethod":[19,0]}}],"vtable":null},{"def_id":20,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["accum",0]},{"Ident":["Product",0]}],"span":{"data":{"file_id":52,"beg":{"line":38,"col":0},"end":{"line":38,"col":34}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait to represent types that can be created by multiplying elements of an"},{"DocComment":" iterator."},{"DocComment":""},{"DocComment":" This trait is used to implement [`Iterator::product()`]. Types which implement"},{"DocComment":" this trait can be generated by using the [`product()`] method on an iterator."},{"DocComment":" Like [`FromIterator`], this trait should rarely be called directly."},{"DocComment":""},{"DocComment":" [`product()`]: Iterator::product"},{"DocComment":" [`FromIterator`]: iter::FromIterator"},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message =\n\"a value of type `{Self}` cannot be made by multiplying all elements of type `{A}` from an iterator\",\nlabel =\n\"value of type `{Self}` cannot be made by multiplying all elements from a `std::iter::Iterator`\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"A"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":38,"col":29},"end":{"line":38,"col":34}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":38,"col":18},"end":{"line":38,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":52,"beg":{"line":42,"col":15},"end":{"line":42,"col":16}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":52,"beg":{"line":42,"col":18},"end":{"line":42,"col":36}},"generated_from_span":null},"origin":"WhereClauseOnFn","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[{"regions":[],"skip_binder":{"trait_ref":{"Deduplicated":5171},"type_id":0,"ty":{"Deduplicated":2621}}}]},"skip_binder":{"name":"product","attr_info":{"attributes":[{"DocComment":" Takes an iterator and generates `Self` from the elements by multiplying"},{"DocComment":" the items."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":220}],"output":{"Deduplicated":188}},"item":{"id":289,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023},{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6457,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"Deduplicated":5166}]}}},"kind":{"TraitMethod":[20,0]}}],"vtable":null},{"def_id":21,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialOrd",0]}],"span":{"data":{"file_id":46,"beg":{"line":1358,"col":0},"end":{"line":1359,"col":41}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for types that form a [partial order](https://en.wikipedia.org/wiki/Partial_order)."},{"DocComment":""},{"DocComment":" The `lt`, `le`, `gt`, and `ge` methods of this trait can be called using the `<`, `<=`, `>`, and"},{"DocComment":" `>=` operators, respectively."},{"DocComment":""},{"DocComment":" This trait should **only** contain the comparison logic for a type **if one plans on only"},{"DocComment":" implementing `PartialOrd` but not [`Ord`]**. Otherwise the comparison logic should be in [`Ord`]"},{"DocComment":" and this trait implemented with `Some(self.cmp(other))`."},{"DocComment":""},{"DocComment":" The methods of this trait must be consistent with each other and with those of [`PartialEq`]."},{"DocComment":" The following conditions must hold:"},{"DocComment":""},{"DocComment":" 1. `a == b` if and only if `partial_cmp(a, b) == Some(Equal)`."},{"DocComment":" 2. `a < b` if and only if `partial_cmp(a, b) == Some(Less)`"},{"DocComment":" 3. `a > b` if and only if `partial_cmp(a, b) == Some(Greater)`"},{"DocComment":" 4. `a <= b` if and only if `a < b || a == b`"},{"DocComment":" 5. `a >= b` if and only if `a > b || a == b`"},{"DocComment":" 6. `a != b` if and only if `!(a == b)`."},{"DocComment":""},{"DocComment":" Conditions 2–5 above are ensured by the default implementation. Condition 6 is already ensured"},{"DocComment":" by [`PartialEq`]."},{"DocComment":""},{"DocComment":" If [`Ord`] is also implemented for `Self` and `Rhs`, it must also be consistent with"},{"DocComment":" `partial_cmp` (see the documentation of that trait for the exact requirements). It's easy to"},{"DocComment":" accidentally make them disagree by deriving some of the traits and manually implementing others."},{"DocComment":""},{"DocComment":" The comparison relations must satisfy the following conditions (for all `a`, `b`, `c` of type"},{"DocComment":" `A`, `B`, `C`):"},{"DocComment":""},{"DocComment":" - **Transitivity**: if `A: PartialOrd` and `B: PartialOrd` and `A: PartialOrd`, then `a"},{"DocComment":" < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`. This must also"},{"DocComment":" work for longer chains, such as when `A: PartialOrd`, `B: PartialOrd`, `C:"},{"DocComment":" PartialOrd`, and `A: PartialOrd` all exist."},{"DocComment":" - **Duality**: if `A: PartialOrd` and `B: PartialOrd`, then `a < b` if and only if `b >"},{"DocComment":" a`."},{"DocComment":""},{"DocComment":" Note that the `B: PartialOrd` (dual) and `A: PartialOrd` (transitive) impls are not forced"},{"DocComment":" to exist, but these requirements apply whenever they do exist."},{"DocComment":""},{"DocComment":" Violating these requirements is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" ## Cross-crate considerations"},{"DocComment":""},{"DocComment":" Upholding the requirements stated above can become tricky when one crate implements `PartialOrd`"},{"DocComment":" for a type of another crate (i.e., to allow comparing one of its own types with a type from the"},{"DocComment":" standard library). The recommendation is to never implement this trait for a foreign type. In"},{"DocComment":" other words, such a crate should do `impl PartialOrd for LocalType`, but it should"},{"DocComment":" *not* do `impl PartialOrd for ForeignType`."},{"DocComment":""},{"DocComment":" This avoids the problem of transitive chains that criss-cross crate boundaries: for all local"},{"DocComment":" types `T`, you may assume that no other crate will add `impl`s that allow comparing `T < U`. In"},{"DocComment":" other words, if other crates add `impl`s that allow building longer transitive chains `U1 < ..."},{"DocComment":" < T < V1 < ...`, then all the types that appear to the right of `T` must be types that the crate"},{"DocComment":" defining `T` already knows about. This rules out transitive chains where downstream crates can"},{"DocComment":" add new `impl`s that \"stitch together\" comparisons of foreign types in ways that violate"},{"DocComment":" transitivity."},{"DocComment":""},{"DocComment":" Not having such foreign `impl`s also avoids forward compatibility issues where one crate adding"},{"DocComment":" more `PartialOrd` implementations can cause build failures in downstream crates."},{"DocComment":""},{"DocComment":" ## Corollaries"},{"DocComment":""},{"DocComment":" The following corollaries follow from the above requirements:"},{"DocComment":""},{"DocComment":" - irreflexivity of `<` and `>`: `!(a < a)`, `!(a > a)`"},{"DocComment":" - transitivity of `>`: if `a > b` and `b > c` then `a > c`"},{"DocComment":" - duality of `partial_cmp`: `partial_cmp(a, b) == partial_cmp(b, a).map(Ordering::reverse)`"},{"DocComment":""},{"DocComment":" ## Strict and non-strict partial orders"},{"DocComment":""},{"DocComment":" The `<` and `>` operators behave according to a *strict* partial order. However, `<=` and `>=`"},{"DocComment":" do **not** behave according to a *non-strict* partial order. That is because mathematically, a"},{"DocComment":" non-strict partial order would require reflexivity, i.e. `a <= a` would need to be true for"},{"DocComment":" every `a`. This isn't always the case for types that implement `PartialOrd`, for example:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let a = f64::NAN;"},{"DocComment":" assert_eq!(a <= a, false);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`."},{"DocComment":""},{"DocComment":" When `derive`d on structs, it will produce a"},{"DocComment":" [lexicographic](https://en.wikipedia.org/wiki/Lexicographic_order) ordering based on the"},{"DocComment":" top-to-bottom declaration order of the struct's members."},{"DocComment":""},{"DocComment":" When `derive`d on enums, variants are primarily ordered by their discriminants. Secondarily,"},{"DocComment":" they are ordered by their fields. By default, the discriminant is smallest for variants at the"},{"DocComment":" top, and largest for variants at the bottom. Here's an example:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, PartialOrd)]"},{"DocComment":" enum E {"},{"DocComment":" Top,"},{"DocComment":" Bottom,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Top < E::Bottom);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" However, manually setting the discriminants can override this default behavior:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #[derive(PartialEq, PartialOrd)]"},{"DocComment":" enum E {"},{"DocComment":" Top = 2,"},{"DocComment":" Bottom = 1,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" assert!(E::Bottom < E::Top);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## How can I implement `PartialOrd`?"},{"DocComment":""},{"DocComment":" `PartialOrd` only requires implementation of the [`partial_cmp`] method, with the others"},{"DocComment":" generated from default implementations."},{"DocComment":""},{"DocComment":" However it remains possible to implement the others separately for types which do not have a"},{"DocComment":" total order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 == false`"},{"DocComment":" (cf. IEEE 754-2008 section 5.11)."},{"DocComment":""},{"DocComment":" `PartialOrd` requires your type to be [`PartialEq`]."},{"DocComment":""},{"DocComment":" If your type is [`Ord`], you can implement [`partial_cmp`] by using [`cmp`]:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" struct Person {"},{"DocComment":" id: u32,"},{"DocComment":" name: String,"},{"DocComment":" height: u32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Person {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.cmp(other))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Ord for Person {"},{"DocComment":" fn cmp(&self, other: &Self) -> Ordering {"},{"DocComment":" self.height.cmp(&other.height)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Person {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.height == other.height"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Person {}"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" You may also find it useful to use [`partial_cmp`] on your type's fields. Here is an example of"},{"DocComment":" `Person` types who have a floating-point `height` field that is the only field to be used for"},{"DocComment":" sorting:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" struct Person {"},{"DocComment":" id: u32,"},{"DocComment":" name: String,"},{"DocComment":" height: f64,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Person {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" self.height.partial_cmp(&other.height)"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Person {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.height == other.height"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## Examples of incorrect `PartialOrd` implementations"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" #[derive(PartialEq, Debug)]"},{"DocComment":" struct Character {"},{"DocComment":" health: u32,"},{"DocComment":" experience: u32,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialOrd for Character {"},{"DocComment":" fn partial_cmp(&self, other: &Self) -> Option {"},{"DocComment":" Some(self.health.cmp(&other.health))"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let a = Character {"},{"DocComment":" health: 10,"},{"DocComment":" experience: 5,"},{"DocComment":" };"},{"DocComment":" let b = Character {"},{"DocComment":" health: 10,"},{"DocComment":" experience: 77,"},{"DocComment":" };"},{"DocComment":""},{"DocComment":" // Mistake: `PartialEq` and `PartialOrd` disagree with each other."},{"DocComment":""},{"DocComment":" assert_eq!(a.partial_cmp(&b).unwrap(), Ordering::Equal); // a == b according to `PartialOrd`."},{"DocComment":" assert_ne!(a, b); // a != b according to `PartialEq`."},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let x: u32 = 0;"},{"DocComment":" let y: u32 = 1;"},{"DocComment":""},{"DocComment":" assert_eq!(x < y, true);"},{"DocComment":" assert_eq!(x.lt(&y), true);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`partial_cmp`]: PartialOrd::partial_cmp"},{"DocComment":" [`cmp`]: Ord::cmp"},{"Unknown":{"path":"rustc_on_unimplemented","args":"message = \"can't compare `{Self}` with `{Rhs}`\", label =\n\"no implementation for `{Self} < {Rhs}` and `{Self} > {Rhs}`\",\nappend_const_msg"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"partial_ord"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":46,"beg":{"line":1359,"col":4},"end":{"line":1359,"col":26}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"partial_cmp","attr_info":{"attributes":[{"DocComment":" This method returns an ordering between `self` and `other` values if one exists."},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" use std::cmp::Ordering;"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&2.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Less));"},{"DocComment":""},{"DocComment":" let result = 1.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Equal));"},{"DocComment":""},{"DocComment":" let result = 2.0.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, Some(Ordering::Greater));"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" When comparison is impossible:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let result = f64::NAN.partial_cmp(&1.0);"},{"DocComment":" assert_eq!(result, None);"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2229},{"HashConsedValue":[5742,{"Ref":[{"Var":{"Bound":[0,1]}},{"Deduplicated":2023},"Shared"]}]}],"output":{"Deduplicated":4347}},"item":{"id":290,"generics":{"regions":[{"Var":{"Bound":[0,0]}},{"Var":{"Bound":[0,1]}}],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6458,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[21,0]}},null,null,null,null,null,null,null,null],"vtable":{"id":{"Adt":48},"generics":{"regions":[],"types":[{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}}},{"def_id":22,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["PartialEq",0]}],"span":{"data":{"file_id":46,"beg":{"line":251,"col":0},"end":{"line":251,"col":65}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for comparisons using the equality operator."},{"DocComment":""},{"DocComment":" Implementing this trait for types provides the `==` and `!=` operators for"},{"DocComment":" those types."},{"DocComment":""},{"DocComment":" `x.eq(y)` can also be written `x == y`, and `x.ne(y)` can be written `x != y`."},{"DocComment":" We use the easier-to-read infix notation in the remainder of this documentation."},{"DocComment":""},{"DocComment":" This trait allows for comparisons using the equality operator, for types"},{"DocComment":" that do not have a full equivalence relation. For example, in floating point"},{"DocComment":" numbers `NaN != NaN`, so floating point types implement `PartialEq` but not"},{"DocComment":" [`trait@Eq`]. Formally speaking, when `Rhs == Self`, this trait corresponds"},{"DocComment":" to a [partial equivalence relation]."},{"DocComment":""},{"DocComment":" [partial equivalence relation]: https://en.wikipedia.org/wiki/Partial_equivalence_relation"},{"DocComment":""},{"DocComment":" Implementations must ensure that `eq` and `ne` are consistent with each other:"},{"DocComment":""},{"DocComment":" - `a != b` if and only if `!(a == b)`."},{"DocComment":""},{"DocComment":" The default implementation of `ne` provides this consistency and is almost"},{"DocComment":" always sufficient. It should not be overridden without very good reason."},{"DocComment":""},{"DocComment":" If [`PartialOrd`] or [`Ord`] are also implemented for `Self` and `Rhs`, their methods must also"},{"DocComment":" be consistent with `PartialEq` (see the documentation of those traits for the exact"},{"DocComment":" requirements). It's easy to accidentally make them disagree by deriving some of the traits and"},{"DocComment":" manually implementing others."},{"DocComment":""},{"DocComment":" The equality relation `==` must satisfy the following conditions"},{"DocComment":" (for all `a`, `b`, `c` of type `A`, `B`, `C`):"},{"DocComment":""},{"DocComment":" - **Symmetry**: if `A: PartialEq` and `B: PartialEq`, then **`a == b`"},{"DocComment":" implies `b == a`**; and"},{"DocComment":""},{"DocComment":" - **Transitivity**: if `A: PartialEq` and `B: PartialEq` and `A:"},{"DocComment":" PartialEq`, then **`a == b` and `b == c` implies `a == c`**."},{"DocComment":" This must also work for longer chains, such as when `A: PartialEq`, `B: PartialEq`,"},{"DocComment":" `C: PartialEq`, and `A: PartialEq` all exist."},{"DocComment":""},{"DocComment":" Note that the `B: PartialEq` (symmetric) and `A: PartialEq`"},{"DocComment":" (transitive) impls are not forced to exist, but these requirements apply"},{"DocComment":" whenever they do exist."},{"DocComment":""},{"DocComment":" Violating these requirements is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" ## Cross-crate considerations"},{"DocComment":""},{"DocComment":" Upholding the requirements stated above can become tricky when one crate implements `PartialEq`"},{"DocComment":" for a type of another crate (i.e., to allow comparing one of its own types with a type from the"},{"DocComment":" standard library). The recommendation is to never implement this trait for a foreign type. In"},{"DocComment":" other words, such a crate should do `impl PartialEq for LocalType`, but it should"},{"DocComment":" *not* do `impl PartialEq for ForeignType`."},{"DocComment":""},{"DocComment":" This avoids the problem of transitive chains that criss-cross crate boundaries: for all local"},{"DocComment":" types `T`, you may assume that no other crate will add `impl`s that allow comparing `T == U`. In"},{"DocComment":" other words, if other crates add `impl`s that allow building longer transitive chains `U1 == ..."},{"DocComment":" == T == V1 == ...`, then all the types that appear to the right of `T` must be types that the"},{"DocComment":" crate defining `T` already knows about. This rules out transitive chains where downstream crates"},{"DocComment":" can add new `impl`s that \"stitch together\" comparisons of foreign types in ways that violate"},{"DocComment":" transitivity."},{"DocComment":""},{"DocComment":" Not having such foreign `impl`s also avoids forward compatibility issues where one crate adding"},{"DocComment":" more `PartialEq` implementations can cause build failures in downstream crates."},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`. When `derive`d on structs, two"},{"DocComment":" instances are equal if all fields are equal, and not equal if any fields"},{"DocComment":" are not equal. When `derive`d on enums, two instances are equal if they"},{"DocComment":" are the same variant and all fields are equal."},{"DocComment":""},{"DocComment":" ## How can I implement `PartialEq`?"},{"DocComment":""},{"DocComment":" An example implementation for a domain in which two books are considered"},{"DocComment":" the same book if their ISBN matches, even if the formats differ:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.isbn == other.isbn"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let b1 = Book { isbn: 3, format: BookFormat::Paperback };"},{"DocComment":" let b2 = Book { isbn: 3, format: BookFormat::Ebook };"},{"DocComment":" let b3 = Book { isbn: 10, format: BookFormat::Paperback };"},{"DocComment":""},{"DocComment":" assert!(b1 == b2);"},{"DocComment":" assert!(b1 != b3);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" ## How can I compare two different types?"},{"DocComment":""},{"DocComment":" The type you can compare with is controlled by `PartialEq`'s type parameter."},{"DocComment":" For example, let's tweak our previous code a bit:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" // The derive implements == comparisons"},{"DocComment":" #[derive(PartialEq)]"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Implement == comparisons"},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &BookFormat) -> bool {"},{"DocComment":" self.format == *other"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" // Implement == comparisons"},{"DocComment":" impl PartialEq for BookFormat {"},{"DocComment":" fn eq(&self, other: &Book) -> bool {"},{"DocComment":" *self == other.format"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" let b1 = Book { isbn: 3, format: BookFormat::Paperback };"},{"DocComment":""},{"DocComment":" assert!(b1 == BookFormat::Paperback);"},{"DocComment":" assert!(BookFormat::Ebook != b1);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" By changing `impl PartialEq for Book` to `impl PartialEq for Book`,"},{"DocComment":" we allow `BookFormat`s to be compared with `Book`s."},{"DocComment":""},{"DocComment":" A comparison like the one above, which ignores some fields of the struct,"},{"DocComment":" can be dangerous. It can easily lead to an unintended violation of the"},{"DocComment":" requirements for a partial equivalence relation. For example, if we kept"},{"DocComment":" the above implementation of `PartialEq` for `BookFormat` and added an"},{"DocComment":" implementation of `PartialEq` for `Book` (either via a `#[derive]` or"},{"DocComment":" via the manual implementation from the first example) then the result would"},{"DocComment":" violate transitivity:"},{"DocComment":""},{"DocComment":" ```should_panic"},{"DocComment":" #[derive(PartialEq)]"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" #[derive(PartialEq)]"},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &BookFormat) -> bool {"},{"DocComment":" self.format == *other"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for BookFormat {"},{"DocComment":" fn eq(&self, other: &Book) -> bool {"},{"DocComment":" *self == other.format"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" fn main() {"},{"DocComment":" let b1 = Book { isbn: 1, format: BookFormat::Paperback };"},{"DocComment":" let b2 = Book { isbn: 2, format: BookFormat::Paperback };"},{"DocComment":""},{"DocComment":" assert!(b1 == BookFormat::Paperback);"},{"DocComment":" assert!(BookFormat::Paperback == b2);"},{"DocComment":""},{"DocComment":" // The following should hold by transitivity but doesn't."},{"DocComment":" assert!(b1 == b2); // <-- PANICS"},{"DocComment":" }"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" let x: u32 = 0;"},{"DocComment":" let y: u32 = 1;"},{"DocComment":""},{"DocComment":" assert_eq!(x == y, false);"},{"DocComment":" assert_eq!(x.eq(&y), false);"},{"DocComment":" ```"},{"DocComment":""},{"DocComment":" [`eq`]: PartialEq::eq"},{"DocComment":" [`ne`]: PartialEq::ne"},{"Unknown":{"path":"rustc_on_unimplemented","args":"message = \"can't compare `{Self}` with `{Rhs}`\", label =\n\"no implementation for `{Self} == {Rhs}`\", append_const_msg"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"eq"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"Rhs"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"},{"index":1,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"eq","attr_info":{"attributes":[{"DocComment":" Tests for `self` and `other` values to be equal, and is used by `==`."}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2229},{"Deduplicated":5742}],"output":{"Deduplicated":235}},"item":{"id":299,"generics":{"regions":[{"Var":{"Bound":[0,0]}},{"Var":{"Bound":[0,1]}}],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"HashConsedValue":[7016,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[22,0]}},null],"vtable":{"id":{"Adt":49},"generics":{"regions":[],"types":[{"Deduplicated":2027}],"const_generics":[],"trait_refs":[]}}},{"def_id":23,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["adapters",0]},{"Ident":["zip",0]},{"Ident":["TrustedRandomAccessNoCoerce",0]}],"span":{"data":{"file_id":24,"beg":{"line":585,"col":0},"end":{"line":585,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Like [`TrustedRandomAccess`] but without any of the requirements / guarantees around"},{"DocComment":" coercions to supertypes after `__iterator_get_unchecked` (they aren’t allowed here!), and"},{"DocComment":" without the requirement that subtypes / supertypes implement `TrustedRandomAccessNoCoerce`."},{"DocComment":""},{"DocComment":" This trait was created in PR #85874 to fix soundness issue #85873 without performance regressions."},{"DocComment":" It is subject to change as we might want to build a more generally useful (for performance"},{"DocComment":" optimizations) and more sophisticated trait or trait hierarchy that replaces or extends"},{"DocComment":" [`TrustedRandomAccess`] and `TrustedRandomAccessNoCoerce`."}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":24,"beg":{"line":585,"col":46},"end":{"line":585,"col":51}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[{"name":"MAY_HAVE_SIDE_EFFECT","attr_info":{"attributes":[{"DocComment":" `true` if getting an iterator element may have side effects."},{"DocComment":" Remember to take inner iterators into account."}],"inline":null,"rename":null,"public":true},"ty":{"Deduplicated":235},"default":null}],"types":[],"methods":[null],"vtable":null},{"def_id":24,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["ops",0]},{"Ident":["try_trait",0]},{"Ident":["FromResidual",0]}],"span":{"data":{"file_id":42,"beg":{"line":310,"col":0},"end":{"line":310,"col":57}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Used to specify which residuals can be converted into which [`crate::ops::Try`] types."},{"DocComment":""},{"DocComment":" Every `Try` type needs to be recreatable from its own associated"},{"DocComment":" `Residual` type, but can also have additional `FromResidual` implementations"},{"DocComment":" to support interconversion with other `Try` types."},{"Unknown":{"path":"rustc_on_unimplemented","args":"on(all(from_desugaring = \"QuestionMark\", Self = \"core::result::Result\",\nR = \"core::option::Option\",), message =\n\"the `?` operator can only be used on `Result`s, not `Option`s, \\\n in {ItemContext} that returns `Result`\",\nlabel = \"use `.ok_or(...)?` to provide an error compatible with `{Self}`\",\nparent_label = \"this function returns a `Result`\"),\non(all(from_desugaring = \"QuestionMark\", Self =\n\"core::result::Result\",), message =\n\"the `?` operator can only be used on `Result`s \\\n in {ItemContext} that returns `Result`\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns a `Result`\"),\non(all(from_desugaring = \"QuestionMark\", Self = \"core::option::Option\", R =\n\"core::result::Result\",), message =\n\"the `?` operator can only be used on `Option`s, not `Result`s, \\\n in {ItemContext} that returns `Option`\",\nlabel = \"use `.ok()?` if you want to discard the `{R}` error information\",\nparent_label = \"this function returns an `Option`\"),\non(all(from_desugaring = \"QuestionMark\", Self = \"core::option::Option\",),\nmessage =\n\"the `?` operator can only be used on `Option`s \\\n in {ItemContext} that returns `Option`\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns an `Option`\"),\non(all(from_desugaring = \"QuestionMark\", Self =\n\"core::ops::control_flow::ControlFlow\", R =\n\"core::ops::control_flow::ControlFlow\",), message =\n\"the `?` operator in {ItemContext} that returns `ControlFlow` \\\n can only be used on other `ControlFlow`s (with the same Break type)\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns a `ControlFlow`\", note =\n\"unlike `Result`, there's no `From`-conversion performed for `ControlFlow`\"),\non(all(from_desugaring = \"QuestionMark\", Self =\n\"core::ops::control_flow::ControlFlow\",), message =\n\"the `?` operator can only be used on `ControlFlow`s \\\n in {ItemContext} that returns `ControlFlow`\",\nlabel = \"this `?` produces `{R}`, which is incompatible with `{Self}`\",\nparent_label = \"this function returns a `ControlFlow`\",),\non(all(from_desugaring = \"QuestionMark\"), message =\n\"the `?` operator can only be used in {ItemContext} \\\n that returns `Result` or `Option` \\\n (or another type that implements `{This}`)\",\nlabel = \"cannot use the `?` operator in {ItemContext} that returns `{Self}`\",\nparent_label =\n\"this function should return `Result` or `Option` to accept `?`\"),"}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"FromResidual"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"},{"index":1,"name":"R"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":42,"beg":{"line":310,"col":0},"end":{"line":334,"col":1}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":42,"beg":{"line":310,"col":29},"end":{"line":310,"col":56}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"name":"from_residual","attr_info":{"attributes":[{"DocComment":" Constructs the type from a compatible `Residual` type."},{"DocComment":""},{"DocComment":" This should be implemented consistently with the `branch` method such"},{"DocComment":" that applying the `?` operator will get back an equivalent residual:"},{"DocComment":" `FromResidual::from_residual(r).branch() --> ControlFlow::Break(r)`."},{"DocComment":" (The residual is not mandated to be *identical* when interconversion is involved.)"},{"DocComment":""},{"DocComment":" # Examples"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" #![feature(try_trait_v2)]"},{"DocComment":" use std::ops::{ControlFlow, FromResidual};"},{"DocComment":""},{"DocComment":" assert_eq!(Result::::from_residual(Err(3_u8)), Err(3));"},{"DocComment":" assert_eq!(Option::::from_residual(None), None);"},{"DocComment":" assert_eq!("},{"DocComment":" ControlFlow::<_, String>::from_residual(ControlFlow::Break(5)),"},{"DocComment":" ControlFlow::Break(5),"},{"DocComment":" );"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"signature":{"is_unsafe":false,"inputs":[{"Deduplicated":2023}],"output":{"Deduplicated":188}},"item":{"id":302,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"HashConsedValue":[6460,{"kind":"SelfId","trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":2049},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"kind":{"TraitMethod":[24,0]}}],"vtable":null},{"def_id":25,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Ident":["Tuple",0]}],"span":{"data":{"file_id":1,"beg":{"line":1074,"col":0},"end":{"line":1074,"col":15}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" A marker for tuple types."},{"DocComment":""},{"DocComment":" The implementation of this trait is built-in and cannot be implemented"},{"DocComment":" for any user type."},{"Unknown":{"path":"diagnostic::on_unimplemented","args":"message = \"`{Self}` is not a tuple\""}}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"tuple_trait"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":1,"beg":{"line":1074,"col":0},"end":{"line":1074,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":26,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Ident":["private",0]},{"Ident":["Sealed",0]}],"span":{"data":{"file_id":19,"beg":{"line":46,"col":12},"end":{"line":46,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":null},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":19,"beg":{"line":46,"col":12},"end":{"line":46,"col":31}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[],"vtable":{"id":{"Adt":50},"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},{"def_id":27,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["cmp",0]},{"Ident":["Eq",0]}],"span":{"data":{"file_id":46,"beg":{"line":338,"col":0},"end":{"line":338,"col":58}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[{"DocComment":" Trait for comparisons corresponding to [equivalence relations]("},{"DocComment":" https://en.wikipedia.org/wiki/Equivalence_relation)."},{"DocComment":""},{"DocComment":" The primary difference to [`PartialEq`] is the additional requirement for reflexivity. A type"},{"DocComment":" that implements [`PartialEq`] guarantees that for all `a`, `b` and `c`:"},{"DocComment":""},{"DocComment":" - symmetric: `a == b` implies `b == a` and `a != b` implies `!(a == b)`"},{"DocComment":" - transitive: `a == b` and `b == c` implies `a == c`"},{"DocComment":""},{"DocComment":" `Eq`, which builds on top of [`PartialEq`] also implies:"},{"DocComment":""},{"DocComment":" - reflexive: `a == a`"},{"DocComment":""},{"DocComment":" This property cannot be checked by the compiler, and therefore `Eq` is a trait without methods."},{"DocComment":""},{"DocComment":" Violating this property is a logic error. The behavior resulting from a logic error is not"},{"DocComment":" specified, but users of the trait must ensure that such logic errors do *not* result in"},{"DocComment":" undefined behavior. This means that `unsafe` code **must not** rely on the correctness of these"},{"DocComment":" methods."},{"DocComment":""},{"DocComment":" Floating point types such as [`f32`] and [`f64`] implement only [`PartialEq`] but *not* `Eq`"},{"DocComment":" because `NaN` != `NaN`."},{"DocComment":""},{"DocComment":" ## Derivable"},{"DocComment":""},{"DocComment":" This trait can be used with `#[derive]`. When `derive`d, because `Eq` has no extra methods, it"},{"DocComment":" is only informing the compiler that this is an equivalence relation rather than a partial"},{"DocComment":" equivalence relation. Note that the `derive` strategy requires all fields are `Eq`, which isn't"},{"DocComment":" always desired."},{"DocComment":""},{"DocComment":" ## How can I implement `Eq`?"},{"DocComment":""},{"DocComment":" If you cannot use the `derive` strategy, specify that your type implements `Eq`, which has no"},{"DocComment":" extra methods:"},{"DocComment":""},{"DocComment":" ```"},{"DocComment":" enum BookFormat {"},{"DocComment":" Paperback,"},{"DocComment":" Hardback,"},{"DocComment":" Ebook,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" struct Book {"},{"DocComment":" isbn: i32,"},{"DocComment":" format: BookFormat,"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl PartialEq for Book {"},{"DocComment":" fn eq(&self, other: &Self) -> bool {"},{"DocComment":" self.isbn == other.isbn"},{"DocComment":" }"},{"DocComment":" }"},{"DocComment":""},{"DocComment":" impl Eq for Book {}"},{"DocComment":" ```"}],"inline":null,"rename":null,"public":true},"is_local":false,"opacity":"Foreign","lang_item":"Eq"},"generics":{"regions":[],"types":[{"index":0,"name":"Self"}],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_clauses":[{"clause_id":0,"span":{"data":{"file_id":46,"beg":{"line":338,"col":20},"end":{"line":338,"col":43}},"generated_from_span":null},"origin":"WhereClauseOnTrait","trait_":{"regions":[],"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"consts":[],"types":[],"methods":[null],"vtable":null}],"trait_impls":[{"def_id":0,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":0}}],"span":{"data":{"file_id":4,"beg":{"line":21,"col":0},"end":{"line":21,"col":36}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":2040}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":4,"beg":{"line":21,"col":9},"end":{"line":21,"col":10}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[7024,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[7023,{"Ref":["Erased",{"HashConsedValue":[2041,{"Slice":{"Deduplicated":188}}]},"Shared"]}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[6279,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"Deduplicated":6233}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":6232}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7025,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5961,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5960,{"Adt":{"id":{"Adt":6},"generics":{"regions":["Erased"],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"HashConsedValue":[2055,{"kind":{"Clause":{"Bound":[1,0]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2049}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5960}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7026,{"kind":{"TraitImpl":{"id":1,"generics":{"regions":["Erased"],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":5960}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":2048},"implied_trait_refs":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"HashConsedValue":[2056,{"Adt":{"id":{"Adt":6},"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}}}]},"implied_trait_refs":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":14,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":0,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}}},{"def_id":1,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["slice",0]},{"Ident":["iter",0]},{"Impl":{"Trait":1}}],"span":{"data":{"file_id":7,"beg":{"line":153,"col":8},"end":{"line":153,"col":45}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":2063}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":"'a","mutability":"Unknown"}],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":7,"beg":{"line":153,"col":17},"end":{"line":153,"col":18}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":5961},{"Deduplicated":6279}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":2048},"implied_trait_refs":[]},"kind":{"TraitType":[3,0]}}],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":15,"generics":{"regions":[{"Var":{"Bound":[1,0]}},{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[3,0]}},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"vtable":{"id":1,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}}},{"def_id":2,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":2}}],"span":{"data":{"file_id":8,"beg":{"line":39,"col":0},"end":{"line":39,"col":47}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":4931}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":39,"col":5},"end":{"line":39,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[7033,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[4932,{"Array":[{"Deduplicated":188},{"kind":{"Var":{"Bound":[1,0]}},"ty":{"Deduplicated":775}}]}]}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"HashConsedValue":[7034,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5965,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[4939,{"Adt":{"id":{"Adt":8},"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[{"kind":{"Var":{"Bound":[1,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":2055}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":4939}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7035,{"kind":{"TraitImpl":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":4939}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":188},"implied_trait_refs":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":4939},"implied_trait_refs":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":16,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[{"kind":{"Var":{"Bound":[1,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}}},{"def_id":3,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Impl":{"Trait":3}}],"span":{"data":{"file_id":8,"beg":{"line":235,"col":0},"end":{"line":235,"col":51}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":4944}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":235,"col":5},"end":{"line":235,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":5965},{"Deduplicated":223}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":188},"implied_trait_refs":[]},"kind":{"TraitType":[3,0]}}],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":17,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[{"Deduplicated":188}],"const_generics":[{"kind":{"Var":{"Bound":[1,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[3,0]}},null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"vtable":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[{"kind":{"Var":{"Bound":[0,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":223}]}}},{"def_id":4,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["array",0]},{"Ident":["iter",0]},{"Ident":["IntoIter",0]},{"Impl":{"Trait":4}}],"span":{"data":{"file_id":8,"beg":{"line":20,"col":0},"end":{"line":20,"col":38}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":4944}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[{"index":0,"name":"N","ty":{"Deduplicated":775}}],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":8,"beg":{"line":20,"col":20},"end":{"line":20,"col":21}},"generated_from_span":null},"origin":"WhereClauseOnType","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":256,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[{"kind":{"Var":{"Bound":[1,0]}},"ty":{"Deduplicated":775}}],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[2,0]}}],"vtable":null},{"def_id":5,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["iter",0]},{"Ident":["traits",0]},{"Ident":["collect",0]},{"Impl":{"Trait":5}}],"span":{"data":{"file_id":13,"beg":{"line":317,"col":0},"end":{"line":317,"col":50}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":6,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"I"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":13,"beg":{"line":317,"col":5},"end":{"line":317,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":13,"beg":{"line":317,"col":8},"end":{"line":317,"col":24}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":3,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[7042,{"kind":{"ParentClause":[{"Deduplicated":223},0]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7043,{"kind":{"ParentClause":[{"Deduplicated":5166},1]},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5172}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"Deduplicated":5166}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":5172},"implied_trait_refs":[]},"kind":{"TraitType":[6,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":188},"implied_trait_refs":[]},"kind":{"TraitType":[6,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":20,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055},{"Deduplicated":5171}]}},"kind":{"TraitMethod":[6,0]}}],"vtable":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"Deduplicated":5166}]}}},{"def_id":6,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":6}}],"span":{"data":{"file_id":3,"beg":{"line":2162,"col":0},"end":{"line":2162,"col":42}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":5178}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":5},"end":{"line":2162,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2162,"col":8},"end":{"line":2162,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[7046,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5179,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"Deduplicated":2055},{"Deduplicated":3039}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7048,{"kind":{"TraitImpl":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":2027},{"Deduplicated":2027}],"const_generics":[],"trait_refs":[{"Deduplicated":223},{"Deduplicated":2650},{"Deduplicated":2650},{"HashConsedValue":[7047,{"kind":{"TraitImpl":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":2027}],"const_generics":[],"trait_refs":[{"Deduplicated":2650}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":2023},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}]}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":5179},{"Deduplicated":5184}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"Deduplicated":5200}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":188},"implied_trait_refs":[]},"kind":{"TraitType":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":5184},"implied_trait_refs":[]},"kind":{"TraitType":[11,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":257,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"Deduplicated":2055},{"Deduplicated":3039}]}},"kind":{"TraitMethod":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":21,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[{"Deduplicated":2055},{"Deduplicated":3039}]}},"kind":{"TraitMethod":[11,1]}}],"vtable":null},{"def_id":7,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["result",0]},{"Impl":{"Trait":7}}],"span":{"data":{"file_id":3,"beg":{"line":2182,"col":0},"end":{"line":2183,"col":20}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":5202},{"Deduplicated":5198}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"},{"index":1,"name":"E"},{"index":2,"name":"F"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":5},"end":{"line":2182,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":1,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":8},"end":{"line":2182,"col":9}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":2,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":11},"end":{"line":2182,"col":12}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3001}],"const_generics":[],"trait_refs":[]}}}},{"clause_id":3,"span":{"data":{"file_id":3,"beg":{"line":2182,"col":14},"end":{"line":2182,"col":29}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":3001},{"Deduplicated":2023}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[7049,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[5205,{"Adt":{"id":{"Adt":5},"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":3001}],"const_generics":[],"trait_refs":[{"Deduplicated":2055},{"HashConsedValue":[5204,{"kind":{"Clause":{"Bound":[1,2]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":3005}],"const_generics":[],"trait_refs":[]}}}}]}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":5200}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":22,"generics":{"regions":[],"types":[{"Deduplicated":188},{"Deduplicated":2023},{"Deduplicated":3001}],"const_generics":[],"trait_refs":[{"Deduplicated":2055},{"Deduplicated":3039},{"Deduplicated":5204},{"HashConsedValue":[7050,{"kind":{"Clause":{"Bound":[1,3]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":3005},{"Deduplicated":2621}],"const_generics":[],"trait_refs":[]}}}}]}]}},"kind":{"TraitMethod":[24,0]}}],"vtable":null},{"def_id":8,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["convert",0]},{"Impl":{"Trait":8}}],"span":{"data":{"file_id":12,"beg":{"line":785,"col":0},"end":{"line":785,"col":27}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":4,"generics":{"regions":[],"types":[{"Deduplicated":220},{"Deduplicated":220}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":12,"beg":{"line":785,"col":5},"end":{"line":785,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":223},{"Deduplicated":223}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":259,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[4,0]}}],"vtable":null},{"def_id":9,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Impl":{"Trait":9}}],"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"impl_trait":{"id":5,"generics":{"regions":[],"types":[{"Deduplicated":5218},{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[7054,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[6475,{"Adt":{"id":{"Adt":11},"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[2347,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[2346,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7055,{"kind":{"BuiltinOrAuto":{"builtin_data":"Tuple","parent_trait_refs":[{"Deduplicated":2346}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":245}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":356}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":231},"implied_trait_refs":[]},"kind":{"TraitType":[5,0]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":260,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[5,0]}}],"vtable":null},{"def_id":10,"item_meta":{"name":[{"Ident":["charon_corpus",0]},{"Ident":["bool_then_closure",0]},{"Ident":["closure",0]},{"Impl":{"Trait":10}}],"span":{"data":{"file_id":0,"beg":{"line":126,"col":11},"end":{"line":126,"col":19}},"generated_from_span":null},"source_text":"|| x + 1","attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":true,"opacity":"Transparent","lang_item":null},"impl_trait":{"id":2,"generics":{"regions":[],"types":[{"Deduplicated":5218}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":262,"generics":{"regions":[{"Var":{"Bound":[1,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[2,0]}}],"vtable":null},{"def_id":11,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":11}}],"span":{"data":{"file_id":6,"beg":{"line":2755,"col":0},"end":{"line":2755,"col":36}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":11,"generics":{"regions":[],"types":[{"Deduplicated":3736}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2755,"col":5},"end":{"line":2755,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[5236,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"HashConsedValue":[2770,{"Adt":{"id":{"Adt":7},"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}}}]}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7058,{"kind":{"TraitImpl":{"id":12,"generics":{"regions":[],"types":[{"Deduplicated":220}],"const_generics":[],"trait_refs":[{"Deduplicated":223}]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":2770},{"Deduplicated":1971}],"const_generics":[],"trait_refs":[]}}}}]},{"Deduplicated":223},{"Deduplicated":1973}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":188},"implied_trait_refs":[]},"kind":{"TraitType":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":1971},"implied_trait_refs":[]},"kind":{"TraitType":[11,1]}}],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":263,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[11,0]}},{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":25,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[11,1]}}],"vtable":null},{"def_id":12,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["option",0]},{"Impl":{"Trait":12}}],"span":{"data":{"file_id":6,"beg":{"line":2777,"col":0},"end":{"line":2777,"col":74}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":24,"generics":{"regions":[],"types":[{"Deduplicated":3736},{"Deduplicated":1971}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[{"index":0,"name":"T"}],"const_generics":[],"trait_clauses":[{"clause_id":0,"span":{"data":{"file_id":6,"beg":{"line":2777,"col":5},"end":{"line":2777,"col":6}},"generated_from_span":null},"origin":"WhereClauseOnImpl","trait_":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[]}}}}],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":5236},{"Deduplicated":1973}],"consts":[],"types":[],"methods":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":188}],"const_generics":[],"trait_refs":[{"Deduplicated":2055}]}},"kind":{"TraitMethod":[24,0]}}],"vtable":null},{"def_id":13,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":13}}],"span":{"data":{"file_id":19,"beg":{"line":62,"col":12},"end":{"line":62,"col":56}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":7,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"HashConsedValue":[2231,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[2230,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7060,{"kind":{"TraitImpl":{"id":14,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7061,{"kind":{"TraitImpl":{"id":15,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[5344,{"kind":{"BuiltinOrAuto":{"builtin_data":"Sized","parent_trait_refs":[{"HashConsedValue":[5343,{"kind":{"BuiltinOrAuto":{"builtin_data":"MetaSized","parent_trait_refs":[],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":1,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}}}}]}],"types":[]}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":0,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}}}}]},{"HashConsedValue":[7062,{"kind":{"TraitImpl":{"id":16,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[{"params":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"value":{"Deduplicated":5342},"implied_trait_refs":[]},"kind":{"TraitType":[7,0]}}],"methods":[],"vtable":null},{"def_id":14,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["marker",0]},{"Impl":{"Trait":14}}],"span":{"data":{"file_id":1,"beg":{"line":60,"col":25},"end":{"line":60,"col":62}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":2230},{"HashConsedValue":[7063,{"kind":{"TraitImpl":{"id":17,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":15,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["nonzero",0]},{"Impl":{"Trait":15}}],"span":{"data":{"file_id":19,"beg":{"line":55,"col":12},"end":{"line":55,"col":47}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":26,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":2230}],"consts":[],"types":[],"methods":[],"vtable":{"id":5,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},{"def_id":16,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":16}}],"span":{"data":{"file_id":53,"beg":{"line":17,"col":24},"end":{"line":17,"col":28}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":18,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":5343},{"HashConsedValue":[7064,{"kind":{"TraitImpl":{"id":18,"generics":{"regions":[],"types":[],"const_generics":[],"trait_refs":[]}}},"trait_decl_ref":{"regions":[],"skip_binder":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}}}}]}],"consts":[],"types":[],"methods":[],"vtable":null},{"def_id":17,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["clone",0]},{"Ident":["impls",0]},{"Impl":{"Trait":17}}],"span":{"data":{"file_id":25,"beg":{"line":612,"col":16},"end":{"line":612,"col":39}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":775}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":2231}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":304,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[8,0]}},null],"vtable":null},{"def_id":18,"item_meta":{"name":[{"Ident":["core",0]},{"Ident":["num",0]},{"Ident":["niche_types",0]},{"Impl":{"Trait":18}}],"span":{"data":{"file_id":53,"beg":{"line":17,"col":17},"end":{"line":17,"col":22}},"generated_from_span":null},"source_text":null,"attr_info":{"attributes":[],"inline":null,"rename":null,"public":false},"is_local":false,"opacity":"Foreign","lang_item":null},"impl_trait":{"id":8,"generics":{"regions":[],"types":[{"Deduplicated":5342}],"const_generics":[],"trait_refs":[]}},"generics":{"regions":[],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"implied_trait_refs":[{"Deduplicated":5344}],"consts":[],"types":[],"methods":[{"params":{"regions":[{"index":0,"name":null,"mutability":"Unknown"}],"types":[],"const_generics":[],"trait_clauses":[],"regions_outlive":[],"types_outlive":[],"trait_type_constraints":[]},"skip_binder":{"id":306,"generics":{"regions":[{"Var":{"Bound":[0,0]}}],"types":[],"const_generics":[],"trait_refs":[]}},"kind":{"TraitMethod":[8,0]}},null],"vtable":null}],"ordered_decls":[{"TraitDecl":{"NonRec":1}},{"TraitDecl":{"NonRec":0}},{"Type":{"NonRec":8}},{"Fun":{"NonRec":256}},{"Fun":{"NonRec":16}},{"Type":{"NonRec":7}},{"Fun":{"NonRec":17}},{"TraitDecl":{"NonRec":2}},{"Fun":{"NonRec":24}},{"TraitDecl":{"NonRec":25}},{"TraitDecl":{"NonRec":5}},{"Fun":{"NonRec":23}},{"TraitDecl":{"NonRec":4}},{"Fun":{"NonRec":258}},{"Fun":{"NonRec":259}},{"TraitImpl":{"NonRec":8}},{"Type":{"NonRec":10}},{"TraitDecl":{"NonRec":3}},{"Fun":{"NonRec":20}},{"Fun":{"NonRec":34}},{"Fun":{"NonRec":18}},{"Type":{"NonRec":9}},{"Fun":{"NonRec":261}},{"Fun":{"NonRec":25}},{"Fun":{"NonRec":26}},{"Type":{"NonRec":5}},{"Fun":{"NonRec":21}},{"Fun":{"NonRec":22}},{"Type":{"NonRec":6}},{"Fun":{"NonRec":15}},{"TraitImpl":{"NonRec":1}},{"Fun":{"NonRec":14}},{"Fun":{"NonRec":19}},{"Type":{"NonRec":0}},{"Fun":{"NonRec":0}},{"Fun":{"NonRec":1}},{"Fun":{"NonRec":2}},{"Fun":{"NonRec":3}},{"Type":{"NonRec":1}},{"Fun":{"NonRec":4}},{"Type":{"NonRec":2}},{"Fun":{"NonRec":5}},{"Fun":{"NonRec":6}},{"Fun":{"NonRec":7}},{"Type":{"NonRec":11}},{"Fun":{"NonRec":262}},{"TraitImpl":{"NonRec":10}},{"Fun":{"NonRec":260}},{"TraitImpl":{"NonRec":9}},{"Fun":{"NonRec":8}},{"Fun":{"NonRec":9}},{"Fun":{"NonRec":10}},{"Fun":{"NonRec":11}},{"Type":{"NonRec":3}},{"Type":{"NonRec":4}},{"Fun":{"NonRec":12}},{"Fun":{"NonRec":13}}]},"has_errors":false} \ No newline at end of file diff --git a/majit/charon-corpus/src/lib.rs b/majit/charon-corpus/src/lib.rs index 41bae65e249..71e80b8401a 100644 --- a/majit/charon-corpus/src/lib.rs +++ b/majit/charon-corpus/src/lib.rs @@ -31,6 +31,31 @@ pub fn branch_loop_sum(slice: &[i64], threshold: i64) -> i64 { acc } +// 2b. Iterator element kinds. `next()`'s payload carries one reference for +// a slice iterator (`core::slice::iter::Iter` yields `Option<&T>`) and none +// for a by-value one (`core::array::iter::IntoIter` yields `Option`), so +// the two spell the same `Option<&i64>` payload for different reasons: here +// the element is `&i64` both times, and only the first has a reference the +// iterator added. A frontend that peels unconditionally, or never, types one +// of the two into the wrong register bank. +#[inline(never)] +pub fn slice_of_refs_sum(slice: &[&i64]) -> i64 { + let mut acc: i64 = 0; + for r in slice { + acc += **r; + } + acc +} + +#[inline(never)] +pub fn array_of_refs_sum(refs: [&i64; 3]) -> i64 { + let mut acc: i64 = 0; + for r in refs { + acc += *r; + } + acc +} + // 3. Strategy dispatch (dict-strategy stand-in) pub enum Strategy { Empty, diff --git a/majit/majit-charon-reader/tests/corpus.rs b/majit/majit-charon-reader/tests/corpus.rs index 05058c5f256..b2740c92866 100644 --- a/majit/majit-charon-reader/tests/corpus.rs +++ b/majit/majit-charon-reader/tests/corpus.rs @@ -29,7 +29,10 @@ fn loads_fixture_corpus() { // + 2 for the host-registered callback table: `host_registry_dispatch` // and `host_registry_dispatch_optional`. `HostCallback` is a type alias, // not an item, so it contributes no body. - assert_eq!(local_count, 14, "14 local fns expected"); + // + // + 2 for the iterator element-kind pair, `slice_of_refs_sum` and + // `array_of_refs_sum`. + assert_eq!(local_count, 16, "16 local fns expected"); } #[test] diff --git a/majit/majit-translate/src/codewriter/assembler.rs b/majit/majit-translate/src/codewriter/assembler.rs index 8eda7d49f92..214dc796504 100644 --- a/majit/majit-translate/src/codewriter/assembler.rs +++ b/majit/majit-translate/src/codewriter/assembler.rs @@ -6968,7 +6968,7 @@ mod tests { /// alone. #[test] fn assemble_vable_arraylen_emits_the_rdd_to_i_wire_shape() { - use crate::flatten::flatten_graph; + use crate::flatten::{FlatOp, flatten_graph}; use crate::jtransform::{GraphTransformConfig, Transformer, VirtualizableFieldDescriptor}; use crate::model::{FieldDescriptor, FunctionGraph, OpKind, ValueType}; @@ -7026,7 +7026,7 @@ mod tests { let mut regallocs = regalloc::perform_all_register_allocations(&rewritten); let mut flat = flatten_graph(&rewritten, &mut regallocs); let mut asm = Assembler::new(); - let _ = asm.assemble(&mut flat, ®allocs); + let body = asm.assemble(&mut flat, ®allocs); assert!( asm.insns.contains_key("arraylen_vable/rdd>i"), @@ -7073,6 +7073,37 @@ mod tests { let word = crate::layout::target_word_size(); assert_eq!((*base_size, *itemsize, *len_offset), (word, word, Some(0))); assert!(is_array_of_pointers); + + // The pool order above only says which descr was minted first. What + // the decoder follows is the pair of indexes in the instruction's own + // operand bytes, so read them: `1B opcode + 1B vable_reg + 2B fdescr + + // 2B adescr + 1B dest`, each index little-endian. A swapped emission + // would still leave the pool in this order and still key + // `arraylen_vable/rdd>i`. + let op_index = flat + .insns + .iter() + .position(|flat_op| { + matches!(flat_op, FlatOp::Op(inner) + if matches!(inner.kind, OpKind::VableArrayLen { .. })) + }) + .expect("the flattened graph must carry the VableArrayLen"); + let offset = flat.insns_pos.as_ref().expect("assemble records insns_pos")[op_index]; + let wire = &body.code[offset..offset + 7]; + assert_eq!( + wire[0], asm.insns["arraylen_vable/rdd>i"], + "the instruction at its recorded position must be the vable arraylen" + ); + assert_eq!( + u16::from_le_bytes([wire[2], wire[3]]) as usize, + vable_at, + "the first descr operand must be the vable-array descr" + ); + assert_eq!( + u16::from_le_bytes([wire[4], wire[5]]) as usize, + array_at, + "the second descr operand must be the array descr" + ); } #[test] diff --git a/majit/majit-translate/src/codewriter/jtransform.rs b/majit/majit-translate/src/codewriter/jtransform.rs index 58736a536c1..7f862186240 100644 --- a/majit/majit-translate/src/codewriter/jtransform.rs +++ b/majit/majit-translate/src/codewriter/jtransform.rs @@ -990,6 +990,25 @@ impl<'a> Transformer<'a> { "link argument", ); } + // The catch-all behind the four positional routes. Registering a + // variable in `vable_array_vars` drops the `getfield` that defined + // it, so an operand the block kept and no rewrite replaced is a + // variable used and never defined; regalloc reports that against a + // register kind, not against the read that went missing. + // + // Nothing between here and regalloc prunes dead operations — + // `finalize_rewritten_graph_to_jitcode` goes straight to regalloc, + // flatten, assemble — so a surviving operand always reaches it. + // That is what makes this safe to assert rather than merely warn: + // it cannot fire on a graph that would otherwise have compiled. + for op in &block.operations { + let operands = crate::inline::op_variable_refs(&op.kind); + self.check_no_vable_array( + operands.iter(), + graph_name, + "surviving operation operand", + ); + } } // Upstream `rpython/translator/backendopt/canraise.py:25-47 @@ -1115,21 +1134,30 @@ impl<'a> Transformer<'a> { /// pass a green test while escaping by the one route that test did not /// look at. /// - /// `route` names which of the four the escape took. Upstream's + /// `route` names which of the five the escape took. Upstream's /// message does not carry it, and the extra line is a deliberate pyre - /// addition: the four call sites below share one panic body, this + /// addition: the five call sites below share one panic body, this /// function is small enough to be inlined into all of them in an /// optimised build, and the resulting backtrace then names whichever /// site the optimiser happened to keep. A misread frame sent a whole /// diagnosis round after a residual call for what was a link argument. /// Keep the upstream block verbatim above and add the route last. /// - /// The four routes are closed — the call sites are the only ones — - /// and each passes its own literal: `"link argument"`, - /// `"fused exitswitch operand"`, `"call argument"`, - /// `"setfield operand"` (`jtransform.py:912`, the base or the stored - /// value of a `setfield`; there is no `setarrayitem` site, because - /// that one is the array access the protocol exists to allow). + /// Four of the routes name a specific operand position, each passing + /// its own literal: `"link argument"`, `"fused exitswitch operand"`, + /// `"call argument"`, `"setfield operand"` (`jtransform.py:912`, the + /// base or the stored value of a `setfield`; there is no + /// `setarrayitem` site, because that one is the array access the + /// protocol exists to allow). + /// + /// The fifth, `"surviving operation operand"`, is the catch-all behind + /// them: every operand of every operation the block kept, whatever its + /// kind. It reports last and least precisely, and it is here because + /// an enumerated list of routes is the shape that let `_check_stack_index` + /// escape by the one route its test did not look at — the same reason + /// the paragraph above prefers a whole-graph assertion to a list of + /// escape hatches. A route the four do not name (a `getfield` on the + /// array pointer, say) reaches it. fn check_no_vable_array<'v>( &self, list: impl IntoIterator, @@ -4387,6 +4415,17 @@ impl<'a> Transformer<'a> { /// Returns `None` for any oopspec spelling this does not handle, so /// the caller falls through to the residual path /// (`jtransform.py:1796` raises `NotSupported`). + /// + /// No arm here checks `vable_array_vars`, and none is owed. Upstream + /// splits on `resizable`: the `do_fixed_list_len/getitem/setitem` arms + /// take a `lltype.GcArray` receiver — which is what a virtualizable array + /// field holds — and so open with that check, while the + /// `do_resizable_list_*` arms take a `GcStruct` and do not. Every + /// spelling below is of the resizable family, its receiver a + /// `W_ListObject`. pyre reaches a fixed array through + /// `getarrayitem` / `setarrayitem` / `getarraysize` instead, which carry + /// the check in their own dispatch arms and emit the same three + /// instructions the fixed arms do. fn _handle_list_call( &mut self, oopspec_name: &str, @@ -8638,6 +8677,122 @@ mod tests { ); } + /// An escape by a route the four positional checks do not name must + /// still be caught, and named, before regalloc sees it. + /// + /// The array pointer's defining read is dropped at registration, so the + /// three rewriting consumers are the only ones that may follow it. A + /// `getfield` on the pointer itself is none of them and is none of the + /// four enumerated escapes either — it is not a call argument, a setfield + /// operand, a link argument or a fused exitswitch operand. It reaches + /// the catch-all, which is the whole point of having one: the four + /// positional checks are an enumeration, and an enumeration is what an + /// unforeseen route walks past. + /// + /// Without it the symptom is one variable used and never defined, + /// surfacing in regalloc against a register kind rather than against the + /// read that went missing. + #[test] + #[should_panic(expected = "Escaped via: surviving operation operand")] + fn a_vable_array_escape_by_an_unenumerated_route_is_named() { + let mut graph = FunctionGraph::new("test"); + let base_var = graph.alloc_value_var(); + let array_var = graph + .push_op_var( + graph.startblock, + OpKind::FieldRead { + base: base_var, + field: crate::model::FieldDescriptor::new( + "locals_stack_w", + Some("Frame".into()), + ), + ty: ValueType::Ref(None), + pure: false, + }, + true, + ) + .unwrap(); + graph.push_op_var( + graph.startblock, + OpKind::FieldRead { + base: array_var, + field: crate::model::FieldDescriptor::new("header", Some("SomeArray".into())), + ty: ValueType::Int, + pure: false, + }, + true, + ); + graph.set_return(graph.startblock, None); + + let config = GraphTransformConfig { + vable_arrays: vec![VirtualizableFieldDescriptor::new_with_arraydescr( + "locals_stack_w", + Some("Frame".into()), + 0, + 8, + true, + )], + ..Default::default() + }; + transform_graph(&graph, &config); + } + + /// The scalar-field half of the same gate. Both virtualizable arms of + /// `rewrite_op_getfield` are gated, so the flag has to be exercised on + /// both: [`a_vable_array_read_is_kept_when_virtualizable_lowering_is_off`] + /// covers the array arm, and this one the field arm. + /// + /// The stakes differ. The array arm drops the read outright, so an + /// ungated drop leaves regalloc an undefined variable. The field arm + /// only rewrites in place, so the flag decides whether the graph carries + /// a `VableFieldRead` no lowering will consume — quieter, and pinned here + /// so the two arms cannot drift apart. + #[test] + fn a_vable_field_read_is_kept_when_virtualizable_lowering_is_off() { + let mut graph = FunctionGraph::new("test"); + let frame_var = graph.alloc_value_var(); + graph.push_inputarg_var(graph.startblock, frame_var.clone()); + let field_var = graph + .push_op_var( + graph.startblock, + OpKind::FieldRead { + base: frame_var, + field: crate::model::FieldDescriptor::new("next_instr", Some("Frame".into())), + ty: ValueType::Int, + pure: false, + }, + true, + ) + .unwrap(); + graph.set_return(graph.startblock, None); + + let config = GraphTransformConfig { + lower_virtualizable: false, + vable_fields: vec![VirtualizableFieldDescriptor::new( + "next_instr", + Some("Frame".into()), + 0, + )], + ..Default::default() + }; + let result = transform_graph(&graph, &config); + assert_eq!(result.vable_rewrites, 0); + let ops = &result.graph.block(graph.startblock).operations; + assert!( + !ops.iter() + .any(|op| matches!(op.kind, OpKind::VableFieldRead { .. })), + "with lowering off the read must stay a plain FieldRead, got {:?}", + ops.iter().map(|op| &op.kind).collect::>(), + ); + assert!( + ops.iter() + .any(|op| matches!(&op.kind, OpKind::FieldRead { .. }) + && op.result.as_ref() == Some(&field_var)), + "with lowering off the field read must still be defined, got {:?}", + ops.iter().map(|op| &op.kind).collect::>(), + ); + } + /// `jtransform.py:808-817 rewrite_op_getarraysize` — the third /// consumer of `vable_array_vars`. /// diff --git a/majit/majit-translate/src/front/mir.rs b/majit/majit-translate/src/front/mir.rs index 6948821084c..ee3d730dda3 100644 --- a/majit/majit-translate/src/front/mir.rs +++ b/majit/majit-translate/src/front/mir.rs @@ -9214,17 +9214,25 @@ impl<'a> Lowering<'a> { // recorded kind is the item's own, the way `ll_listnext` hands // back the list's item repr rather than a pointer to it — and // only that one, so an element that is itself a reference stays - // reference-typed. An unreadable shape records `Ref(None)` — the - // answer the fold assumed unconditionally before this was - // carried, so an unreadable type keeps today's behaviour instead - // of inventing a new one. + // reference-typed. Which iterator this is decides whether there + // is a reference to peel at all: the receiver names the iterator + // ADT, and a by-value one yields the element directly. An + // unreadable shape records `Ref(None)` — the answer the fold + // assumed unconditionally before this was carried, so an + // unreadable type keeps today's behaviour instead of inventing a + // new one. + let iterator_added_a_reference = first_arg_ty + .as_ref() + .and_then(|receiver| self.tyref_ref_adt_path(receiver)) + .is_some_and(|path| iterator_adds_a_reference(&path)); let item_ty = crate::front::result_exc::tyref_option_payload(&call.dest.ty, self.llbc) .and_then(|payload| { let body = match &payload { TyRef::Inline { value: (_, v) } | TyRef::Other(v) => v, TyRef::Dedup { id } => self.llbc.dedup_body(*id)?, }; - let item = iterator_payload_element(body, self.llbc)?; + let item = + iterator_payload_element(body, self.llbc, iterator_added_a_reference)?; serde_json::from_value::(item.clone()).ok() }) .map(|ty| tyref_to_value_type(&ty, self.llbc)) @@ -11428,6 +11436,15 @@ impl<'a> Lowering<'a> { } } + /// The full name path of the ADT behind a signature [`TyRef`], peeling + /// the same wrappers [`Self::tyref_ref_adt_def_id`] does — a desugared + /// `it.next()` passes its iterator as `&mut Iter<'_, T>`, so the receiver + /// reaches [`iterator_adds_a_reference`] behind one reference. + fn tyref_ref_adt_path(&self, ty: &TyRef) -> Option { + let id = self.tyref_ref_adt_def_id(ty)?; + Some(self.llbc.type_by_id(id)?.item_meta.name_path()) + } + /// Peel `Ref` / `RawPtr` wrappers (through dedup / hash-cons /// indirections) to the pointee as an owned [`TyRef`] — the by-value shape /// the `Option` owner resolvers expect. Returns `ty` itself (cloned) when @@ -16833,23 +16850,48 @@ fn strip_ty_indirections<'l>( None } +/// Does the iterator ADT named by `path` hand back a reference *it* added, +/// rather than the element itself? +/// +/// `core::slice::iter::Iter<'a, T>` yields `Option<&'a T>`: that `&` is the +/// iterator's, and peeling it is what leaves `&[i64]`'s element an `i64`. +/// The by-value iterators [`Lowering::is_concrete_iter_constructor`] admits +/// alongside it — `alloc::vec::into_iter::IntoIter` for `Vec` and +/// `core::array::iter::IntoIter` for `[T; N]` — yield `Option` +/// instead, so their payload is already the element and the same peel would +/// strip a reference the element owns. +/// +/// Recognition is positive-only: an unlisted or unreadable receiver does not +/// peel, which leaves a `&T` payload typed `Ref` — the answer the fold +/// assumed unconditionally before any element type was carried. +fn iterator_adds_a_reference(path: &str) -> bool { + matches!( + path, + "core::slice::iter::Iter" | "core::slice::iter::IterMut" + ) +} + /// The element type behind an iterator's `next()` payload. /// -/// A slice iterator yields `Option<&T>`, so exactly one reference level -/// belongs to the iterator and the rest belongs to the element: over -/// `&[i64]` the payload is `&i64` and the element is `i64`, but over -/// `&[&i64]` it is `&&i64` and the element is `&i64` — a pointer, which -/// belongs in the Ref bank. Peeling every `Ref` would put that pointer in -/// the integer bank. +/// When the iterator added a reference ([`iterator_adds_a_reference`]), +/// exactly one reference level belongs to it and the rest belongs to the +/// element: over `&[i64]` the payload is `&i64` and the element is `i64`, +/// but over `&[&i64]` it is `&&i64` and the element is `&i64` — a pointer, +/// which belongs in the Ref bank. Peeling every `Ref` would put that +/// pointer in the integer bank. /// -/// A by-value iterator (`[i64; N]`, `Vec`) hands back the item itself -/// with no reference to peel, so a payload that is not a `Ref` is already -/// the element. +/// When it did not, the payload is the element already, and peeling would +/// commit the mirror-image error: `Vec<&i64>::into_iter()` yields +/// `Option<&i64>`, whose `&i64` is the element itself. fn iterator_payload_element<'l>( payload: &'l serde_json::Value, llbc: &'l Llbc, + iterator_adds_a_reference: bool, ) -> Option<&'l serde_json::Value> { let node = strip_ty_indirections(payload, llbc)?; + if !iterator_adds_a_reference { + return Some(node); + } let Some(arr) = node.get("Ref").and_then(serde_json::Value::as_array) else { return Some(node); }; diff --git a/majit/majit-translate/tests/test_mir_frontend.rs b/majit/majit-translate/tests/test_mir_frontend.rs index 9fde5affc56..a2af112d56a 100644 --- a/majit/majit-translate/tests/test_mir_frontend.rs +++ b/majit/majit-translate/tests/test_mir_frontend.rs @@ -483,6 +483,47 @@ fn branch_loop_sum_next_yields_an_int_element() { ); } +/// The element `[__iter_next]` yields is a `&i64` for both of these, and the +/// two get there differently: `slice_of_refs_sum` iterates `&[&i64]`, whose +/// `core::slice::iter::Iter` yields `Option<&&i64>` — one reference the +/// iterator added over one the element owns — while `array_of_refs_sum` +/// iterates `[&i64; 3]` by value, whose `core::array::iter::IntoIter` yields +/// `Option<&i64>` with no reference of its own. +/// +/// So neither a blanket peel nor a blanket keep answers both: peeling every +/// reference types the first element `Int`, and peeling one unconditionally +/// types the second `Int`. Either way a pointer lands in the integer +/// register bank, which is why the decision reads the receiver's iterator +/// ADT rather than the payload's shape alone. +#[test] +fn a_reference_element_stays_a_reference_through_either_iterator() { + use majit_translate::model::{CallTarget, OpKind, ValueType}; + let llbc = load_corpus(); + + for name in ["slice_of_refs_sum", "array_of_refs_sum"] { + let graph = lower_function(llbc, name).expect("lowering"); + let element_types: Vec = graph + .blocks + .iter() + .flat_map(|b| &b.operations) + .filter_map(|op| match &op.kind { + OpKind::Call { + target: CallTarget::FunctionPath { segments }, + result_ty, + .. + } if segments.len() == 1 && segments[0] == "__iter_next" => Some(result_ty.clone()), + _ => None, + }) + .collect(); + + assert_eq!( + element_types, + vec![ValueType::Ref(None)], + "{name}: a `&i64` element is a pointer and must keep the ref bank", + ); + } +} + /// `branch_loop_sum`'s `for &v in slice` lifts to the native `iter` + /// `[__iter_next]` ops: Layer 3 of the iterator vertical replaces the /// residual `Iterator::next()` call (an unregistered callee that would diff --git a/majit/majit-translate/tests/test_unroll_safe_inventory.rs b/majit/majit-translate/tests/test_unroll_safe_inventory.rs index 6966632f71a..71b00366e67 100644 --- a/majit/majit-translate/tests/test_unroll_safe_inventory.rs +++ b/majit/majit-translate/tests/test_unroll_safe_inventory.rs @@ -73,6 +73,15 @@ fn harvested_unroll_safe() -> Option> { .map(|(path, _)| path.clone()) .collect(); paths.sort(); + if !paths.iter().any(|p| leaf(p) == CONTROL) { + eprintln!( + "skipping: {INTERPRETER_LLBC} carries no `unroll_safe` on {CONTROL}, \ + so it predates the hint inventory entirely; re-extract to exercise \ + this test (harvested: {paths:?})" + ); + return None; + } + // `REVIEWED_UNROLL_SAFE` and the subset check below both match on the // leaf, on the stated assumption that leaves are unambiguous across the // interpreter. Nothing else verifies that. If an unreviewed function @@ -91,14 +100,6 @@ fn harvested_unroll_safe() -> Option> { ); } } - if !paths.iter().any(|p| leaf(p) == CONTROL) { - eprintln!( - "skipping: {INTERPRETER_LLBC} carries no `unroll_safe` on {CONTROL}, \ - so it predates the hint inventory entirely; re-extract to exercise \ - this test (harvested: {paths:?})" - ); - return None; - } Some(paths) } From 4af3cc1354efacbabd56ea9e393fbf30baa3594d Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 19:45:23 +0900 Subject: [PATCH 09/10] majit: cover the untested virtualizable abort paths `VableArrayIndexNotConcrete` and `GuardSnapshotVableUntyped` had no tests. Neither fires on the synth corpus (0 across the 374 fixtures that trace, where `VableEscapedDuringResidualCall` takes 123). - `array_vable_handlers_with_unpinned_index_surface_index_not_concrete` drives `getarrayitem_vable_i` / `setarrayitem_vable_i` with a seeded vable ref and an index register holding no concrete value. - `an_untyped_virtualizable_box_is_not_snapshot_buildable` pins `TraceCtx::vable_snapshot_buildable` over an absent box list, an all-typed list, and an untyped entry in each of the two positions `build_vable_snapshot_boxes` reads separately. - `build_vable_snapshot_boxes_panics_on_an_untyped_{identity,entry}` pin the two `.expect()` calls that predicate keeps unreachable. Assisted-by: Claude --- .../majit-metainterp/src/pyjitpl/dispatch.rs | 17 ++++ majit/majit-metainterp/src/trace_ctx.rs | 33 +++++++ .../src/jitcode_dispatch/tests.rs | 95 +++++++++++++++++++ 3 files changed, 145 insertions(+) diff --git a/majit/majit-metainterp/src/pyjitpl/dispatch.rs b/majit/majit-metainterp/src/pyjitpl/dispatch.rs index 5ca874b565c..271d0f5f993 100644 --- a/majit/majit-metainterp/src/pyjitpl/dispatch.rs +++ b/majit/majit-metainterp/src/pyjitpl/dispatch.rs @@ -13462,4 +13462,21 @@ mod tests { )] ); } + + /// The two panics `TraceCtx::vable_snapshot_buildable` exists to keep + /// unreachable. Its caller reports a false answer as + /// `GuardSnapshotVableUntyped` and aborts to interpretation; these pin + /// what that abort is worth, one per untyped position, since the + /// identity slot and the rest are read by separate arms above. + #[test] + #[should_panic(expected = "virtualizable identity must be typed")] + fn build_vable_snapshot_boxes_panics_on_an_untyped_identity() { + build_vable_snapshot_boxes(&[majit_ir::OpRef::int_op(3), majit_ir::OpRef::NONE]); + } + + #[test] + #[should_panic(expected = "virtualizable_boxes entry must be typed")] + fn build_vable_snapshot_boxes_panics_on_an_untyped_entry() { + build_vable_snapshot_boxes(&[majit_ir::OpRef::NONE, majit_ir::OpRef::ref_op(7)]); + } } diff --git a/majit/majit-metainterp/src/trace_ctx.rs b/majit/majit-metainterp/src/trace_ctx.rs index 7fb870d949c..147cf3addc1 100644 --- a/majit/majit-metainterp/src/trace_ctx.rs +++ b/majit/majit-metainterp/src/trace_ctx.rs @@ -6539,4 +6539,37 @@ mod tests { ); } } + + /// `vable_snapshot_buildable` is the precondition the walker checks + /// before capturing a resume snapshot; a false answer is reported as + /// `GuardSnapshotVableUntyped` and aborts to interpretation. What it + /// guards is `build_vable_snapshot_boxes`, whose two `.expect()` calls + /// panic on an untyped entry — see + /// `build_vable_snapshot_boxes_panics_on_an_untyped_entry`, which pins + /// the other half of the pair. + /// + /// `OpRef::ty()` answers `None` for exactly `None` and `TempVar` + /// (resoperation.rs), so an unseeded slot is what makes a box untyped. + #[test] + fn an_untyped_virtualizable_box_is_not_snapshot_buildable() { + let mut ctx = TraceCtx::for_test(0); + + // No virtualizable at all: vacuously buildable, so a walk that never + // seeded `virtualizable_boxes` must not take the abort. + assert!(ctx.virtualizable_boxes.is_none()); + assert!(ctx.vable_snapshot_buildable()); + + // Every slot typed, identity last: buildable. + let identity = OpRef::ref_op(7); + ctx.virtualizable_boxes = Some(vec![OpRef::int_op(3), identity]); + assert!(ctx.vable_snapshot_buildable()); + + // A non-identity slot left unseeded. + ctx.virtualizable_boxes = Some(vec![OpRef::NONE, identity]); + assert!(!ctx.vable_snapshot_buildable()); + + // The identity slot itself left unseeded. + ctx.virtualizable_boxes = Some(vec![OpRef::int_op(3), OpRef::NONE]); + assert!(!ctx.vable_snapshot_buildable()); + } } diff --git a/pyre/pyre-jit-trace/src/jitcode_dispatch/tests.rs b/pyre/pyre-jit-trace/src/jitcode_dispatch/tests.rs index bff995873ef..da82d7acf74 100644 --- a/pyre/pyre-jit-trace/src/jitcode_dispatch/tests.rs +++ b/pyre/pyre-jit-trace/src/jitcode_dispatch/tests.rs @@ -904,6 +904,101 @@ fn array_vable_handlers_with_none_obj_surface_vable_box_not_seeded() { } } +/// A seeded vable whose index register carries no concrete value must abort +/// to `VableArrayIndexNotConcrete`. +/// +/// `pyjitpl.py _get_arrayitem_vable_index` reaches the slot through +/// `indexbox.getint()` after `implement_guard_value(indexbox, pc)`, so the +/// index is a constant by the time the slot is chosen. pyre promotes the same +/// way (`walker_promote_vable_array_index`) but has to read the concrete value +/// out of the walker first, and an `OpRef` with no recorded concrete cannot +/// supply one — the array slot would otherwise be picked from a value the +/// trace never pinned. +/// +/// The abort itself never fires on the synth corpus (measured: 0 across the +/// 374 fixtures that trace, where `VableEscapedDuringResidualCall` takes 123). +/// That is the reason to pin it rather than not: nothing else would notice if +/// a refactor made this path unreachable, or made it fire where the promote +/// should have carried the index. +#[test] +fn array_vable_handlers_with_unpinned_index_surface_index_not_concrete() { + // operand 0 (the box) at code[pc+1], operand 1 (the index) at code[pc+2]. + let code = [0u8, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00]; + for (key, opname, argcodes) in [ + ( + "getarrayitem_vable_i/riXdd>i", + "getarrayitem_vable_i", + "riXdd>i", + ), + ( + "setarrayitem_vable_i/riXdd", + "setarrayitem_vable_i", + "riXdd", + ), + ] { + let descr_pool: Vec = Vec::new(); + let mut tc = fresh_trace_ctx(); + // Ref reg 0 is seeded, so the `VableBoxNotSeeded` guard above lets this + // through; int reg 1 holds an `OpRef` the walker never gave a concrete. + let mut regs_r = vec![OpRef::input_arg_ref(0)]; + let mut regs_i = vec![OpRef::NONE, OpRef::NONE]; + let session = std::cell::RefCell::new(WalkSession::default()); + let mut wc = WalkContext { + callee_shadow: None, + inline_callee_consts: None, + fbw_mode: test_fbw_mode(), + session: &session, + registers_r: &mut regs_r, + registers_i: &mut regs_i, + registers_f: &mut [], + concrete_registers_r: &mut [], + concrete_registers_i: &mut [], + descr_refs: &descr_pool, + trace_ctx: &mut tc, + is_top_level: true, + sub_jitcode_lookup: &no_sub_jitcodes, + last_exc_value: None, + last_exc_value_concrete: ConcreteValue::Null, + entry_py_pc: EntryPyPc::Py(0), + outer_resume_marker_jit_pc: None, + outer_jitcode_index: 0, + raw_descrs: RawDescrPool::Global, + is_authoritative_executor: false, + outer_active_boxes: Vec::new(), + pending_guard_snapshot_error: None, + vstack_boxes: Vec::new(), + vstack_depth: 0, + vstack_cur_pypc: 0, + vstack_valid: false, + vstack_last_ref: OpRef::NONE, + vstack_reorder_ceiling: u32::MAX, + vstack_reorder_saved: None, + vstack_handler_landing_py: None, + live_before_jit_pc: usize::MAX, + live_after_jit_pc: usize::MAX, + }; + let op = DecodedOp { + key, + opname, + argcodes, + pc: 0, + next_pc: code.len(), + }; + let result = match opname { + "getarrayitem_vable_i" => getarrayitem_vable_via_metainterp(&code, &op, &mut wc, 'i'), + "setarrayitem_vable_i" => setarrayitem_vable_via_metainterp(&code, &op, &mut wc, 'i'), + _ => unreachable!(), + }; + assert!( + matches!( + result, + Err(DispatchError::VableArrayIndexNotConcrete { pc: 0, .. }) + ), + "{opname} must abort VableArrayIndexNotConcrete on an unpinned index, got {result:?}", + ); + } +} + /// `_opimpl_getarrayitem_vable` (pyjitpl.py:1218-1230) and /// `_opimpl_setarrayitem_vable` (:1236-1247) take the /// `_nonstandard_virtualizable` decision FIRST, and their non-standard branch From 2e8f940953f12a19843518e208178aef55567840 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Thu, 20 Aug 2026 22:41:37 +0900 Subject: [PATCH 10/10] majit: drop the optimizer's virtualizable array-element seeding MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both loop-close arms carry the tracer's live `virtualizable_boxes` shadow into the JUMP as `[reds..., virtualizable_boxes[..-1]]`: the macro state-field JIT through `JitState::collect_jump_args_with_boxes`, PyFrame through `jitcode_dispatch::append_virtualizable_boxes`. PyFrame reaches the second only — nothing under `pyre/` produces `TraceAction::CloseLoop`, so its `collect_jump_args_with_boxes` override is not called in production; note that where the override is defined. `elements_carried_via_shadow` classified PyFrame as not shadow-carried and kept `track_array_elements` on for it, so `VirtualizableTracker::init` seeded element state from the trace-entry input args. Remove that seeding, along with `VirtualizableConfig::track_array_elements`, `::array_lengths` and the length patch in `current_virtualizable_optimizer_config`. The standard-path read answers from the shadow and records no op (`vable_getarrayitem_*_checked`, pyjitpl.py:1170-1184), and the tracer updates the shadow through `set_virtualizable_entry_at` without recording one, so a seeded element box had nothing to fold against and could go stale. Measured before removal: check.py dynasm 434/434, zero jit-stats counters moved. Replace the three tests that pinned the removed length assertion with one that pins what `ensure_setup` still owes — the identity `PtrInfo::Virtualizable` install — and state in the tracker's doc which parts remain and what retiring them would require. Also check `set_virtualizable_entry_at`'s documented precondition against `virtualizable_slot_type` instead of only stating it: a non-Ref value in a Ref slot decodes to NULL through `value_as_ref_bits`. Assisted-by: Claude --- .../src/optimizeopt/virtualize.rs | 234 ++++-------------- majit/majit-metainterp/src/pyjitpl.rs | 2 - majit/majit-metainterp/src/trace_ctx.rs | 18 ++ majit/majit-metainterp/src/virtualizable.rs | 35 +-- pyre/pyre-jit-trace/src/state.rs | 10 + 5 files changed, 74 insertions(+), 225 deletions(-) diff --git a/majit/majit-metainterp/src/optimizeopt/virtualize.rs b/majit/majit-metainterp/src/optimizeopt/virtualize.rs index 32514c2b0bb..52cee57fcc2 100644 --- a/majit/majit-metainterp/src/optimizeopt/virtualize.rs +++ b/majit/majit-metainterp/src/optimizeopt/virtualize.rs @@ -46,13 +46,6 @@ pub(crate) struct VirtualizableConfig { /// Same role as `static_field_descrs`, but for the array-pointer /// fields on the virtualizable object. pub array_field_descrs: Vec, - /// Trace-entry lengths of array fields, parallel to `array_field_offsets`. - /// - /// Standard virtualizable traces carry array elements in the input box - /// layout; the optimizer needs the concrete lengths to map those input - /// args back into VirtualizableFieldState without falling back to raw - /// heap reads. - pub array_lengths: Vec, /// Number of input slots between `OpRef::input_arg_ref(0)` (frame) and the first vable /// scalar slot. Equals `JitDriverStaticData::num_reds() - 1` after the /// frame is excluded — typically `NUM_EXTRA_REDS` from the @@ -99,24 +92,6 @@ pub(crate) struct VirtualizableConfig { /// before it consults this field at all, so a tracker is still installed /// there with this set to `None`. pub identity_input_index: Option, - /// Whether the tracker seeds array-element state from the trace-entry - /// input args (`init`'s array loop). - /// - /// `true` (PyFrame and the optimizer unit tests) keeps the legacy - /// stopgap behavior: array elements are mapped from input args into - /// `VirtualizableFieldState.arrays`, and the loop boundary expands the - /// virtualizable back into those element slots. - /// - /// `false` (the macro state-field JIT) suppresses that seeding. The - /// state-field tracer carries `[int; virt]` elements through the live - /// `virtualizable_boxes` shadow and splices the symbolically-updated - /// boxes straight into the loop JUMP (`collect_jump_args_with_boxes`, - /// pyjitpl.py:2982-2989). Re-seeding from the trace-entry input args - /// would thread stale loop-entry boxes alongside the fresh shadow boxes, - /// double-counting the array at the loop boundary. The identity - /// `PtrInfo::Virtualizable` is still installed (so the base is not - /// forced); only the per-element seeding is skipped. - pub track_array_elements: bool, } /// JitVirtualRef field slot indices. @@ -130,20 +105,31 @@ pub(crate) const VREF_FORCED_FIELD_INDEX: u32 = 1; /// Size descriptor index for the JitVirtualRef struct. const VREF_SIZE_DESCR_INDEX: u32 = 0x7F10; -/// TODO: Virtualizable field tracking in the optimizer. +/// TODO: Virtualizable field tracking in the optimizer — pyre-only, being +/// retired. /// /// RPython does NOT track virtualizable field values in the optimizer. /// Field tracking happens during tracing (`pyjitpl.py:virtualizable_boxes`), /// not in the optimization pipeline. The optimizer only removes /// `COND_CALL(OS_JIT_FORCE_VIRTUALIZABLE)` when the target is virtual. /// -/// Pyre's tracing model carries virtualizable fields as trace input args -/// (`OpRef::input_arg_ref`), and the optimizer maps them via -/// `VirtualizableFieldState`. This exists because pyre doesn't yet have -/// RPython's `virtualizable_boxes` model in the metainterp. +/// The tracing layer now has that model — `TraceCtx::virtualizable_boxes` is +/// the live shadow, and both loop-close arms carry it into the JUMP — so the +/// array-element half of this tracker is gone: `init` no longer seeds element +/// state from the trace-entry input args, because the standard-path read +/// answers from the shadow and records no op for a fold to match. +/// +/// What is still here, and what retiring the rest costs: /// -/// If pyre's tracing layer grows RPython's `virtualizable_boxes` model, this -/// optimizer-side tracker should no longer be needed. +/// - the identity `PtrInfo::Virtualizable` install. Not a deviation to +/// remove — it is what keeps the base from being forced, which is the one +/// virtualizable job upstream's optimizer does have. +/// - the STATIC field map (`VirtualizableFieldState.fields`), still seeded +/// from input args. Retiring it needs the same argument the array half +/// got: that no recorded op reads a static vable field on the standard +/// path. That has not been established. +/// - `is_standard_ref` / `mirror_setarrayitem` / `invalidate_array`, which +/// exist to keep the static map honest and follow it. pub(crate) struct VirtualizableTracker { config: VirtualizableConfig, needs_setup: bool, @@ -308,76 +294,19 @@ impl VirtualizableTracker { flat_input_idx += 1; } - // The state-field JIT carries array elements through the live - // `virtualizable_boxes` shadow into the loop JUMP, so seeding element - // state from the trace-entry input args here would double-count them - // at the loop boundary. Skip the per-element loop in that mode; the - // empty `PtrInfo::Virtualizable` installed below still keeps the - // identity base from being forced. - // The zip below is silent about a config that declares array - // fields but carries no lengths: it runs zero times, leaves - // `state.arrays` empty, and every later `tracked_array_element` - // misses. `to_optimizer_config` builds exactly that state and - // relies on its caller to patch the lengths in, so name the - // unpatched config here rather than letting it read as "this - // trace had no array elements". - // The zip below pairs `array_field_offsets` with `array_lengths`, - // so a short `array_lengths` does not fail — it silently drops the - // tail, seeding some arrays and leaving the rest untracked. An - // empty vector is only the loudest case of that, so require the - // whole invariant rather than non-emptiness. - debug_assert!( - !self.config.track_array_elements - || self.config.array_lengths.len() == self.config.array_field_offsets.len(), - "array-tracking config reached the optimizer with {} array_lengths for {} \ - array fields; the zip below would pair only {} of them and leave the rest \ - unseeded, so `tracked_array_element` can never hit for those — see \ - MetaInterp::current_virtualizable_optimizer_config", - self.config.array_lengths.len(), - self.config.array_field_offsets.len(), - self.config - .array_lengths - .len() - .min(self.config.array_field_offsets.len()), - ); - if self.config.track_array_elements { - for (array_idx, (&_offset, &length)) in self - .config - .array_field_offsets - .iter() - .zip(self.config.array_lengths.iter()) - .enumerate() - { - let descr_for_slot = self.config.array_field_descrs.get(array_idx).cloned(); - let field_idx = descr_for_slot - .as_ref() - .and_then(|d| d.as_field_descr()) - .map(|fd| fd.index_in_parent() as u32) - .unwrap_or((1 + num_static + array_idx) as u32); - if let Some(descr) = descr_for_slot { - set_field_descr(&mut state.field_descrs, field_idx, descr); - } - - let mut elements = Vec::with_capacity(length); - for _ in 0..length { - if flat_input_idx >= ctx.num_inputs() { - break; - } - let slot_tp = ctx - .inputarg_type_at(flat_input_idx) - .unwrap_or(majit_ir::Type::Ref); - elements.push(OpRef::input_arg_typed(flat_input_idx as u32, slot_tp)); - flat_input_idx += 1; - } - if !elements.is_empty() { - let elements: Vec = elements - .into_iter() - .map(|r| ctx.materialize_operand_at(r)) - .collect(); - state.arrays.push((array_idx as u32, elements)); - } - } - } + // Array elements are deliberately not seeded. Every layout carries + // them into the loop JUMP through the tracer's live + // `virtualizable_boxes` shadow — the macro state-field JIT via + // `JitState::collect_jump_args_with_boxes`, PyFrame via + // `jitcode_dispatch::append_virtualizable_boxes` — and the tracer + // updates that shadow through `set_virtualizable_entry_at` without + // recording an op, so a seeded entry box is invisible to + // `mirror_setarrayitem` and goes stale. The standard-path read + // records no op either (`TraceCtx::vable_getarrayitem_*_checked` + // answers from the shadow, pyjitpl.py:1170-1184), so there is + // nothing for a seeded element to fold against in the first place. + // Measured before removal: check.py dynasm 434/434 with zero + // jit-stats counters moved. } let b = ctx.materialize_operand_at(identity_ref); @@ -3521,10 +3450,8 @@ mod tests { array_field_offsets: vec![8], array_item_types: vec![Type::Ref], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }, ))); let forced = opt.force_box(OpRef::input_arg_ref(0), &mut ctx); @@ -3553,10 +3480,8 @@ mod tests { array_field_offsets: vec![8], array_item_types: vec![Type::Int], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -3654,10 +3579,8 @@ mod tests { array_field_offsets: vec![], array_item_types: vec![], array_field_descrs: vec![], - array_lengths: vec![], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -3704,10 +3627,8 @@ mod tests { array_field_offsets: vec![], array_item_types: vec![], array_field_descrs: vec![], - array_lengths: vec![], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -3736,10 +3657,8 @@ mod tests { array_field_offsets: vec![], array_item_types: vec![], array_field_descrs: vec![], - array_lengths: vec![], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -3756,43 +3675,13 @@ mod tests { assert!(matches!(result, OptimizationResult::PassOn)); } - /// A config that declares an array field but no length is the state - /// `to_optimizer_config` hands out before its caller patches the lengths - /// in. It has to be built by hand — no production path produces it, - /// because both writers of `TraceCtx::virtualizable_boxes` set the - /// lengths in the same statement — and the seeding loop would otherwise - /// absorb it silently, leaving every `tracked_array_element` a miss that - /// reads as "this trace had no array elements". + /// A config that declares an array field carries no lengths at all now: + /// the element seeding that needed them is gone, so the shape that used + /// to trip the length assertion is just an ordinary config. It still has + /// to install the identity `PtrInfo::Virtualizable`, which is the only + /// thing `ensure_setup` still owes a virtualizable with arrays. #[test] - #[should_panic(expected = "array_lengths for")] - fn array_tracking_config_without_lengths_is_named_not_absorbed() { - let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); - let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { - static_field_offsets: vec![], - static_field_types: vec![], - static_field_descrs: vec![], - array_field_offsets: vec![48], - array_item_types: vec![Type::Ref], - array_field_descrs: vec![], - array_lengths: vec![], - vable_input_offset: 0, - identity_input_index: Some(0), - track_array_elements: true, - }); - pass.setup(); - if let Some(ref mut vt) = pass.vable { - vt.ensure_setup(&mut ctx); - } - } - - /// A length vector shorter than the field list is the case a - /// non-emptiness check cannot see: `zip` pairs what it can and drops the - /// rest, so the first array is seeded, the second is not, and - /// `tracked_array_element` misses for it exactly as if no config had - /// arrived at all. - #[test] - #[should_panic(expected = "array_lengths for")] - fn a_partial_array_lengths_vector_is_named_not_truncated() { + fn an_array_declaring_config_needs_no_lengths_and_still_installs_the_identity() { let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { static_field_offsets: vec![], @@ -3801,45 +3690,20 @@ mod tests { array_field_offsets: vec![48, 56], array_item_types: vec![Type::Ref, Type::Ref], array_field_descrs: vec![], - array_lengths: vec![4], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); if let Some(ref mut vt) = pass.vable { vt.ensure_setup(&mut ctx); } - } - - /// The same shape with `track_array_elements` off is the state-field - /// macro JIT's, which carries elements through the live - /// `virtualizable_boxes` shadow instead; and a config with no array field - /// at all has nothing to seed. Neither is the unpatched config, so - /// neither may trip the assertion above. - #[test] - fn a_shadow_carried_or_arrayless_config_without_lengths_is_accepted() { - for (array_field_offsets, array_item_types, track_array_elements) in - [(vec![48], vec![Type::Ref], false), (vec![], vec![], true)] - { - let mut ctx = OptContext::with_inputarg_types(8, &[Type::Ref, Type::Int]); - let mut pass = OptVirtualize::with_virtualizable(VirtualizableConfig { - static_field_offsets: vec![], - static_field_types: vec![], - static_field_descrs: vec![], - array_field_offsets, - array_item_types, - array_field_descrs: vec![], - array_lengths: vec![], - vable_input_offset: 0, - identity_input_index: Some(0), - track_array_elements, - }); - pass.setup(); - if let Some(ref mut vt) = pass.vable { - vt.ensure_setup(&mut ctx); - } - } + let identity = ctx + .get_box_replacement_operand_opt(OpRef::input_arg_ref(0)) + .expect("the identity inputarg must materialize"); + assert!( + ctx.is_virtualizable(&identity), + "ensure_setup must still mark the identity virtualizable so the base is not forced", + ); } #[test] @@ -3901,10 +3765,8 @@ mod tests { array_field_offsets: vec![24], array_item_types: vec![Type::Int], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -3948,10 +3810,8 @@ mod tests { array_field_offsets: vec![24], array_item_types: vec![Type::Int], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -4000,10 +3860,8 @@ mod tests { array_field_offsets: vec![8], array_item_types: vec![Type::Int], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -4109,10 +3967,8 @@ mod tests { array_field_offsets: vec![8], array_item_types: vec![Type::Int], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); pass.setup(); @@ -4224,10 +4080,8 @@ mod tests { array_field_offsets: vec![24], array_item_types: vec![Type::Int], array_field_descrs: vec![], - array_lengths: vec![1], vable_input_offset: 0, identity_input_index: Some(0), - track_array_elements: true, }); let mut constants: majit_ir::ConstMap = majit_ir::ConstMap::new(); let mut ops = vec![ diff --git a/majit/majit-metainterp/src/pyjitpl.rs b/majit/majit-metainterp/src/pyjitpl.rs index 330cde71e82..b8a12ec5b5d 100644 --- a/majit/majit-metainterp/src/pyjitpl.rs +++ b/majit/majit-metainterp/src/pyjitpl.rs @@ -4338,7 +4338,6 @@ impl MetaInterp { } self.virtualizable_info().map(|info| { let mut config = info.to_optimizer_config(); - config.array_lengths = ctx.virtualizable_array_lengths().unwrap_or(&[]).to_vec(); // virtualizable.py:90 read_boxes input layout = [frame, // extra_reds..., vable_scalars..., array_items...]. The // canonical source of `vable_input_offset` is the active @@ -24743,7 +24742,6 @@ mod tests { config.array_item_types, info.to_optimizer_config().array_item_types ); - assert_eq!(config.array_lengths, vec![2]); } // ── JitIface hook/callback parity tests (rpython/jit/metainterp/test/test_jitiface.py) ── diff --git a/majit/majit-metainterp/src/trace_ctx.rs b/majit/majit-metainterp/src/trace_ctx.rs index 147cf3addc1..6f53f2d0f0a 100644 --- a/majit/majit-metainterp/src/trace_ctx.rs +++ b/majit/majit-metainterp/src/trace_ctx.rs @@ -3041,6 +3041,24 @@ impl TraceCtx { /// That null is a pyre-upstream parity gap, not a shadow bug — the /// shadow faithfully reflects the caller's Box. pub fn set_virtualizable_entry_at(&mut self, index: usize, opref: OpRef, value: Value) { + // The precondition above, checked rather than only stated. A + // `Value::Int` in a Ref slot is not a wrong number — it is a pointer + // the shadow will hand to `value_as_ref_bits`, which decodes it as 0, + // so a later `BC_GETARRAYITEM_VABLE_R` reads NULL out of a slot that + // holds a live object. `Value::Void` is the absence of a live + // concrete and is legal in every slot; a slot whose type is not + // declared (no `virtualizable_info`, or an index past the layout) + // yields `None` and is left to the range assert below. + debug_assert!( + matches!(value, Value::Void) + || self + .virtualizable_slot_type(index) + .is_none_or(|declared| declared == value.get_type()), + "set_virtualizable_entry_at: slot {index} is declared {:?} but the caller wrote a \ + {:?}; a mismatched Ref slot decodes to NULL through `value_as_ref_bits`", + self.virtualizable_slot_type(index), + value.get_type(), + ); let (boxes_opt, values_opt) = ( &mut self.virtualizable_boxes, &mut self.virtualizable_values, diff --git a/majit/majit-metainterp/src/virtualizable.rs b/majit/majit-metainterp/src/virtualizable.rs index 352478b8292..493ab071697 100644 --- a/majit/majit-metainterp/src/virtualizable.rs +++ b/majit/majit-metainterp/src/virtualizable.rs @@ -919,23 +919,6 @@ impl VirtualizableInfo { /// non-vable reds (e.g. `interp_jit.py:67 reds = ['frame', 'ec']`) /// should patch the field after construction — see /// `MetaInterp::current_virtualizable_optimizer_config`. - /// Whether array elements reach the loop JUMP through the tracer's live - /// `virtualizable_boxes` shadow (`collect_jump_args_with_boxes`, - /// pyjitpl.py:2982-2989) instead of being re-seeded from the trace-entry - /// input args by the optimizer's stopgap `VirtualizableTracker`. - /// - /// True for the macro state-field JIT: no static extra boxes and a green - /// ref kept ahead of the identity (so `identity_ref_bank_index` is set). - /// PyFrame (a heap-object virtualizable, `identity_ref_bank_index == None`) - /// returns false and keeps the legacy optimizer seeding. When true, - /// `to_optimizer_config` clears `track_array_elements` so the optimizer - /// does not double-count the array at the loop boundary. The discriminator - /// is structural — the banked-identity layout, not the field name — so it - /// holds for any state-field driver regardless of what it names its state. - pub fn elements_carried_via_shadow(&self) -> bool { - self.num_static_extra_boxes == 0 && self.identity_ref_bank_index.is_some() - } - pub(crate) fn to_optimizer_config( &self, ) -> crate::optimizeopt::virtualize::VirtualizableConfig { @@ -946,18 +929,6 @@ impl VirtualizableInfo { array_field_offsets: self.array_fields.iter().map(|a| a.field_offset).collect(), array_item_types: self.array_fields.iter().map(|a| a.item_type).collect(), array_field_descrs: self.array_field_descrs().to_vec(), - // Placeholder, like `vable_input_offset` below, and patched by the - // same caller. A length is not a property of the shape: upstream - // reads `len(lst)` off the live object every time it needs one - // (`virtualizable.py` `read_boxes`, `get_array_length`), and stores - // it nowhere. `MetaInterp::current_virtualizable_optimizer_config` - // fills this from `TraceCtx::virtualizable_array_lengths`, which - // both writers of `virtualizable_boxes` populate in the same - // statement. Leaving it empty while `array_field_offsets` is not - // makes `VirtualizableTracker::init`'s zip run zero times, so no - // element state is seeded and `tracked_array_element` can never - // hit — a debug assertion there names that state. - array_lengths: vec![], vable_input_offset: 0, // Same declaration the resume path reads // (`MetaInterp::identity_live_position`): the loop's inputargs are @@ -965,8 +936,8 @@ impl VirtualizableInfo { // input-arg slot. // // `identity_live_index == None` is overloaded, so the layout - // decides what it means. `identity_ref_bank_index` is the same - // structural discriminator `elements_carried_via_shadow` uses: + // decides what it means. `identity_ref_bank_index` is the + // structural discriminator: // // - `None` — the legacy frame-first (PyFrame) layout, whose reds are // `[frame, extra_reds.., vable_scalars.., array_items..]`. The @@ -989,7 +960,6 @@ impl VirtualizableInfo { None => Some(0), Some(_) => self.identity_live_index, }, - track_array_elements: !self.elements_carried_via_shadow(), } } @@ -2458,7 +2428,6 @@ mod tests { ); assert_eq!(config.array_field_offsets, vec![48, 56]); assert_eq!(config.array_item_types, vec![Type::Ref, Type::Int]); - assert!(config.array_lengths.is_empty()); } /// `identity_live_index == None` means two different things, and the layout diff --git a/pyre/pyre-jit-trace/src/state.rs b/pyre/pyre-jit-trace/src/state.rs index 8a930028c3e..00e3bb5fae7 100644 --- a/pyre/pyre-jit-trace/src/state.rs +++ b/pyre/pyre-jit-trace/src/state.rs @@ -11556,6 +11556,16 @@ impl JitState for PyreJitState { // live_arg_boxes += self.virtualizable_boxes // live_arg_boxes.pop() // + // Not reached in production, and the reason matters to anyone + // reading this as PyFrame's close: this hook is called from the + // metainterp's `TraceAction::CloseLoop` arm, and nothing under + // `pyre/` ever produces that action — the portal closes through + // `CloseLoopWithArgs`, whose args the tracer builds itself in + // `jitcode_dispatch::append_virtualizable_boxes`. That function + // splices the same shadow by the same formula, so the two agree; + // this one exists so the metainterp arm is also correct for PyFrame + // rather than falling back to the register mirror. + // // PyFrame's reds are [frame, ec]. The TraceCtx shadow is the // authoritative `virtualizable_boxes` list in upstream order // [static fields..., locals_cells_stack_w..., frame], with the