Difference between revisions of "cpp/experimental/reflect"

Latest revision as of 01:08, 1 December 2023

The C++ Extensions for Reflection, ISO/IEC TS 23619:2021, specifies modifications to the core language and defines new components for the C++ standard library listed on this page.

The Reflection TS is based on the C++20 standard (except that the definition of concepts are specified in the style of Concepts TS).

[edit] Core language changes

[edit] reflexpr-specifier

A reflexpr-specifier is of form reflexpr ( reflexpr-operand ), and specifies a meta-object type (see below).

reflexpr-operand can be one of following:

where function-call-expression is

and functional-type-conv-expression are following sorts of expressions which perform explict cast:

The operand to the reflexpr-specifier shall be a type, namespace, enumerator, variable, data member, function parameter, captured entity, function-call-expression or functional-type-conv-expression, and parenthesized expression. reflexpr(::) reflects the global namespace.

For a reflexpr-operand of form ( expression ), the expression shall be a (possibly multi-parenthesized) function-call-expression or functional-type-conv-expression.

If an unparenthesized operand can be treated as either a type-id or a functional-type-conv-expression, then it is treated as a type-id. Parenthesizes can be used for disambiguation between function-style cast and a type-id. For example, given a class type X with default constructor, reflexpr(X()) reflects the function type X(), and reflexpr((X())) reflects the expression X().

If the operand designates both an alias and a class name, the type represented by the reflexpr-specifier reflects the alias and satisfies reflect::Alias.

If the operand designates a name whose declaration is enclosed in a block scope and the named entity is neither captured nor a function parameter, the program is ill-formed.

[edit] Meta-object types

A meta-object type is an unnamed, incomplete namespace-scope class type. A type satisfies the concept reflect::Object if and only if it is a meta-object type. Meta-object types may satisfy other concepts, depending on the operand to reflexpr.

It is unspecified whether repeatedly applying reflexpr to the same operand yields the same type or a different type. If a meta-object type reflects an incomplete class type, certain type transformations cannot be applied.

A meta-object type allows inspection of some properties of the operand to reflexpr through type traits or type transformations on it.

[edit] Overload resolution

If the postfix-expression of the function-call-expression is of class type, i.e. e in the function-call-expression e(args) is of class type, then the user-defined conversion function of the type of the postfix-expression (e) shall not be used.

If postfix-expression is not of class type, it shall name a function that is the unique result of overload resolution.

struct Functor
{
    void operator()(int) const;
 
    using fptr_t = void(*)(std::nullptr_t);
    operator fptr_t() const;
};
 
using Meta0 = reflexpr(Functor{}(0));          // OK
// using Meta1 = reflexpr(Functor{}(nullptr)); // error: conversion function used

[edit] Reflection-related

An alias is a name introduced by a typedef declaration, an alias-declaration, or a using-declaration.

An entity or alias B is reflection-related to an entity or alias A if

1. A and B are the same entity or alias,
2. A is a variable or enumerator and B is the type of A,
3. A is an enumeration and B is the underlying type of A,
4. A is a class and B is a member or base class of A,
5. A is a non-template alias that designates the entity B,
6. A is not the global namespace and B is an enclosing class or namespace of A,
7. A is the parenthesized expression ( B ),
8. A is a lambda capture of the closure type B,
9. A is the closure type of the lambda capture B,
10. B is the type specified by the functional-type-conv-expression A,
11. B is the function selected by overload resolution for a function-call-expression A,
12. B is the return type, a parameter type, or function type of the function A, or
13. B is reflection-related to an entity or alias X and X is reflection-related to A.

Reflection-relation relationship is reflexive and transitive, but not symmetric.

Informally speaking, the case that B is reflection-related to A means that B participates in the declaration or definition of A.

Zero or more successive applications of type transformations that yield meta-object types to the type denoted by a reflexpr-specifier enable inspection of entities and aliases that are reflection-related to the operand; such a meta-object type is said to reflect the respective reflection-related entity or alias.

struct X;
struct B
{
    using X = ::X;
    typedef X Y;
};
struct D : B
{
    using B::Y;
};
// ::X, but not B::X or B::Y is reflection-related to D::Y

[edit] Miscellaneous

• An expression used as reflexpr-operand is an unevaluated expressions and potentially constant evaluated.
• For the purpose of determination of variables captured in a lambda expression by a capture-default, a reflexpr operand is not considered to be an unevaluated operand.
• A function or variable of static storage duration reflected by meta-object type T is odr-used by the specialization std::experimental::reflect::get_pointer<T>, as if by taking the address of an id-expression nominating the function or variable.
• There can be more than one definition of a meta-object type, as long as all operations on this type yield the same constant expression results.
• A type is dependent if it is denoted by a reflexpr-specifier, and the operand
  • is a type-dependent expression or a (possibly parenthesized) functional-type-conv-expression with at least one type-dependent immediate subexpression, or
  • designates a dependent type or a member of an unknown specialization or a value-dependent constant expression.

[edit] Keywords

reflexpr

[edit] Predefined feature testing macros

[edit] Library support

[edit] Concepts

[edit] Meta-object operations

[edit] Library feature testing macros

[edit] Satisfaction of concepts

The following table lists that whether a meta-object type reflecting an operand satisfies concepts introduced by the Reflection TS.

If the operand of the form id-expression is a constant expression, the type specified by the reflexpr-specifier also satisfies reflect::Constant.

If the reflexpr-operand designates a class member, the type represented by the reflexpr-specifier also satisfies reflect::RecordMember.

[edit] See also