ILLink: Trimmer will map matching public virtual methods as implementations of interface methods when a MethodImpl for the interface method exists on the type

[jtschuster]

The trimmer will look for the first method with a matching signature for an interface method implementation, even if there is a methodImpl for that method. This will keep the method, even though it's not needed.

		public static void Main ()
		{
			IFoo f = new FooWithImpl ();
			f.Method ();
			f = new FooWithBase ();
			f.Method ();
		}

		[Kept]
		interface IFoo
		{
			[Kept]
			void Method ();
		}

		[Kept]
		[KeptMember (".ctor()")]
		class BaseFoo
		{
			[Kept] // Should not be kept, but TypeMapInfo finds it as the first method with matching signature
			public virtual void Method ()
			{
			}
		}

		[Kept]
		[KeptMember (".ctor()")]
		[KeptBaseType (typeof (BaseFoo2))]
		[KeptInterface (typeof (IFoo))]
		class FooWithBase : BaseFoo, IFoo
		{
			[Kept]
			void IFoo.Method () { }
		}

		[Kept]
		[KeptInterface(typeof(IFoo))]
		class FooWithImpl : IFoo
		{
			[Kept]
			void IFoo.Method() { }
			[Kept] // Should not be kept
			public virtual void Method() { }
		}

[dotnet-policy-service]

Tagging subscribers to this area: @agocke, @sbomer, @vitek-karas
See info in area-owners.md if you want to be subscribed.

[MichalStrehovsky]

This case (and a couple others) are also tracked at dotnet/linker#1187.

It might be a better use of time to throw away the Cecil based interface/virtual method resolution and use the one from ILCompiler.TypeSystem. Both Cecil and the managed type system have a common language (the tokens) and it should be possible to switch back and forth between the two (in theory). We don't want to keep maintaining Cecil in the longer term.

It doesn't feel like a good use of time to invest more into the Cecil based algorithm because it has too many issues. This particular issue is not even a correctness issue, just extra size; we have correctness problems with it as well and there is a risk that as we make it tighter, people will start running into the correctness bugs (the imprecision here could be papering over the other bugs that choose wrong methods - the couple examples in the dotnet/linker issue are just things I could easily come up with in C# - there's many other issues on IL level and I'm not even a virtual method resolution expert).