I’d like to remove these “special cases” that require an index. The macro expansion doesn’t accept it and I’d rather not complicate the macro further. If you know a clean way to handle this, please share it with me. I’ll address it in the next PR anyway.

Same "special case" here

I think this fixing-up of ops should go inGcOp::fixup. We can addnum_types as a parameter there. And ifnum_types == 0, we should probably just remove this op, no? How do westruct.new or call a function that takes a concrete struct reference if we don't define any types?

Stylistically, it is quite rare to have the doc comment below the#[...] attributes. Mind reverting this code motion?

To avoid a ton of temporary allocations, and reuse a single allocation instead, let's have this method take a mutable vector as an out parameter:

And let's also do an out parameter here as well.

Should this still be taking astack: usize and returning a newusize? Shouldn't it be taking astack: &mut Vec<StackType> now instead?

I am back!!!

Does this also mean that when we generate a new op, we should also be checking type compatibility, not just maintaining stack depth?

@fitzgen

Does this also mean that when we generate a new op, we should also be checking type compatibility, not just maintaining stack depth?

Yes, we either have to do that (if we continue the existing approach) or else we switch to a new approach and instead just generate a random sequence of arbitrary ops and then rely on the fixup pass to make it valid. The latter might be easier long term, so that there is only one code path we have to maintain.

But also, backing up, we shouldn't really need togenerate op sequences from scratch. The whole point of using a mutation-based paradigm is that we can generate arbitrary inputs via a series of mutations over time. So, instead of generating whole op sequences, weshould be able to get away with something like

implGenerate<GcOps>forGcOpsMutator{fngenerate(&mutself,ctx:&mutContext) -> mutatis::Result<GcOps>{letmut ops =GcOps::default();for _in0..N{self.mutate(ctx,&mut ops)?;}Ok(ops)}}

(And we should probably build the generic version of this intomutatis directly eventually)

Awesome! That was the answer I needed. After addressing this I will push

Thanks a lot

Let's align with the Wasm spec and call thisAnyRef.

We will eventually want to differentiate between(ref struct) and(ref any) and(ref eq) as well.

Aside: we will need to track nullability for all our different ref types eventually as well.

(ref extern) is a different type hierarchy from(ref any), that is there is no single top type of everything, so there is no function that can takeanything and I want to make sure we don't build that assumption in here.

Backing up a bit: I am a bit confused about this function's purpose and why it is necessary. It seems like we shouldn't ever be changing the stack types, we should be only be doing the opposite: fixing up our ops given the types that are actually on the stack. The former doesn't make sense (we can't change what types are on the stack at this point without changing what instructions we emitted earlier).