Expose discriminant values in stable_mir

[NotLebedev]

Resolves rust-lang/project-stable-mir#93

• Added Discr struct to stable mir as stable version of struct with same name
• Added discriminant_for_variant method to AdtDef and CoroutineDef

[rustbot]

r? @celinval

rustbot has assigned @celinval.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

[NotLebedev]

Uh, I think the job failed due to some rate limits and needs to be restarted?

[celinval]

Nice! Can you please add a test for this? Can you please make sure you cover generic and monomorphic code? Thanks!

[NotLebedev]

Nice! Can you please add a test for this? Can you please make sure you cover generic and monomorphic code? Thanks!

Added a test for enum discriminant. I'm not sure how to best make tests for coroutines as I only have high level understanding of async/await not of the underlying coroutine mechanism. I would really appreciate some advice what I need to look at to create a test for CoroutineDef::discriminant_for_variant

[makai410]

nit: Could you please rewrite this doc? It doesn't match the test.

[NotLebedev]

Forgot to change when copy-pasting. Fixed

[makai410]

For testing coroutine, I think we should wait for this PR to land before we can retrieve the body of a closure, since rustc would generate closures to implement state machines for async functions.

For example:

async fn simple_async() -> i32 {
    let a = async { 1 }.await;
    let b = async { 2 }.await;
    a + b
}

where the optimized mir is like:

fn simple_async() -> {async fn body of simple_async()} {
// ...
}

fn simple_async::{closure#0}(_1: Pin<&mut {async fn body of simple_async()}>, _2: &mut Context<'_>) -> Poll<i32> {
// ...
}

fn simple_async::{closure#0}::{closure#0}(_1: Pin<&mut {async block@src/lib.rs:2:13: 2:18}>, _2: &mut Context<'_>) -> Poll<i32> {
// ...
}

fn simple_async::{closure#0}::{closure#1}(_1: Pin<&mut {async block@src/lib.rs:3:13: 3:18}>, _2: &mut Context<'_>) -> Poll<i32> {
// ...
}

{closure#0}::{closure#0} and {closure#0}::{closure#1} correspond to the two async blocks.

And what we might need to visit are something like

bb0: {
    _24 = deref_copy (_1.0: &mut {async fn body of simple_async()});
    _23 = discriminant((*_24));
    switchInt(move _23) -> [0: bb1, 1: bb24, 2: bb23, 3: bb21, 4: bb22, otherwise: bb6];
}

i.e., the discriminant and switchInt operations here are used to determine which state the async state machine is in.

Btw in that case, it would be handy if we could also add a discriminants() for retrieving all discriminants, something like

rust/compiler/rustc_middle/src/ty/sty.rs

Lines 98 to 109 in 14863ea

	/// The set of all discriminants for the coroutine, enumerated with their
	/// variant indices.
	#[inline]
	fn discriminants(
	self,
	def_id: DefId,
	tcx: TyCtxt<'tcx>,
	) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> {
	self.variant_range(def_id, tcx).map(move |index| {
	(index, Discr { val: index.as_usize() as u128, ty: self.discr_ty(tcx) })
	})
	}

it can be done as a follow-up though.

[oli-obk]

[oli-obk]

@bors r+ rollup

[oli-obk]

@bors r+ rollup

[bors]

📌 Commit 443e45c has been approved by oli-obk

It is now in the queue for this repository.

[bors]

☔ The latest upstream changes (presumably #141942) made this pull request unmergeable. Please resolve the merge conflicts.