Can you dereference a temporary array?

Consider the following code:

void foo() {
    int arr[1];
    *arr; // OK

    using T = int[1];
    *T{}; // OK for Clang and MSVC
          // GCC error: taking address of temporary array
}

See live code at Compiler Explorer.

My intuition is that *T{} should result in array-to-pointer conversion, and the indirection is well-formed. However, I'm not entirely sure about this.

Is GCC right, or is this a bug? Is it intentional, to prevent developers from making mistakes? After all, you don't usually dereference arrays. Is this documented anywhere?

More discussion at editorial issue EDIT 6555

GCC is right because indirection can only be applied to pointers. [expr.unary.op]/1:

The unary * operator performs indirection: the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result [...]

Note: CWG 1642 and EDIT 3945 makes indirection apply to a prvalue operand.

*arr is OK because arr is an lvalue, and [basic.lval]/6:

Whenever a glvalue appears as an operand of an operator that expects a prvalue for that operand, the lvalue-to-rvalue, array-to-pointer, or function-to-pointer standard conversions are applied to convert the expression to a prvalue.

Array-to-pointer conversion ([conv.array]) is applied toarr.

T{} is already a prvalue (of array type), and there is no wording which necessitates array-to-pointer conversion here, so *T{} is not OK.