He means that if you're using dynamic dispatch with polymorphism (aka
virtual methods), you don't necessarily know at compile time (and thus
in the assembly) which actual method will be called. You don't know this
because you don't know at compile time the actual type of the instance.
Discovering actual type for all instances requires solving the halting
problem, i.e. impossible.

Another thing not mentioned yet is reflection. Any method might be
called via reflection, and discovering which ones in all cases requires
solving the halting problem.

Here's an example. Trivial static analysis looking for call opcodes
won't find that C is constructed or that its Foo method is called (and
actually, in this case, C.Foo is called statically, not dynamically, due
to runtime generic instantiation in .NET).

---8<---
using System;
class App
{
   interface IFoo
   {
       void Foo();
   }
   class C : IFoo
   {
       public void Foo()
       {
           Console.WriteLine("Foo");
       }
   }
   
   static void CallFoo<T>()
       where T: IFoo, new()
   {
       new T().Foo();
   }
   
   static void Main()
   {
       CallFoo<C>();
   }
}
--->8---

Following IL produced for CallFoo<T>, no C methodref/defs:

---8<---
 .method private hidebysig static void  CallFoo<.ctor (App/IFoo) T>()
cil managed
 {
   // Code size       49 (0x31)
   .maxstack  2
   .locals init (!!T V_0)
   IL_0000:  nop
   IL_0001:  ldloca.s   V_0
   IL_0003:  initobj    !!T
   IL_0009:  ldloc.0
   IL_000a:  box        !!T
   IL_000f:  brfalse.s  IL_001c

   IL_0011:  ldloca.s   V_0
   IL_0013:  initobj    !!T
   IL_0019:  ldloc.0
   IL_001a:  br.s       IL_0021

   IL_001c:  call       !!0
[mscorlib]System.Activator::CreateInstance<!!0>()
   IL_0021:  stloc.0
   IL_0022:  ldloca.s   V_0
   IL_0024:  constrained. !!T
   IL_002a:  callvirt   instance void App/IFoo::Foo()
   IL_002f:  nop
   IL_0030:  ret
 } // end of method App::CallFoo
--->8---

Only type token required for Main method (in executable metadata
tables):

---8<---
 .method private hidebysig static void  Main() cil managed
 {
   .entrypoint
   // Code size       8 (0x8)
   .maxstack  8
   IL_0000:  nop
   IL_0001:  call       void App::CallFoo<class App/C>()
   IL_0006:  nop
   IL_0007:  ret
 } // end of method App::Main
--->8---

-- Barry