Странная проблема с преобразованием ссылочного типа в другой с помощью оператора reinterpret_cast

#include <iostream>
int main(){
  int& rf = reinterpret_cast<int&>((int&&)1);
}

В этом примере GCC и MSVC не принимают этот код. Вместо этого Clang успешно компилирует его. Результат здесь.

Изучив соответствующее правило, соответствующее правило:
expr.reinterpret.cast#11

Значение gl типа T1, обозначающее объект x, может быть приведено к типу «ссылка на T2», если выражение типа «указатель на T1» можно явно преобразовать в тип «указатель на T2» с помощью reinterpret_cast. Результатом является *reinterpret_­cast<T2 *>(p), где p — указатель на x типа «указатель на T1». Временные объекты не создаются, копии не создаются, конструкторы ([class.ctor]) или функции преобразования ([class.conv]) не вызываются.

Посмотрите на это правило, я думаю, что это правило очень расплывчато. Там написано, что результат такой же, как *reinterpret_­cast<T2 *>(p). Правило разыменования указателя определяется как: экспр.унарный#оп-1

Унарный оператор * выполняет косвенность: выражение, к которому он применяется, должно быть указателем на тип объекта или указателем на тип функции, а результатом является lvalue, ссылающееся на объект или функцию, на которую указывает выражение.

Итак, согласно правилу [expr.unary#op-1], категория значений *reinterpret_­cast<T2 *>(p) — это lvalue. И правило [expr.reinterpret.cast#11] требует только, чтобы тип исходного указателя мог быть преобразован в тип указателя назначения с помощью reinterpret_cast, нет никаких других требований, таких как категория значения для его операнда. С этого момента я думаю, что Clang дает правильный процесс. Поскольку результатом является lvalue, следовательно, его можно привязать к ссылке lvalue.

Теперь немного модифицируем первый пример.

#include <iostream>
int main(){
  int& rf = reinterpret_cast<int&>(1);
}

Затем три компилятора отвергают этот пример. Какого черта? Отличие от первого примера в том, что операндом reinterpret_cast здесь является prvalue. Просто эта разница заставляет Clang не принимать этот код? Согласно expr#10

Всякий раз, когда выражение prvalue появляется как операнд оператора, который ожидает значение gl для этого операнда, применяется временное преобразование материализации для преобразования выражения в значение x.

Как сказано в приведенном выше правиле, временное преобразование материализации должно применяться к prvalue 1, чтобы сделать его glvalue. После этого преобразования я не вижу, чтобы этот пример имел какое-либо отличие от первого примера. Почему Clang теперь отклонить его?

Продолжим рассмотрение третьего примера

#include <iostream>
int main(){
  int&& rf = reinterpret_cast<int&&>(1);
}

На этот раз GCC принять этот пример, в то время как два других компилятора сообщают об ошибке, результат здесь.

Если изменить объявление на int&& rf = reinterpret_cast<int&&>((int&&)1);, то Clang примет это.

Кроме того, в [expr.reinterpret.cast#11] говорится, что результат преобразования ссылочного типа в другой с использованием reinterpret_cast всегда является lvalue (*reinterpret_­cast<T2 *>(p)), намекает, что мы не можем использовать ссылочный тип rvalue для привязки к результату. Не так ли?

Эти примеры придумываются, когда я читаю [expr.reinterpret.cast#11]. Разные компиляторы дают очень разные результаты. Это странно. Я также думаю, что [expr.reinterpret.cast#11] дает очень расплывчатую формулировку. В нем не говорилось о требовании категории значения операнда, когда мы даем ссылку rvalue или тип ссылки lvalue. Он просто говорит, что до тех пор, пока эти типы указателей могут быть преобразованы. В правиле также не указано, к какой категории значений относится результат. Мы можем сделать вывод, что его категория значений — это lvalue, только с помощью выражения *reinterpret_­cast<T2 *>(p).

Как интерпретировать эти вопросы. Является ли это дефектом [expr.reinterpret.cast#11]?