Interface stripping produces invalid outputs

[MichalStrehovsky]

Found this when I was looking at #1077 (it looks like having to declare IsAssignableFrom linker unsafe would be quite a pain.)

It wouldn't be completely academical to assume that an app that has some Foos implementing IFoo could end up in a situation where we have an empty array of Foos (because no Foo was allocated because the code that normally news them up was e.g. linked out) that we need to cast to an array of IFoo.

Linker currently produces invalid output for this because it strips the IFoo implementation off Foo:

using System;

interface IFoo { }

class Foo : IFoo { }

class Program
{
    static void Main()
    {
        // need to go through object to force a cast for added dramatic effect at runtime
        // otherwise this would just silently break type safety
        IFoo[] foos = (IFoo[])(object)new Foo[0];
    }
}

[MichalStrehovsky]

This has the same problems for variant casting (if such Foo/IFoo is ever used in a position of an argument to a variant interface/delegate). I don't think this is solvable without linker scanning instantiated code.

This optimization will also have problems for the covariant returns feature.

In general I have low confidence this optimization can be done correctly.

I think we'll need to replace this with something less aggressive that doesn't produce broken apps (keep the interface, but stub out the implementations). This is what the .NET Native dependency reducer does too.

[mrvoorhe]

without linker scanning instantiated code.

Can you elaborate on what you mean by that? Is this more than what AnnotationStore.MarkInstantiated is tracking?

[MichalStrehovsky]

without linker scanning instantiated code.

Can you elaborate on what you mean by that? Is this more than what AnnotationStore.MarkInstantiated is tracking?

AFAIK linker doesn't do enough genericness tracking to be able to propagate the Boring<Foo> here into knowledge that Foo was used in a variant position.

interface IVariant<out T> { }
interface IFoo { }
class Foo : IFoo { }
class Interesting<T> : IVariant<T> { }
class Boring<T> : Interesting<T> { }

class Program
{
    static void Main()
    {
        IVariant<IFoo> foos = (IVariant<IFoo>)(object)new Boring<Foo>();
    }
}

Boring<Foo> should be castable to IVariant<IFoo> but it won't if linker decides to strip the IFoo interface off Foo based on the fact that Foo was not instantiated.

The fact that no Foo was instantiated should not break Boring's variant castability but it currently does.

[mrvoorhe]

Can we fix this by doing a little extra processing when we see new Boring<Foo>() and mark all of the generic arguments as instantiated?

It seems like there should be some blunt approach we can take to close this hole without giving up the optimization entirely.

[MichalStrehovsky]

Yep, considering the interface usable when a type is used as a generic argument, array element, or from a typeof should plug all the known holes with this. It still makes me uneasy, but I can't come up with a scenario where it wouldn't work.