Don't forget to pass instantiation context after devirtualizing

[MichalStrehovsky]

This is a difference between CoreCLR and the managed type system - the result of interface method resolution is going to be a canonical method on the CoreCLR side, but exact on the managed side.

So this implementation is slightly different from how it looks like on the VM side. We slightly touched on the difference in #45744 but there was more to it.

[MichalStrehovsky]

@dotnet/crossgen-contrib PTAL

@agocke This is the issue you hit with NativeAOT in Roslyn. I assume Roslyn proper doesn't hit this because it's either not compiled with crossgen2, or because version bubble crossing happens (aborting the devirt).

[MichalStrehovsky]

I want to make this Pri 1, but I want this to run in the CI first.

[MichalStrehovsky]

Huh, so RyuJIT then goes and feeds the result of the devirt back into resolveVirtualMethod for... reasons?

We resolve System.Collections.Generic.ICollection1<int32>.get_Count on System.Collections.Generic.Dictionary2+KeyCollection<int32,string> into System.Collections.Generic.Dictionary2+KeyCollection<int32,System.__Canon>.get_Count().

And then RyuJIT asks us to resolveVirtualMethod the System.Collections.Generic.Dictionary2+KeyCollection<int32,System.__Canon>.get_Count() on System.Collections.Generic.Dictionary2+KeyCollection<int32,string>?

This now fails because we're not the CoreCLR type system where <int32,System.__Canon> is pretty much <int32,string> in arbitrary ways.

We'll need to also canonicalize in some other spot too. I haven't figured out where yet.

[MichalStrehovsky]

Sigh, so this is now failing because the devirtualization logic has other problems with canonical code unrelated to what I'm fixing here:

using System;
using System.Runtime.CompilerServices;

Console.WriteLine(Foo<Atom1>.Call());
Console.WriteLine(Foo<Atom2>.Call());


interface IFooable<T>
{
    public string DoFoo(T x);
}

class Base : IFooable<Atom2>
{
    string IFooable<Atom2>.DoFoo(Atom2 x) => "Base";
}

sealed class Foo<T> : Base, IFooable<T>
{
    string IFooable<T>.DoFoo(T x) => "Foo";

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static string Call()
    {
        var f = new Foo<T>();
        return ((IFooable<T>)f).DoFoo(default) + ((IFooable<Atom2>)f).DoFoo(null);
    }
}

class Atom1 { }
class Atom2 { }

This is supposed to print:

FooBase
FooFoo

However, after crossgen2, it will print

FooBase
FooBase

This will need a bit more rewriting.

I'm a bit concerned about the amount of test coverage we have for type system corner cases like this.

[MichalStrehovsky]

Oh so the second repro program is also broken on CoreCLR without ReadyToRun at all. I was hoping I can just steal whatever CoreCLR is doing but nope.

I'll watch this from the sidelines. Filed #51983 and #51982.