A template parameter object does have storage and lifetime, but it is seemly not considered as a variable. Template parameter objects and constexpr variables of object types have some common properties: both of them are usable in constant expressions, and shall have constant destruction. Currently these properties are repeatedly specified.

I guess we should say that all NTTPs are not variables, or more precisely, declaration of a non-type template-parameter does not introduce an object or a reference (related to #82). And then we may specify that they (as _id-expression_s) are prvalues with some values or lvalues denoting some objects or functions (for scalar or non-scalar NTTPs respectively).

(So that the original problem might be resolved in the way that a NTTP of a reference type is not itself a reference, it's just a glvalue constant expression denoting an object or a function.)

From a more general way, I think most issues I recently submit here regarding the parameter-declarations that appear as template parameters are actually the core issue: which declaration declares variable.

I agree with the opinion that all NTTP should not be a variable.

A template parameter object does have storage and lifetime, but it is seemly not considered as a variable.

This is a bit contradictory to the definition of the variable. [basic.pre] p6 says

A variable is introduced by the declaration of a reference other than a non-static data member or of an object.
The variable's name, if any, denotes the reference or object.

[temp.param] p8 says

An id-expression naming a non-type template-parameter of class type T denotes a static storage duration object of type const T, known as a template parameter object

we say the template parameter object denotes an object with static storage duration, and we say the id-expression(its name) denotes that object, which is exactly what the definition of variable tries to say.

Another thing that should be noticed is, the parameter-declaration that appears in template-parameter is still a declaration. [basic.def] p1 says

A declaration may (re)introduce one or more names and/or entities into a translation unit.

Either the declaration only introduces a name(like a typedef declaration) or it introduces a name and entity. What does a parameter-declaration as a template parameter do? Does it introduce the name and entity? In the current, we say

An entity is a value, object, reference, structured binding, function, enumerator, type, class member, bit-field, template, template specialization, namespace, or pack.

If the parameter-declaration(as a template parameter) declares an entity, which one does it declare if we admit that the parameter-declaration is not a variable? This should be clarified.

CWG2983