Typedef (alias) reflection

[matus-chochlik]

Let's have the following:

enum E { x, y, z };

typedef F E;
typedef F G;

template <typename T>
struct S {
    typedef T type;
    typedef reflexpr(T) mtype;
    T x;
    void foo(void);
};

Alternatives for alias reflection:

A) (my new favorite)

Concepts:

• /meta-Named/ -- anything named (/meta-Type/, /meta-Namespace/, ...)
• /meta-Aliased/ -- a /meta-Named/ with a known alias
• /meta-Alias/ -- a /meta-Named/ reflecting an alias of a named declaration
• /meta-TemplateParameter/ -- is a /meta-Alias/

For reflected typedef both a /meta-Alias/ and a /meta-Aliased/ are also a /meta-Type/ so all type-related operations apply to them, just like a /typedef/ is still a /type/.

Operations:

• get_name<meta::Named> -- returns the 'basic' (without any qualifiers), 'standard', platform-independent name usable for parsing, etc.
• get_display_name<meta::Named> -- returns a 'nice', compiler-specific, human-readable name
• get_aliased<meta::Alias> -> meta-Aliased -- goes from an alias (typedef) to the most basic aliased declaration.
• get_alias<meta::Aliased> -> meta-Alias -- goes from aliased (the most basic thing) to its known alias.

Rules:

• the only platform-independent way to obtain a meta-Alias is by directly reflecting a typedef (or namespace alias):

using MAs = reflexpr(std::size_t); // (always a) meta-Alias

also:

template <typename T>
void S<T>::foo(void) {
    using MTp = reflexpr(T); // meta-TemplateParameter (meta-Alias)
}

• get_name<meta::Alias> returns the alias/typedef name:

using MAs = reflexpr(std::size_t); // meta-Alias
get_name_v<MAs>; // "size_t"

template <typename T>
void S<T>::foo(void) {
    using MTp = reflexpr(T); // meta-TemplateParameter (meta-Alias)
    get_name_v<MTp>; // "T"
}

• get_name<meta::Aliased> returns the most basic underlying declaration name:

using MAs = reflexpr(std::size_t); // meta-Alias
using MAd = get_aliased_m<MAs>; // meta-Aliased
get_name_v<MAd>; // "unsigned" (or whatever)

• meta-Type can (optionally) be a meta-Aliased (if the compiler maintains the typedef information. This is platform-dependent. For compilers where the typedef information is lost the meta-Type is not a meta-Aliased)

void S<G>::foo(void) {
    using Mx = reflexpr(x); // meta-DataMember
    using MT = get_type_m<Mx>; // meta-Type (possibly meta-Aliased)
    constexpr_if(Aliased<MT>) {
        using MAs = get_alias_m<MT>; // meta-Alias (explicitly obtained from a meta-Aliased)
        get_name_v<MAs>; // "T" -- the 'topmost' alias name
    } constexpr_else {
        get_name_v<MT>; // "E" -- the most basic type name
    }
}

Pros: The /meta-Alias/ ties together information about:

• the alias name
• the scope where the alias was defined
• the source location
• possibly more ...

and it allows to use the same functions as with /meta-Named/ -- no duplication:

using MetaNamed = reflexpr(S<G>::type);
using MetaAliasT = S<G>::mtype;
using MetaAliasG = reflexpr(G);

get_name_v<MetaNamed> // "E" (since: type -> T -> G -> F -> E)
get_name_v<MetaAliasT> // "T"
get_name_v<MetaAliasG> // "G"

get_scope_m<MetaNamed> // the global scope
get_scope_m<MetaAliasT> // the S<G> class
get_scope_m<MetaAliasG> // the global scope

get_source_line_v<MetaNamed> // 8
get_source_line_v<MetaAliasT>   // 6
get_source_line_v<MetaAliasG>  // 4

---

TODO: to be finished

[ricardofandrade]

A few questions that can be responded when the TODO is taken care of:

• What is "the 'basic' (without any qualifiers), 'standard', platform-independent name"? std::string = "string"? Well, that's a typedef... int = "int"?
• What is "a 'nice', compiler-specific, human-readable name"? "my::multi::nested::ns::type"? Examples may clarify it.
• I found the MetaAliased vs. MetaAlias confusing. If there was just MetaAlias, the meaning is quite obvious, it's a typedef. Now, MetaAliased may be misleading - is it the original type? the most basic type? something context-dependent and error-prone I should not rely on unless I need to? ... perhaps a different name for MetaAliased would help such as MetaDeclaredType?
• Regarding the rules, if I have a variable of size_t, is its type an alias (size_t) or the most basic type (unsigned or whatever)? If it's size_t, there's more ways to obtain it then. Otherwise, that's no a very useful information since I can't obtain size_t anywhere else. Let's say, serializing variables of such alias may be problematic - to transfer the info about the platform independent type. I'm aware of some discussion around this.
• Regarding MetaTemplateParameter, I have the impression the compilers always know the original (aliased) type of the argument passed to a template, at least for diagnostics. Anyway, I would expect to be able to obtain an alias (size_t) from the reflected parameter. Knowing reflection will be used through templates all the time, wouldn't the behavior explained here make get_name_v for types too limited?
• Based on the explanation, the example seems wrong to me. Wouldn't the result of get_name_v<MetaNamed> be actually the alias "type"?
• I assume there's no difference between typedef vs. using aliases for the same type, is that right?
• It seems the fact that some compiler vendors do not keep any information about the aliases is making things difficult. On top of that, if platform-dependent behavior could be eliminated, that would be the best. How hard would it be to propose compilers to keep tabs on the aliases? It would be great if at least going step-by-step were possible. Following your example: type -> T -> G -> F -> E where type knows it is an alias of T but it knowns nothing about the others in the chain of aliases, T knows it is actually G and so on... of course at any point it would be possile to tell that any them are actually E and that E is not an alias.