13 Templates [temp]

13.8 Name resolution [temp.res]

13.8.2 Dependent names [temp.dep]

13.8.2.2 Type-dependent expressions [temp.dep.expr]

Except as described below, an expression is type-dependent if any subexpression is type-dependent.

this is type-dependent if the class type of the enclosing member function is dependent ([temp.dep.type]).

An id-expression is type-dependent if it is not a concept-id and it contains

(3.1)
an identifier associated by name lookup with one or more declarations declared with a dependent type,
(3.2)
an identifier associated by name lookup with a non-type template-parameter declared with a type that contains a placeholder type,
(3.3)
an identifier associated by name lookup with a variable declared with a type that contains a placeholder type ([dcl.spec.auto]) where the initializer is type-dependent,
(3.4)
an identifier associated by name lookup with one or more declarations of member functions of the current instantiation declared with a return type that contains a placeholder type,
(3.5)
an identifier associated by name lookup with a structured binding declaration whose brace-or-equal-initializer is type-dependent,
(3.6)
the identifier __func__ ([dcl.fct.def.general]), where any enclosing function is a template, a member of a class template, or a generic lambda,
(3.7)
a template-id that is dependent,
(3.8)
a conversion-function-id that specifies a dependent type, or
(3.9)
a nested-name-specifier or a qualified-id that names a member of an unknown specialization;

or if it names a dependent member of the current instantiation that is a static data member of type “array of unknown bound of T” for some T ([temp.static]).

Expressions of the following forms are type-dependent only if the type specified by the type-id, simple-type-specifier or new-type-id is dependent, even if any subexpression is type-dependent:

simple-type-specifier ( expression-list $_{o p t}$  )
:: $_{o p t}$  new new-placement $_{o p t}$  new-type-id new-initializer $_{o p t}$ 
:: $_{o p t}$  new new-placement $_{o p t}$  ( type-id ) new-initializer $_{o p t}$ 
dynamic_cast < type-id > ( expression )
static_cast < type-id > ( expression )
const_cast < type-id > ( expression )
reinterpret_cast < type-id > ( expression )
( type-id ) cast-expression

Expressions of the following forms are never type-dependent (because the type of the expression cannot be dependent):

literal
sizeof unary-expression
sizeof ( type-id )
sizeof ... ( identifier )
alignof ( type-id )
typeid ( expression )
typeid ( type-id )
:: $_{o p t}$  delete cast-expression
:: $_{o p t}$  delete [ ] cast-expression
throw assignment-expression $_{o p t}$ 
noexcept ( expression )

[ Note

For the standard library macro offsetof, see [support.types].

— end note

]

A class member access expression is type-dependent if the expression refers to a member of the current instantiation and the type of the referenced member is dependent, or the class member access expression refers to a member of an unknown specialization.

[ Note

In an expression of the form x.y or xp->y the type of the expression is usually the type of the member y of the class of x (or the class pointed to by xp).

However, if x or xp refers to a dependent type that is not the current instantiation, the type of y is always dependent.

If x or xp refers to a non-dependent type or refers to the current instantiation, the type of y is the type of the class member access expression.

— end note

]

A braced-init-list is type-dependent if any element is type-dependent or is a pack expansion.

A fold-expression is type-dependent.