Sorry for the fairly lengthy post. I'm wondering if there are any suggested good practices in place for calling templated functions using the runtime type of an object, e.g. what typeid(object) returns.
Consider the following situation:

class Person {
	string name;
	int age;
}
class Boss : Person {
	int numEmployees;
}

string serialize(T)(T obj) {
	// ... iterate over fields and serialize stuff
	return join([FieldNameTuple!T], ",");
}

void main() {
	writeln(serialize(new Person)); // name,age
	writeln(serialize(new Boss)); // numEmployees
	writeln(serialize(cast(Person) new Boss)); // name,age
}

Naturally, when an object is instantiated as a Boss but the variable holding it is type Person, the version of the template that gets called is serialize!Person. It's especially common to run into this if, say, Person defined Person[] friends and that array was populated by various inherited subclasses that needed to be recognized (we also need to recursively serialize the members of the parent class, but that part's trivial so I'll skip it for now).

So, the first basic idea I came up with was using mixins in each serializable class:

mixin template Serializable() {
	static if (hasMember!(BaseClassesTuple!(typeof(this))[0], "serializeMe")) {
		override string serializeMe() {
			return serializeTrue(this);
		}
	} else {
		string serializeMe() {
			return serializeTrue(this);
		}
	}
}

class Person {
	string name;
	int age;
	mixin Serializable;
}
class Boss : Person {
	int numEmployees;
	mixin Serializable;
}

string serialize(T)(T obj) {
	return obj.serializeMe();
}
private string serializeTrue(T)(T obj) {
	// ...
	return join([FieldNameTuple!T], ",");
}

void main() {
	writeln(serialize(new Person)); // name,age
	writeln(serialize(new Boss)); // numEmployees
	writeln(serialize(cast(Person) new Boss)); // numEmployees
}

This works, but I kind of don't like using mixins for this for some reason. It feels less obvious that the class itself has been identified as something serializable, and you never know what additional methods or fields the mixin might be declaring.

I'd prefer to use UDAs, so I came up with something like:

enum Serializable;
@Serializable class Person {
	string name;
	int age;
}
@Serializable class Boss : Person {
	int numEmployees;
}

string serialize(Object obj) {
	string runtimeTypeName = typeid(obj).name;
	static foreach (sym; getSymbolsByUDA!(test_serialize, Serializable)) {
		if (fullyQualifiedName!sym == runtimeTypeName)
			return serializeTrue(cast(sym) obj);
	}
	assert(false, "Unable to serialize type: "~runtimeTypeName);
}
private string serializeTrue(T)(T obj) {
	// ...
	return join([FieldNameTuple!T], ",");
}

void main() {
	writeln(serialize(new Person)); // name,age
	writeln(serialize(new Boss)); // numEmployees
	writeln(serialize(cast(Person) new Boss)); // numEmployees
}

This also works, but it has a problem. We pass the current module directly to getSymbolsByUDA (test_serialize.d), but if we have classes spread across multiple modules, we need some way to iterate through those as well. Unfortunately I couldn't find any trait related to iterating through all the modules compiled into a project. Could an allModules or such thing be added? Or is this non-trivial to the compilation process?

So, I ultimately came up with the following. It requires some instantiation at runtime to create lookup tables between real type templates and typeid values, and requires a mixin of a mixin since I couldn't find a way to get the module of a symbol as an alias (no moduleOf!symbol trait?), but it seems to get the job done (also, I finally went and added the recursive parent class serialization):

enum Serializable;
@Serializable class Person {
	string name;
	int age;
}
@Serializable class Boss : Person {
	int numEmployees;
}

mixin template RegisterSerializer(alias MODULE) {
	void RegisterSerializer() {
		static foreach (SYM; getSymbolsByUDA!(MODULE, Serializable))
			static if (is(SYM == class))
				serialTypes[fullyQualifiedName!SYM] = new SerialType!SYM;
	}
}
abstract class SerialTypeBase {
	string encodeObject(Object obj);
}
final class SerialType(T) : SerialTypeBase {
	override string encodeObject(Object obj) {
		return serializeTrue(cast(T) obj);
	}
}

void[0][string] registeredModules;
SerialTypeBase[string] serialTypes;

string serialize(T)(T obj) {
	enum string MODULENAME = moduleName!T;
	if (MODULENAME !in registeredModules) {
		registeredModules.require(MODULENAME);
		mixin("mixin RegisterSerializer!"~MODULENAME~";");
		RegisterSerializer();
	}

	string runtimeTypeName = typeid(obj).name;
	if (auto st = runtimeTypeName in serialTypes) {
		return st.encodeObject(obj);
	}
	assert(false, "Unable to serialize type: "~runtimeTypeName);
}
private string serializeTrue(T)(T obj) {
	// ...
	alias PARENT = BaseClassesTuple!(T)[0];
	static if (hasUDA!(PARENT, Serializable))
		return join([serializeTrue(cast(PARENT) obj), FieldNameTuple!T], ",");
	else
		return join([FieldNameTuple!T], ",");
}

void main() {
	writeln(serialize(new Person)); // name,age
	writeln(serialize(new Boss)); // name,age,numEmployees
	writeln(serialize(cast(Person) new Boss)); // name,age,numEmployees
}

Now it should be able to handle any class marked as @Serializable regardless of module. So.. are there any better ways to do this? I glanced through some of the other serialization modules in D (orange) but it didn't look like any of them were doing anything like this. Did I miss something much simpler? It feels like there ought to be something inherent in TypeInfo that would let me get away with all this.