[wasm][mono][AOT] After an exception filter catches, the method's arguments read wrong (string empty, int 1) #136780

using System.Runtime.CompilerServices;

var p = new Probe { Flag = true };
Console.WriteLine("1 arg after filter: [" + Probe.ArgAfterFilter("name") + "]");
Console.WriteLine("2 arg after plain: [" + Probe.ArgAfterPlain("name") + "]");
Console.WriteLine("3 local set in filtered catch: " + p.LocalSetInCatch());
Console.WriteLine("4 local before try: " + Probe.LocalBeforeTry(7));
Console.WriteLine("5 int arg after filter: " + Probe.IntArgAfterFilter(42));
Console.WriteLine("6 arg in filter: " + Probe.ArgInFilter("x"));
Console.WriteLine("7 interpolated in catch: [" + Probe.Interpolated("name") + "]");
Console.WriteLine("8 rethrow outer: [" + Probe.Outer("name") + "]");
return 0;

internal sealed class Probe
{
    public bool Flag { get; set; }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static void Throw() => throw new InvalidDataException("x");

    // The argument read after a filter caught.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static string ArgAfterFilter(string name)
    {
        string r;
        try { Throw(); r = "ok"; }
        catch (Exception e) when (e is InvalidDataException or NotSupportedException) { r = e.GetType().Name; }
        return name + ": " + r;
    }

    // The same with a plain catch that rethrows: right.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static string ArgAfterPlain(string name)
    {
        string r;
        try { Throw(); r = "ok"; }
        catch (Exception e) { if (e is not InvalidDataException) throw; r = e.GetType().Name; }
        return name + ": " + r;
    }

    // Locals set in the filtered catch: right.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public string LocalSetInCatch()
    {
        List<int> a; List<int> b; bool lost = false;
        try { Throw(); a = [1]; b = [2]; }
        catch (InvalidDataException) when (Flag) { (a, b, lost) = ([], [], true); }
        return $"{a.Count} {b.Count} {lost}";
    }

    // A local set before the try (y = 21) is kept; the argument x is not.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int LocalBeforeTry(int x)
    {
        int y = x * 3;
        try { Throw(); }
        catch (Exception e) when (e is InvalidDataException) { }
        return y + x;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int IntArgAfterFilter(int n)
    {
        try { Throw(); }
        catch (Exception e) when (e is InvalidDataException) { }
        return n;
    }

    // The argument read in the filter itself: right.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool ArgInFilter(string s)
    {
        try { Throw(); return false; }
        catch (Exception) when (s == "x") { return true; }
    }

    // The argument read inside the filtered catch block.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static string Interpolated(string name)
    {
        try { Throw(); return ""; }
        catch (Exception e) when (e is InvalidDataException or NotSupportedException) { return $"{name}: {e.GetType().Name}"; }
    }

    // The exception passes an inner filter that doesn't match and is caught by an outer one.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static string Outer(string name)
    {
        try { return Inner(); }
        catch (Exception e) when (e is InvalidDataException) { return name + " " + e.Message; }
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static string Inner()
    {
        try { Throw(); return ""; }
        catch (Exception e) when (e is NotSupportedException) { return "wrong"; }
    }
}