rename `ui/stable-mir-print`

6 files changed, 791 insertions, 0 deletions

diff --git a/tests/ui/rustc_public-ir-print/async-closure.rs b/tests/ui/rustc_public-ir-print/async-closure.rs
new file mode 100644
index 00000000000..80f96e09cfc
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/async-closure.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
+//@ check-pass
+//@ only-x86_64
+//@ edition: 2024
+//@ needs-unwind unwind edges are different with panic=abort
+
+pub fn foo() {
+    let y = 0;
+    let x = async || {
+        let y = y;
+    };
+}
diff --git a/tests/ui/rustc_public-ir-print/async-closure.stdout b/tests/ui/rustc_public-ir-print/async-closure.stdout
new file mode 100644
index 00000000000..31811299722
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/async-closure.stdout
@@ -0,0 +1,113 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn foo() -> () {
+    let mut _0: ();
+    let  _1: i32;
+    let  _2: {async closure@$DIR/async-closure.rs:9:13: 9:21};
+    let mut _3: &i32;
+    debug y => _1;
+    debug x => _2;
+    bb0: {
+        StorageLive(_1);
+        _1 = 0_i32;
+        StorageLive(_2);
+        StorageLive(_3);
+        _3 = &_1;
+        _2 = {coroutine-closure@$DIR/async-closure.rs:9:13: 9:21}(move _3);
+        StorageDead(_3);
+        _0 = ();
+        StorageDead(_2);
+        StorageDead(_1);
+        return;
+    }
+}
+fn foo::{closure#0}(_1: &{async closure@$DIR/async-closure.rs:9:13: 9:21}) -> {async closure body@$DIR/async-closure.rs:9:22: 11:6} {
+    let mut _0: {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _2: &i32;
+    let mut _3: &i32;
+    debug y => (*((*_1).0: &i32));
+    bb0: {
+        StorageLive(_2);
+        _3 = CopyForDeref(((*_1).0: &i32));
+        _2 = &(*_3);
+        _0 = {coroutine@$DIR/async-closure.rs:9:22: 11:6}(move _2);
+        StorageDead(_2);
+        return;
+    }
+}
+fn foo::{closure#0}::{closure#0}(_1: Pin<&mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}>, _2: &mut Context<'_>) -> Poll<()> {
+    let mut _0: Poll<()>;
+    let  _3: i32;
+    let mut _4: &i32;
+    let mut _5: ();
+    let mut _6: &mut Context<'_>;
+    let mut _7: u32;
+    let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    debug _task_context => _6;
+    debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
+    debug y => _3;
+    bb0: {
+        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _7 = discriminant((*_8));
+        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
+    }
+    bb1: {
+        _6 = move _2;
+        StorageLive(_3);
+        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _4 = CopyForDeref(((*_9).0: &i32));
+        _3 = (*_4);
+        _5 = ();
+        StorageDead(_3);
+        _0 = std::task::Poll::Ready(move _5);
+        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        discriminant((*_10) = 1;
+        return;
+    }
+    bb2: {
+        assert(false, `async fn` resumed after completion) -> [success: bb2, unwind unreachable];
+    }
+    bb3: {
+        unreachable;
+    }
+}
+fn foo::{closure#0}::{synthetic#0}(_1: Pin<&mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}>, _2: &mut Context<'_>) -> Poll<()> {
+    let mut _0: Poll<()>;
+    let  _3: i32;
+    let mut _4: &i32;
+    let mut _5: ();
+    let mut _6: &mut Context<'_>;
+    let mut _7: u32;
+    let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    debug _task_context => _6;
+    debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
+    debug y => _3;
+    bb0: {
+        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _7 = discriminant((*_8));
+        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
+    }
+    bb1: {
+        _6 = move _2;
+        StorageLive(_3);
+        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _4 = CopyForDeref(((*_9).0: &i32));
+        _3 = (*_4);
+        _5 = ();
+        StorageDead(_3);
+        _0 = std::task::Poll::Ready(move _5);
+        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        discriminant((*_10) = 1;
+        return;
+    }
+    bb2: {
+        assert(false, `async fn` resumed after completion) -> [success: bb2, unwind unreachable];
+    }
+    bb3: {
+        unreachable;
+    }
+}
diff --git a/tests/ui/rustc_public-ir-print/basic_function.rs b/tests/ui/rustc_public-ir-print/basic_function.rs
new file mode 100644
index 00000000000..21469c61f72
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/basic_function.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Z unpretty=stable-mir -Zmir-opt-level=0
+//@ check-pass
+//@ only-x86_64
+//@ needs-unwind unwind edges are different with panic=abort
+
+fn foo(i: i32) -> i32 {
+    i + 1
+}
+
+fn bar(vec: &mut Vec<i32>) -> Vec<i32> {
+    let mut new_vec = vec.clone();
+    new_vec.push(1);
+    new_vec
+}
+
+pub fn demux(input: u8) -> u8 {
+    match input {
+        0 => 10,
+        1 => 6,
+        2 => 8,
+        _ => 0,
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/rustc_public-ir-print/basic_function.stdout b/tests/ui/rustc_public-ir-print/basic_function.stdout
new file mode 100644
index 00000000000..319d9c1dc69
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/basic_function.stdout
@@ -0,0 +1,87 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn foo(_1: i32) -> i32 {
+    let mut _0: i32;
+    let mut _2: i32;
+    let mut _3: (i32, bool);
+    debug i => _1;
+    bb0: {
+        StorageLive(_2);
+        _2 = _1;
+        _3 = CheckedAdd(_2, 1_i32);
+        assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, 1_i32) -> [success: bb1, unwind continue];
+    }
+    bb1: {
+        _0 = move (_3.0: i32);
+        StorageDead(_2);
+        return;
+    }
+}
+fn bar(_1: &mut Vec<i32>) -> Vec<i32> {
+    let mut _0: Vec<i32>;
+    let mut _2: Vec<i32>;
+    let mut _3: &Vec<i32>;
+    let  _4: ();
+    let mut _5: &mut Vec<i32>;
+    debug vec => _1;
+    debug new_vec => _2;
+    bb0: {
+        StorageLive(_2);
+        StorageLive(_3);
+        _3 = &(*_1);
+        _2 = <Vec<i32> as Clone>::clone(move _3) -> [return: bb1, unwind continue];
+    }
+    bb1: {
+        StorageDead(_3);
+        StorageLive(_4);
+        StorageLive(_5);
+        _5 = &mut _2;
+        _4 = Vec::<i32>::push(move _5, 1_i32) -> [return: bb2, unwind: bb3];
+    }
+    bb2: {
+        StorageDead(_5);
+        StorageDead(_4);
+        _0 = move _2;
+        StorageDead(_2);
+        return;
+    }
+    bb3: {
+        drop(_2) -> [return: bb4, unwind terminate];
+    }
+    bb4: {
+        resume;
+    }
+}
+fn demux(_1: u8) -> u8 {
+    let mut _0: u8;
+    debug input => _1;
+    bb0: {
+        switchInt(_1) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb1];
+    }
+    bb1: {
+        _0 = 0_u8;
+        goto -> bb5;
+    }
+    bb2: {
+        _0 = 8_u8;
+        goto -> bb5;
+    }
+    bb3: {
+        _0 = 6_u8;
+        goto -> bb5;
+    }
+    bb4: {
+        _0 = 10_u8;
+        goto -> bb5;
+    }
+    bb5: {
+        return;
+    }
+}
+fn main() -> () {
+    let mut _0: ();
+    bb0: {
+        _0 = ();
+        return;
+    }
+}
diff --git a/tests/ui/rustc_public-ir-print/operands.rs b/tests/ui/rustc_public-ir-print/operands.rs
new file mode 100644
index 00000000000..484ad07cf04
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/operands.rs
@@ -0,0 +1,48 @@
+//@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
+//@ check-pass
+//@ only-x86_64
+//@ needs-unwind unwind edges are different with panic=abort
+//! Check how stable mir pretty printer prints different operands and abort strategy.
+
+pub fn operands(val: u8) {
+    let array = [val; 10];
+    let first = array[0];
+    let last = array[10 - 1];
+    assert_eq!(first, last);
+
+    let reference = &first;
+    let dereferenced = *reference;
+    assert_eq!(dereferenced, first);
+
+    let tuple = (first, last);
+    let (first_again, _) = tuple;
+    let first_again_again = tuple.0;
+    assert_eq!(first_again, first_again_again);
+
+    let length = array.len();
+    let size_of = std::mem::size_of_val(&length);
+    assert_eq!(length, size_of);
+}
+
+pub struct Dummy {
+    c: char,
+    i: i32,
+}
+
+pub enum Ctors {
+    Unit,
+    StructLike { d: Dummy },
+    TupLike(bool),
+}
+
+pub fn more_operands() -> [Ctors; 3] {
+    let dummy = Dummy { c: 'a', i: i32::MIN };
+    let unit = Ctors::Unit;
+    let struct_like = Ctors::StructLike { d: dummy };
+    let tup_like = Ctors::TupLike(false);
+    [unit, struct_like, tup_like]
+}
+
+pub fn closures(x: bool, z: bool) -> impl FnOnce(bool) -> bool {
+    move |y: bool| (x ^ y) || z
+}
diff --git a/tests/ui/rustc_public-ir-print/operands.stdout b/tests/ui/rustc_public-ir-print/operands.stdout
new file mode 100644
index 00000000000..37c5ec1a95e
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/operands.stdout
@@ -0,0 +1,506 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn operands(_1: u8) -> () {
+    let mut _0: ();
+    let  _2: [u8; 10];
+    let mut _3: u8;
+    let  _4: u8;
+    let  _5: usize;
+    let mut _6: bool;
+    let  _7: u8;
+    let  _8: usize;
+    let mut _9: (usize, bool);
+    let mut _10: bool;
+    let  _11: ();
+    let mut _12: (&u8, &u8);
+    let mut _13: &u8;
+    let mut _14: &u8;
+    let  _15: &u8;
+    let  _16: &u8;
+    let mut _17: bool;
+    let mut _18: u8;
+    let mut _19: u8;
+    let mut _20: !;
+    let  _21: core::panicking::AssertKind;
+    let  _22: !;
+    let mut _23: core::panicking::AssertKind;
+    let mut _24: &u8;
+    let  _25: &u8;
+    let mut _26: &u8;
+    let  _27: &u8;
+    let mut _28: Option<Arguments<'_>>;
+    let  _29: &u8;
+    let  _30: u8;
+    let  _31: ();
+    let mut _32: (&u8, &u8);
+    let mut _33: &u8;
+    let mut _34: &u8;
+    let  _35: &u8;
+    let  _36: &u8;
+    let mut _37: bool;
+    let mut _38: u8;
+    let mut _39: u8;
+    let mut _40: !;
+    let  _41: core::panicking::AssertKind;
+    let  _42: !;
+    let mut _43: core::panicking::AssertKind;
+    let mut _44: &u8;
+    let  _45: &u8;
+    let mut _46: &u8;
+    let  _47: &u8;
+    let mut _48: Option<Arguments<'_>>;
+    let  _49: (u8, u8);
+    let mut _50: u8;
+    let mut _51: u8;
+    let  _52: u8;
+    let  _53: u8;
+    let  _54: ();
+    let mut _55: (&u8, &u8);
+    let mut _56: &u8;
+    let mut _57: &u8;
+    let  _58: &u8;
+    let  _59: &u8;
+    let mut _60: bool;
+    let mut _61: u8;
+    let mut _62: u8;
+    let mut _63: !;
+    let  _64: core::panicking::AssertKind;
+    let  _65: !;
+    let mut _66: core::panicking::AssertKind;
+    let mut _67: &u8;
+    let  _68: &u8;
+    let mut _69: &u8;
+    let  _70: &u8;
+    let mut _71: Option<Arguments<'_>>;
+    let  _72: usize;
+    let mut _73: &[u8];
+    let mut _74: &[u8; 10];
+    let  _75: usize;
+    let mut _76: &usize;
+    let  _77: &usize;
+    let  _78: ();
+    let mut _79: (&usize, &usize);
+    let mut _80: &usize;
+    let mut _81: &usize;
+    let  _82: &usize;
+    let  _83: &usize;
+    let mut _84: bool;
+    let mut _85: usize;
+    let mut _86: usize;
+    let mut _87: !;
+    let  _88: core::panicking::AssertKind;
+    let  _89: !;
+    let mut _90: core::panicking::AssertKind;
+    let mut _91: &usize;
+    let  _92: &usize;
+    let mut _93: &usize;
+    let  _94: &usize;
+    let mut _95: Option<Arguments<'_>>;
+    debug val => _1;
+    debug array => _2;
+    debug first => _4;
+    debug last => _7;
+    debug left_val => _15;
+    debug right_val => _16;
+    debug kind => _21;
+    debug reference => _29;
+    debug dereferenced => _30;
+    debug left_val => _35;
+    debug right_val => _36;
+    debug kind => _41;
+    debug tuple => _49;
+    debug first_again => _52;
+    debug first_again_again => _53;
+    debug left_val => _58;
+    debug right_val => _59;
+    debug kind => _64;
+    debug length => _72;
+    debug size_of => _75;
+    debug left_val => _82;
+    debug right_val => _83;
+    debug kind => _88;
+    bb0: {
+        StorageLive(_2);
+        StorageLive(_3);
+        _3 = _1;
+        _2 = [move _3; 10];
+        StorageDead(_3);
+        StorageLive(_4);
+        StorageLive(_5);
+        _5 = 0_usize;
+        _6 = Lt(_5, 10_usize);
+        assert(move _6, "index out of bounds: the length is {} but the index is {}", 10_usize, _5) -> [success: bb1, unwind unreachable];
+    }
+    bb1: {
+        _4 = _2[_5];
+        StorageDead(_5);
+        StorageLive(_7);
+        StorageLive(_8);
+        _9 = CheckedSub(10_usize, 1_usize);
+        assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", 10_usize, 1_usize) -> [success: bb2, unwind unreachable];
+    }
+    bb2: {
+        _8 = move (_9.0: usize);
+        _10 = Lt(_8, 10_usize);
+        assert(move _10, "index out of bounds: the length is {} but the index is {}", 10_usize, _8) -> [success: bb3, unwind unreachable];
+    }
+    bb3: {
+        _7 = _2[_8];
+        StorageDead(_8);
+        StorageLive(_11);
+        StorageLive(_12);
+        StorageLive(_13);
+        _13 = &_4;
+        StorageLive(_14);
+        _14 = &_7;
+        _12 = (move _13, move _14);
+        StorageDead(_14);
+        StorageDead(_13);
+        StorageLive(_15);
+        _15 = (_12.0: &u8);
+        StorageLive(_16);
+        _16 = (_12.1: &u8);
+        StorageLive(_17);
+        StorageLive(_18);
+        _18 = (*_15);
+        StorageLive(_19);
+        _19 = (*_16);
+        _17 = Eq(move _18, move _19);
+        switchInt(move _17) -> [0: bb5, otherwise: bb4];
+    }
+    bb4: {
+        StorageDead(_19);
+        StorageDead(_18);
+        _11 = ();
+        StorageDead(_17);
+        StorageDead(_16);
+        StorageDead(_15);
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageLive(_29);
+        _29 = &_4;
+        StorageLive(_30);
+        _30 = (*_29);
+        StorageLive(_31);
+        StorageLive(_32);
+        StorageLive(_33);
+        _33 = &_30;
+        StorageLive(_34);
+        _34 = &_4;
+        _32 = (move _33, move _34);
+        StorageDead(_34);
+        StorageDead(_33);
+        StorageLive(_35);
+        _35 = (_32.0: &u8);
+        StorageLive(_36);
+        _36 = (_32.1: &u8);
+        StorageLive(_37);
+        StorageLive(_38);
+        _38 = (*_35);
+        StorageLive(_39);
+        _39 = (*_36);
+        _37 = Eq(move _38, move _39);
+        switchInt(move _37) -> [0: bb7, otherwise: bb6];
+    }
+    bb5: {
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageLive(_21);
+        _21 = core::panicking::AssertKind::Eq;
+        StorageLive(_22);
+        StorageLive(_23);
+        _23 = move _21;
+        StorageLive(_24);
+        StorageLive(_25);
+        _25 = &(*_15);
+        _24 = &(*_25);
+        StorageLive(_26);
+        StorageLive(_27);
+        _27 = &(*_16);
+        _26 = &(*_27);
+        StorageLive(_28);
+        _28 = std::option::Option::None;
+        _22 = core::panicking::assert_failed::<u8, u8>(move _23, move _24, move _26, move _28) -> unwind unreachable;
+    }
+    bb6: {
+        StorageDead(_39);
+        StorageDead(_38);
+        _31 = ();
+        StorageDead(_37);
+        StorageDead(_36);
+        StorageDead(_35);
+        StorageDead(_32);
+        StorageDead(_31);
+        StorageLive(_49);
+        StorageLive(_50);
+        _50 = _4;
+        StorageLive(_51);
+        _51 = _7;
+        _49 = (move _50, move _51);
+        StorageDead(_51);
+        StorageDead(_50);
+        StorageLive(_52);
+        _52 = (_49.0: u8);
+        StorageLive(_53);
+        _53 = (_49.0: u8);
+        StorageLive(_54);
+        StorageLive(_55);
+        StorageLive(_56);
+        _56 = &_52;
+        StorageLive(_57);
+        _57 = &_53;
+        _55 = (move _56, move _57);
+        StorageDead(_57);
+        StorageDead(_56);
+        StorageLive(_58);
+        _58 = (_55.0: &u8);
+        StorageLive(_59);
+        _59 = (_55.1: &u8);
+        StorageLive(_60);
+        StorageLive(_61);
+        _61 = (*_58);
+        StorageLive(_62);
+        _62 = (*_59);
+        _60 = Eq(move _61, move _62);
+        switchInt(move _60) -> [0: bb9, otherwise: bb8];
+    }
+    bb7: {
+        StorageDead(_39);
+        StorageDead(_38);
+        StorageLive(_41);
+        _41 = core::panicking::AssertKind::Eq;
+        StorageLive(_42);
+        StorageLive(_43);
+        _43 = move _41;
+        StorageLive(_44);
+        StorageLive(_45);
+        _45 = &(*_35);
+        _44 = &(*_45);
+        StorageLive(_46);
+        StorageLive(_47);
+        _47 = &(*_36);
+        _46 = &(*_47);
+        StorageLive(_48);
+        _48 = std::option::Option::None;
+        _42 = core::panicking::assert_failed::<u8, u8>(move _43, move _44, move _46, move _48) -> unwind unreachable;
+    }
+    bb8: {
+        StorageDead(_62);
+        StorageDead(_61);
+        _54 = ();
+        StorageDead(_60);
+        StorageDead(_59);
+        StorageDead(_58);
+        StorageDead(_55);
+        StorageDead(_54);
+        StorageLive(_72);
+        StorageLive(_73);
+        StorageLive(_74);
+        _74 = &_2;
+        _73 = move _74 as &[u8];
+        StorageDead(_74);
+        _72 = core::slice::<impl [u8]>::len(move _73) -> [return: bb10, unwind unreachable];
+    }
+    bb9: {
+        StorageDead(_62);
+        StorageDead(_61);
+        StorageLive(_64);
+        _64 = core::panicking::AssertKind::Eq;
+        StorageLive(_65);
+        StorageLive(_66);
+        _66 = move _64;
+        StorageLive(_67);
+        StorageLive(_68);
+        _68 = &(*_58);
+        _67 = &(*_68);
+        StorageLive(_69);
+        StorageLive(_70);
+        _70 = &(*_59);
+        _69 = &(*_70);
+        StorageLive(_71);
+        _71 = std::option::Option::None;
+        _65 = core::panicking::assert_failed::<u8, u8>(move _66, move _67, move _69, move _71) -> unwind unreachable;
+    }
+    bb10: {
+        StorageDead(_73);
+        StorageLive(_75);
+        StorageLive(_76);
+        StorageLive(_77);
+        _77 = &_72;
+        _76 = &(*_77);
+        _75 = std::mem::size_of_val::<usize>(move _76) -> [return: bb11, unwind unreachable];
+    }
+    bb11: {
+        StorageDead(_76);
+        StorageDead(_77);
+        StorageLive(_78);
+        StorageLive(_79);
+        StorageLive(_80);
+        _80 = &_72;
+        StorageLive(_81);
+        _81 = &_75;
+        _79 = (move _80, move _81);
+        StorageDead(_81);
+        StorageDead(_80);
+        StorageLive(_82);
+        _82 = (_79.0: &usize);
+        StorageLive(_83);
+        _83 = (_79.1: &usize);
+        StorageLive(_84);
+        StorageLive(_85);
+        _85 = (*_82);
+        StorageLive(_86);
+        _86 = (*_83);
+        _84 = Eq(move _85, move _86);
+        switchInt(move _84) -> [0: bb13, otherwise: bb12];
+    }
+    bb12: {
+        StorageDead(_86);
+        StorageDead(_85);
+        _78 = ();
+        StorageDead(_84);
+        StorageDead(_83);
+        StorageDead(_82);
+        StorageDead(_79);
+        StorageDead(_78);
+        _0 = ();
+        StorageDead(_75);
+        StorageDead(_72);
+        StorageDead(_53);
+        StorageDead(_52);
+        StorageDead(_49);
+        StorageDead(_30);
+        StorageDead(_29);
+        StorageDead(_7);
+        StorageDead(_4);
+        StorageDead(_2);
+        return;
+    }
+    bb13: {
+        StorageDead(_86);
+        StorageDead(_85);
+        StorageLive(_88);
+        _88 = core::panicking::AssertKind::Eq;
+        StorageLive(_89);
+        StorageLive(_90);
+        _90 = move _88;
+        StorageLive(_91);
+        StorageLive(_92);
+        _92 = &(*_82);
+        _91 = &(*_92);
+        StorageLive(_93);
+        StorageLive(_94);
+        _94 = &(*_83);
+        _93 = &(*_94);
+        StorageLive(_95);
+        _95 = std::option::Option::None;
+        _89 = core::panicking::assert_failed::<usize, usize>(move _90, move _91, move _93, move _95) -> unwind unreachable;
+    }
+}
+fn operands::{constant#0}() -> usize {
+    let mut _0: usize;
+    bb0: {
+        _0 = 10_usize;
+        return;
+    }
+}
+fn more_operands() -> [Ctors; 3] {
+    let mut _0: [Ctors; 3];
+    let  _1: Dummy;
+    let  _2: Ctors;
+    let  _3: Ctors;
+    let mut _4: Dummy;
+    let  _5: Ctors;
+    let mut _6: Ctors;
+    let mut _7: Ctors;
+    let mut _8: Ctors;
+    debug dummy => _1;
+    debug unit => _2;
+    debug struct_like => _3;
+    debug tup_like => _5;
+    bb0: {
+        StorageLive(_1);
+        _1 = Dummy('a', core::num::<impl i32>::MIN);
+        StorageLive(_2);
+        _2 = Ctors::Unit;
+        StorageLive(_3);
+        StorageLive(_4);
+        _4 = move _1;
+        _3 = Ctors::StructLike(move _4);
+        StorageDead(_4);
+        StorageLive(_5);
+        _5 = Ctors::TupLike(false);
+        StorageLive(_6);
+        _6 = move _2;
+        StorageLive(_7);
+        _7 = move _3;
+        StorageLive(_8);
+        _8 = move _5;
+        _0 = [move _6, move _7, move _8];
+        StorageDead(_8);
+        StorageDead(_7);
+        StorageDead(_6);
+        StorageDead(_5);
+        StorageDead(_3);
+        StorageDead(_2);
+        StorageDead(_1);
+        return;
+    }
+}
+fn more_operands::{constant#0}() -> usize {
+    let mut _0: usize;
+    bb0: {
+        _0 = 3_usize;
+        return;
+    }
+}
+fn closures(_1: bool, _2: bool) -> {closure@$DIR/operands.rs:47:5: 47:19} {
+    let mut _0: {closure@$DIR/operands.rs:47:5: 47:19};
+    debug x => _1;
+    debug z => _2;
+    bb0: {
+        _0 = {closure@$DIR/operands.rs:47:5: 47:19}(_1, _2);
+        return;
+    }
+}
+fn closures::{closure#0}(_1: {closure@$DIR/operands.rs:47:5: 47:19}, _2: bool) -> bool {
+    let mut _0: bool;
+    let mut _3: bool;
+    let mut _4: bool;
+    let mut _5: bool;
+    debug y => _2;
+    debug x => (_1.0: bool);
+    debug z => (_1.1: bool);
+    bb0: {
+        StorageLive(_3);
+        StorageLive(_4);
+        _4 = (_1.0: bool);
+        StorageLive(_5);
+        _5 = _2;
+        _3 = BitXor(move _4, move _5);
+        switchInt(move _3) -> [0: bb2, otherwise: bb1];
+    }
+    bb1: {
+        StorageDead(_5);
+        StorageDead(_4);
+        _0 = true;
+        goto -> bb3;
+    }
+    bb2: {
+        StorageDead(_5);
+        StorageDead(_4);
+        _0 = (_1.1: bool);
+        goto -> bb3;
+    }
+    bb3: {
+        StorageDead(_3);
+        return;
+    }
+}
+fn Ctors::TupLike(_1: bool) -> Ctors {
+    let mut _0: Ctors;
+    bb0: {
+        _0 = Ctors::TupLike(move _1);
+        return;
+    }
+}