21 Metaprogramming library [meta]

21.4 Reflection [meta.reflection]

21.4.8 Scope identification [meta.reflection.scope]

1
#
The functions in this subclause retrieve information about where in the program they are invoked.
2
#
None of the functions in this subclause is an addressable function ([namespace.std]).
3
#
Given a program point P, let eval-point(P) be the following program point:
  • (3.1)
    If a potentially-evaluated subexpression ([intro.execution]) of a default member initializer I for a member of class C ([class.mem.general]) appears at P, then a point determined as follows:
    • (3.1.1)
      If an aggregate initialization is using I, eval-point(Q), where Q is the point at which that aggregate initialization appears.
    • (3.1.2)
      Otherwise, if an initialization by an inherited constructor ([class.inhctor.init]) is using I, a point whose immediate scope is the class scope corresponding to C.
    • (3.1.3)
      Otherwise, a point whose immediate scope is the function parameter scope corresponding to the constructor definition that is using I.
  • (3.2)
    Otherwise, if a potentially-evaluated subexpression of a default argument ([dcl.fct.default]) appears at P, eval-point(Q), where Q is the point at which the invocation of the function ([expr.call]) using that default argument appears.
  • (3.3)
    Otherwise, if the immediate scope of P is a function parameter scope introduced by a declaration D, and P appears either before the locus of D or within the trailing requires-clause of D, a point whose immediate scope is the innermost scope enclosing the locus of D that is not a template parameter scope.
  • (3.4)
    Otherwise, if the immediate scope of P is a function parameter scope introduced by a lambda-expression L whose lambda-introducer appears at point Q, and P appears either within the trailing-return-type or the trailing requires-clause of L, eval-point(Q).
  • (3.5)
    Otherwise, if the innermost non-block scope enclosing P is the function parameter scope introduced by a consteval-block-declaration ([dcl.pre]), a point whose immediate scope is that inhabited by the outermost consteval-block-declaration D containing P such that each scope (if any) that intervenes between P and the function parameter scope introduced by D is either
  • (3.6)
    Otherwise, P.
4
#
Given a scope S, let ctx-scope(S) be the following scope:
  • (4.1)
    If S is a class scope or namespace scope, S.
  • (4.2)
    Otherwise, if S is a function parameter scope introduced by the declaration of a function, S.
  • (4.3)
    Otherwise, if S is a lambda scope introduced by a lambda-expression L, the function parameter scope corresponding to the call operator of the closure type of L.
  • (4.4)
    Otherwise, ctx-scope(), where is the parent scope of S.
5
#
Let CURRENT-SCOPE(P) for a point P be a reflection representing the function, class, or namespace whose corresponding function parameter scope, class scope, or namespace scope, respectively, is ctx-scope(S), where S is the immediate scope of eval-point(P).
🔗
consteval info current_function();
6
#
An invocation of current_function that appears at a program point P is value-dependent ([temp.dep.constexpr]) if eval-point(P) is enclosed by a scope corresponding to a templated entity.
7
#
Let S be CURRENT-SCOPE(P), where P is the point at which the invocation of current_function lexically appears.
8
#
Returns: S.
9
#
Throws: meta​::​exception unless S represents a function.
🔗
consteval info current_class();
10
#
An invocation of current_class that appears at a program point P is value-dependent ([temp.dep.constexpr]) if eval-point(P) is enclosed by a scope corresponding to a templated entity.
11
#
Let S be CURRENT-SCOPE(P) where P is the point at which the invocation of current_class lexically appears.
12
#
Returns: S if S represents a class.
Otherwise, parent_of(S).
13
#
Throws: meta​::​exception unless S represents either a class or a member function.
🔗
consteval info current_namespace();
14
#
An invocation of current_namespace that appears at a program point P is value-dependent ([temp.dep.constexpr]) if eval-point(P) is enclosed by a scope corresponding to a templated entity.
15
#
Let S be CURRENT-SCOPE(P) where P is the point at which the invocation of current_namespace lexically appears.
16
#
Returns: S if S represents a namespace.
Otherwise, a reflection representing the nearest enclosing namespace of the entity represented by S.