Совместимость макета в стандарте С++ 11 (рабочий проект) слишком слаба?

Три Foo совместимы по макету, поскольку они имеют один и тот же тип, struct ::Foo.

[основные.типы]

11 - Если два типа T1 и T2 одного типа, то T1 и T2 являются типами, совместимыми с компоновкой.

Классы одного типа, потому что они имеют одно и то же (полное) имя и имеют внешнюю связь:

[базовый]

9. Имя, используемое более чем в одной единице перевода, потенциально может относиться к одному и тому же объекту в этих единицах перевода в зависимости от связи (3.5) имени, указанного в каждой единице перевода.

Имена классов, объявленные в области пространства имен, которые не объявлены (рекурсивно) в безымянном пространстве имен, имеют внешнюю связь:

[основная.ссылка]

2. Говорят, что имя имеет связь, если оно может обозначать [...] тот же тип [...], что и имя, введенное объявлением в другой области:
— когда имя имеет внешнюю связь, на объект, который он обозначает, можно ссылаться по именам из областей действия других единиц перевода или из других областей действия той же единицы перевода. [...]
4 - Безымянное пространство имен или пространство имен, объявленное прямо или косвенно в безымянном пространстве имен, имеет внутреннюю связь. Все остальные пространства имен имеют внешнюю связь. Имя, имеющее область пространства имен, для которой не была задана внутренняя связь выше, имеет ту же связь, что и окружающее пространство имен, если оно является именем [...]
— именованного класса (пункт 9) или определенного безымянного класса. в объявлении typedef, в котором класс имеет имя typedef для целей компоновки (7.1.3) [...]

Обратите внимание, что разрешено иметь несколько определений типа класса, появляющихся в разных единицах перевода, если определения состоят из одной и той же последовательности токенов:

[базовый.def.odr]

6 - В программе может быть более одного определения типа класса (пункт 9) [...] при условии, что каждое определение появляется в другой единице перевода, и при условии, что [...] каждое определение [...] должны состоять из той же последовательности токенов [...]

Таким образом, если бы у Foo были разные имена, они не были бы одного типа; если бы они появились в анонимном пространстве имен или в определении функции (кроме встроенной функции; см. [dcl.fct.spec]/4), у них не было бы внешней связи и так что не будет того же типа. В любом случае они будут совместимы с макетом только в том случае, если они будут стандартного макета.

Некоторые примеры:

// tu1.cpp
struct Foo { private: int i; public: int j; };

// tu2.cpp
struct Foo { private: int i; public: int j; };

Два Foo одного типа.

// tu1.cpp
struct Foo { private: int i; public: int j; };

// tu2.cpp
struct Foo { private: int i; public: int k; };

нарушение ОДР; неопределенное поведение.

// tu1.cpp
struct Foo { private: int i; public: int j; };

// tu2.cpp
struct Bar { private: int i; public: int j; };

Разные имена, такие разные типы. Не совместим с макетом.

// tu1.cpp
struct Foo { int i; int j; };

// tu2.cpp
struct Bar { int i; int j; };

Разные имена, разные типы, но совместимые с макетом (начиная со стандартного макета).

// tu1.cpp
namespace { struct Foo { private: int i; public: int j; }; }

// tu2.cpp
namespace { struct Foo { private: int i; public: int j; }; }

Внутренняя связь; различные виды.

// tu1.cpp
static void f() { struct Foo { private: int i; public: int j; }; }

// tu2.cpp
static void f() { struct Foo { private: int i; public: int j; }; }

Нет связи; различные виды.

// tu1.cpp
inline void f() { struct Foo { private: int i; public: int j; }; }

// tu2.cpp
inline void f() { struct Foo { private: int i; public: int j; }; }

Тот же тип по [dcl.fct.spec]/4.