Launder less

    alignas(T) std::byte storage[sizeof(T)];
    ::new (&storage) T();
    // ...
    T *ptr_ = reinterpret_cast<T*>(&storage);  // UB

III. Impact on the optimizers

Due to many popular projects do cast storage to an object without calling std::launder and everything works fine - there's no optimization that is enabled by default and that relies on that particular UB in the Standard.

LLVM has a -fstrict-vtable-pointers optimization that is disabled by default. With that optimization turned on the std::launder for polymorphic objects emits a special barrier that takes over the argument, as a result it prevents some of the CSE optimizations (for example - prevent removal of loads). For non polymorphic types it does nothing.

However, note that placement new of dynamic object already emits a barrier according to Devirtualization in LLVM and Clang. So using std::launder on a result of reinterpret_cast only adds an unnecessary optimization barrier.

IV. Wording

Adjust [expr.static.cast] p14:

A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object
type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1. If the original pointer value
represents the address A of a byte in memory and A does not satisfy the alignment requirement of T, then the resulting
pointer value is unspecified. Otherwise, if the original pointer value points to an object a, and there is an object b of
type similar to T that is pointer-interconvertible with a, the result is a pointer to b. Otherwise, if the original
pointer value points to an element of an array of std::byte or unsigned char, and there is an object b of type
T for which the array provides storage, created at the address of the array element, the result is a pointer to b.
Otherwise, the pointer value is unchanged by the conversion.

[Example 3: 
  T* p1 = new T;
  const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
  bool b = p1 == p2;  // b will have the value true.
— end example]

[Example 4: 
  alignas(T) std::byte storage[sizeof(T)];
  auto* p1 = ::new (&storage) T();
  auto* p2 = reinterpret_cast<T*>(&storage);
  bool b = p1 == p2;  // b will have the value true.
— end example]