This seems much broader than the rule in /2.2. This would also remove the access in:

struct X { int a; };
constexpr X x = {1};
int n = (&x)->a;

... which currently does result in an odr-use of x and an access. Changing that doesn't seem editorial.

Can we make the words here more directly refer back to the /2.2 case somehow? Maybe something like:

\item Otherwise, if $E$ is potentially evaluated and the object designated by $E$ is not accessed, as specified above, the designated object is necessarily usable in constant expressions ([expr.const]) and the result is the value of that object.

(I don't like "is necessarily" here. Do we have another way to say "must be" without making ISO angry?)

Or maybe we could inline /2 into these bullets?

This also has interactions with the very definition of "lvalue":

struct S
{
     static const int a = 1;
};

int main()
{
     return S::a;  // no odr-use; no definition of S::a needed
}

[intro.object] p1 "An object is created by a definition (6.2) ..."

[basic.lval] p1 "A glvalue is an expression whose evaluation determines the identity of an object or function.

How can you identify an object that wasn't ever created (because there is no definition)?

http://lists.isocpp.org/core/2021/02/10513.php

I think it works best to integrate p2 into the "result" bullets.

Maybe say the result is the value of \tcode{x}'s initializer. in non-odr-used variable case? Variable is not an object, it doesn't have value.

BTW

struct S
{
	int m;
};

int main()
{
	&S::m;
}

[expr.prim.id.qual] says that a qualified-id denoting data member is an lvalue, but I don't think S::m in &S::m can denote an object. Even though we have pointer-to-member, IIUC S::m is still an lvalue there, which makes me feel uncomfortable. Should this be a Core issue? 🤔

Maybe say the result is the value of \tcode{x}'s initializer. A variable that is usable in constant expressions does not always have an initializer

A variable or temporary object o is constant-initialized if.

• either it has an initializer or its default-initialization results in some initialization being performed

struct A{
    int v = 1;
};