Remove DAM warning for base types/interfaces

[sbomer]

Similar to #107660, it should be possible to call static methods on a derived type even if the type declaration has mismatching DAM annotations. The problem should surface when the base type is actually instantiated:

using System.Diagnostics.CodeAnalysis;

Derived<int>.DoSomethingSafe();
new Derived<int>();

class Derived<T> : Base<T> // warns here but should not
{
    public Derived() // warns here
    {
    }

    public static void DoSomethingSafe() { }
}

class Base<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] T>
{
    static void Require() => typeof(T).GetMethods();
}

Similar for interfaces.

@MichalStrehovsky @agocke do you agree or can you see any problems with this?

[MichalStrehovsky]

I can't immediately see any problems with that. We might need to be careful with static virtuals.

[sbomer]

@agocke came up with an example that would cause problems:

C<int>.M2();

public class B<T>
{
    public static void M2() { }
}
public class C<T> : B<T> {
    public void M() {
    }
}

C# allows calling base static methods through a reference to the derived class, so Derived<int>.SomeStaticMethod needs to warn if the method is on the base type. The analyzer would have to do significant extra work to figure that out, so this isn't worth the effort.

[sbomer]

Maybe I closed this too soon.

The analyzer would have to do significant extra work to figure that out, so this isn't worth the effort.

I think the analyzer already knows that the method is declared on the base type, for example:

UseDerived<int>();

static void UseDerived<T>()
{
    Derived<T>.StaticMethod(); // this already produces a warning
}

class Derived<T> : BaseDAM<T>
{ }

class BaseDAM<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>
{
    public static void StaticMethod() { }
}

[sbomer]

I think this works for base types, but is harder to solve for interfaces since we don't have a way to detect all places where a type may get converted to an interface. We could move the warning to the constructor but that would require producing the same warning from all constructors, which doesn't seem worthwhile. So I'm only planning to address this for the base type case.

We don't have a similar problem for #107660 because we don't allow RUC on interfaces.