Until it's available as an engine feature, I've taken a stab at implementing the templated type-of object add_on as mentioned here. Note that this requires at least rev 2043 for an engine bugfix.

I register it into a custom namespace as follows:

engine->SetDefaultNamespace("myns");
RegisterScriptType(engine);
engine->SetDefaultNamespace("");

New Types

myns::typeid

class Foo {}
Foo foo;
 
void main()
{
    myns::typeid t = myns::typeof(foo);
 
    // implicitly convertible to a string
    print("type of t is: " + t);
 
    if ( t == myns::type<Foo>() )
        print("matches");
}

myns::type<T>

class Foo {}
 
void main()
{
    myns::type<Foo> typeOfFoo;
    myns::type<int> typeOfInt;
 
    // implicitly convertible to a string (or a myns::typeid for comparisons)
    print("Type of Foo is: " + typeOfFoo);
    print("Type of int is: " + typeOfInt);
}

New global functions

myns::typeid myns::typeof()

interface Base {}
class Derived : Base {}
 
Derived gDerived;
Base@ gBase = @gDerived;
 
void main()
{
    myns::type<Base>    typeOfBase;
    myns::type<Derived> typeOfDerived;
 
    print( myns::typeof(gDerived) == typeOfBase    ? "yes" : "no" );  // no
    print( myns::typeof(gDerived) == typeOfDerived ? "yes" : "no" );  // yes
    print( myns::typeof(gBase) == typeOfBase       ? "yes" : "no" );  // yes
    print( myns::typeof(gBase) == typeOfDerived    ? "yes" : "no" );  // no
 
    myns::mynsSprite@ anim = ...;
    if ( myns::typeof(anim) == myns::type<myns::Animation2d>() )
        print("It's an animation");
}

string myns::classname()

class Base
{
    Base() { print("constructing a: " + myns::classname(this)); }
}
 
class Derived : Base
{
    Derived() { print("constructing a: " + myns::classname(this)); }
}
 
void main()
{
    Derived derived;
    // "constructing a: Base"
    // "constructing a: Derived"
}

Also, why this line?
assert( strstr(asGetLibraryOptions(), "AS_MAX_PORTABILITY") == 0 );

I didn't implement generic calling convention because I happen to not use it.

Can you try the latest version of the library?

Here is my currently reflection stuff:

http://codepad.org/NkoNgRWI

http://codepad.org/eFOvrqPd (in end of this file you can find all API of reflection stuff)

Usage:

class A {}
class B : A { }

void main()
{
	// type can be retrieved by typeof call
	reflection::type t1 = reflection::typeof<A>();
	
	// also we can retrieve real type of class by passing reference as argument
	A@ aa = B();
	reflection::type t2 = reflection::typeof<A>(aa);
	t2 == reflection::typeof<B>(); // true
	
	// generic stuff
	reflection::type t = reflection::typeof<B>();
	t.derivesFrom(reflection::typeof<A>()); // true
	t.isEnum; // false
	t.isClass; // true
	t.propertiesCount; // 0
	t.nameWithoutNamespace; // B
	// etc
	
	// instantiation of derived types by base part
	A@ a = B();
	A@ b = clone(a);
	reflection::type tA = reflection::typeof<A>(a);
	reflection::type tB = reflection::typeof<A>(b);
	tA == tB; // true
}

A@ clone(A@ a)
{
	A@ newObj;
	reflection::typeof<A>(a).instantiate(@a, @newObj);
	return newObj; // here will be instance of class B, not A
} 

Maybe this helps to somebody.

If Andreas interested in this implementation, than I can format it to common AS code style (formatting, add generic calling convention) for future publication as add-on.