1. modify the D2 opDot semantic from forwarding to compiletime opDot function calling
2. modify the D2 __traits(getallmembers) to return tuples.
in the patch, it's currently organized as:
(member_name, member_symbol) pair 

Thus, by the 1st change we can have following code working:
import std.stdio;
class c
{
    
    B opDot(U:immutable(char)[], T...)(U methodname, T t)
    {
    	writefln("god it works ", methodname);
      return new B();
    }
    void opAdd(int j)
    {
      
    }
    void test()
    {
    }
}

class B
{
  int i;
  B opAssign(int k){
    i=k;
    return this;
  }
}

void extmethod(c v,int j){writefln("extmenthod!");}

char[] v1;

void func(char[] v, ...){}

void main()
{
   c v=new c;
   v.opDot("jesus", 3,4);
   v.test();
   v.dynamicmethod(3,4);
   //v.qq(1,2) = 5;
   writefln((v.qq(1,2) = 5).i);
   v.extmethod(3);
   
}

By the second change we can have the following code working:
import std.stdio;
class D
{
    int tt;
    alias tt this;
    this() { }
    ~this() { }
    int foo(int) { tt++;writefln("god you called me?");return 0; }
    void foo() { }
    int vvv;
}

class M:D
{
  void callfunc()
  {
  pragma(msg, __traits(allMembers, D)[0]);
  pragma(msg, __traits(allMembers, D)[2]);
  pragma(msg, __traits(allMembers, D)[6]);
      __traits(allMembers, D)[7](1);
      writefln("tt should be 1 now ",tt);
  }
}

void main()
{
    auto b = ["__ctor","__dtor","foo","toString","toHash","opCmp","opEquals","Monitor","factory"];
    M subd= new M;
		subd.callfunc();
    writefln(subd.tt);
}

The second change provides richer functionality while we can still achieve the old result by templates wrapping the __traits.

original opDot semantic can be simulated by the 1st and 2nd change together.

Thus I think the semantic change provides richer functionality while on the other hand we can still mock the old behavior.