Mutation of a mutable data-member via pointer-to-member - c++

Question

The Standard provide the following note:
[ Note: it is not possible to use a pointer to member that refers to a
mutable member to modify a const class object. For example,
struct S {
S() : i(0) { }
mutable int i;
};
void f()
{
const S cs;
int S::* pm = &S::i; // pm refers to mutable member S::i
cs.*pm = 88; // ill-formed: cs is a const object
}
-end note]
But we can use just object-expression to modify const object which has a mutale data member.
#include <iostream>
struct A
{
A(){ }
mutable int a;
};
const A a;
int main()
{
a.a = 4;
std::cout << a.a; //4
}
DEMO
But ISO/IEC Derictive tells
Notes and examples integrated in the text of a document shall only be
used for giving additional information intended to assist the
understanding or use of the document. They shall not contain
requirements ("shall"; see 3.3.1 and Table H.1) or any information
considered indispensable for the use of the document [...]
Which means the note I provide at the beginning of my Q is not a requirement.
I'm looking for a normative requirement explcitly precludes such using.

Answer 1

Just before that note you will find the following:
The restrictions on cv-qualification, and the manner in which the cv-qualifiers of the operands are combined to produce the cv-qualifiers of the result, are the same as the rules for E1.E2 given in 5.2.5
Jump up to 5.2.5 and you'll find this:
If E2 is a non-static data member and the type of E1 is “cq1 vq1 X”, and the type of E2 is “cq2 vq2 T”, the expression designates the named member of the object designated by the first expression. If E1 is an lvalue, then E1.E2 is an lvalue; otherwise E1.E2 is an xvalue. Let the notation vq12 stand for the “union” of vq1 and vq2; that is, if vq1 or vq2 is volatile, then vq12 is volatile. Similarly, let the notation cq12 stand for the “union” of cq1 and cq2; that is, if cq1 or cq2 is const, then cq12 is const. If E2 is declared to be a mutable member, then the type of E1.E2 is “vq12 T”. If E2 is not declared to be a mutable member, then the type of E1.E2 is “cq12 vq12 T”.
The union of the const qualifiers in cs.*pm is const, the exception for mutable members doesn't apply to pointers.
It's easier to understand if you consider that storage class specifiers are not part of the type, so how would the compiler be able to distinguish between mutable and non-mutable pointers to member?
struct S;
void f(const S& s, int S::* pm)
{
s.*pm = 1; // How do I know if pm points to a mutable member? S isn't even defined!
}
Simply put, there is no such thing as a pointer to a mutable member, just as there is no such thing as a pointer to a static member, the pointed type's storage class is unknown (the type can only be qualified by const and / or volatile).