extern (C++) including bodies of member functions?

[cy via Digitalmars-d-learn]

I would never (ever) do this myself, but trying to understand 
dmd, the code is absolutely packed with things like this:

extern(C++) class Package : ScopeDSymbol
{
...
   override const(char)* kind() const
   {
      return "package";
   }
...
   override final inout(Package) isPackage() inout
   {
      return this;
   }
...etc...
}

How exactly does that... work? Is the body of such a member 
function written in the D Programming Language? Or is it some 
weird hybrid of D and C++ that just has a human programmer brain 
taking into account all the times that differing name mangling 
might produce different code? I mean, Package.resolve for 
instance is a non-trivial function. Can you not use templates 
inside such a function? Can you only use other "extern(C++)" 
types? Can you import from other modules, inside such a function?

The documents say nothing about this, only defining their 
examples as stubs, like
extern(C++) class Foo {
   void bar();
}

The documentation also avoids any memory allocation in D, instead 
assuming C++ routines like createInstance to use malloc to 
allocate the classes. But the code in dmd makes extensive use of 
things like this:
extern(C++) ... {
   final extern(D) this(...) { ... }
}

How would you create new objects of types that are declared 
extern(C++)? Just new, and mark the constructor as extern(D)?

I realize DMD is a horrible program that was Frankensteined from 
C++ code ages ago and is practically still C++ itself, and that 
DMD has to have /full/ control of symbol mangling, but it is also 
sort of important, not just as a D compiler, but as one of the 
only programs left in the world that produces optimized assembly, 
rather than passing it on to gcc or LLVM. So, understanding it is 
kind of an interest of mine.