For all of the class templates X declared in this subclause,
instantiating that template with a template-argument that is a class
template specialization may result in the implicit instantiation of
the template argument if and only if the semantics of X require that
the argument is a complete type.

For the purpose of defining the templates in this subclause,
a function call expression declval<T>() for any type T
is considered to be a trivial ([basic.types], [special]) function call
that is not an odr-use of declval
in the context of the corresponding definition
notwithstanding the restrictions of [declval].

T is a class type, but not a union type, with no non-static data
members other than subobjects of zero size, no virtual member functions,
no virtual base classes, and no base class B for
which is_­empty_­v<B> is false.

The compilation of the
expression can result in side effects such as the instantiation of class template
specializations and function template specializations, the generation of
implicitly-defined functions, and so on.

Such side effects are not in the “immediate
context” and can result in the program being ill-formed.

The expressions swap(declval<T>(), declval<U>()) and
swap(declval<U>(), declval<T>()) are each well-formed
when treated as an unevaluated operand
in an overload-resolution context
for swappable values ([swappable.requirements]).

The compilation of the expressions can result in side effects
such as the instantiation of class template specializations and
function template specializations,
the generation of implicitly-defined functions, and so on.

Such side effects are not in the “immediate context” and
can result in the program being ill-formed.

The predicate condition for a template specialization
is_­constructible<T, Args...> shall be satisfied if and only if the
following variable definition would be well-formed for some invented variable t:

The evaluation of the
initialization can result in side effects such as the instantiation of class
template specializations and function template specializations, the generation
of implicitly-defined functions, and so on.

Such side effects are not in the
“immediate context” and can result in the program being ill-formed.

any two objects of type T with the same value
have the same object representation, where
two objects of array or non-union class type are considered to have the same value
if their respective sequences of direct subobjects have the same values, and
two objects of union type are considered to have the same value
if they have the same active member and the corresponding members have the same value.

The set of scalar types for which this condition holds is
implementation-defined.