21 Metaprogramming library [meta]

21.4 Reflection [meta.reflection]

21.4.8 Member accessibility queries [meta.reflection.access.queries]

consteval bool is_accessible(info r, access_context ctx);

Let PARENT-CLS(r) be:

(1.1)
If parent_of(r) represents a class C, then C.
(1.2)
Otherwise, PARENT-CLS(parent_of(r)).

Constant When:

(2.1)
r does not represent a class member for which PARENT-CLS(r) is an incomplete class and
(2.2)
r does not represent a direct base class relationship $(D, B)$ for which D is incomplete.

Let DESIGNATING-CLS(r, ctx) be:

(3.1)
If ctx.designating_class() represents a class C, then C.
(3.2)
Otherwise, PARENT-CLS(r).

Returns:

(4.1)
If r represents an unnamed bit-field F, then is_accessible( $r_{H}$ , ctx), where $r_{H}$ represents a hypothetical non-static data member of the class represented by PARENT-CLS(r) with the same access as F.

[Note 1:
Unnamed bit-fields are treated as class members for the purpose of is_accessible.
— end note]
(4.2)
Otherwise, if r does not represent a class member or a direct base class relationship, then true.
(4.3)
Otherwise, if r represents
- (4.3.1)
  a class member that is not a (possibly indirect or variant) member of DESIGNATING-CLS(r, ctx) or
- (4.3.2)
  a direct base class relationship such that parent_of(r) does not represent DESIGNATING-CLS(r, ctx) or a (direct or indirect) base class thereof,
then false.
(4.4)
Otherwise, if ctx.scope() is the null reflection, then true.
(4.5)
Otherwise, letting P be a program point whose immediate scope is the function parameter scope, class scope, or namespace scope corresponding to the function, class, or namespace represented by ctx.scope():
- (4.5.1)
  If r represents a direct base class relationship $(D, B)$ , then true if base class B of DESIGNATING-CLS(r, ctx) is accessible at P ([class.access.base]); otherwise false.
- (4.5.2)
  Otherwise, r represents a class member M; true if M would be accessible at P with the designating class ([class.access.base]) as DESIGNATING-CLS(r, ctx) if the effect of any using-declarations ([namespace.udecl]) were ignored.
  
  Otherwise, false.

[Note 2:

The definitions of when a class member or base class is accessible from a point P do not consider whether a declaration of that entity is reachable from P.

— end note]

[Example 1: consteval access_context fn() { return access_context::current(); } class Cls { int mem; friend consteval access_context fn(); public: static constexpr auto r = ^^mem; }; static_assert(is_accessible(Cls::r, fn())); // OK static_assert(!is_accessible(Cls::r, access_context::current())); // OK static_assert(is_accessible(Cls::r, access_context::unchecked())); // OK — end example]

🔗

consteval bool has_inaccessible_nonstatic_data_members(info r, access_context ctx);

Constant When:

(5.1)
nonstatic_data_members_of(r, access_context::unchecked()) is a constant subexpression and
(5.2)
r does not represent a closure type.

Returns: true if is_accessible(R, ctx) is false for any R in nonstatic_data_members_of(r, access_context::unchecked()).

Otherwise, false.

🔗

consteval bool has_inaccessible_bases(info r, access_context ctx);

Constant When: bases_of(r, access:context::unchecked()) is a constant subexpression.

Returns: true if is_accessible(R, ctx) is false for any R in bases_of(r, access_context::unchecked()).

Otherwise, false.

🔗

consteval bool has_inaccessible_subobjects(info r, access_context ctx);

Effects: Equivalent to: return has_inaccessible_bases(r, ctx) || has_inaccessible_nonstatic_data_members(r, ctx);