[clang] Dynamic initialization of an array of objects with a private destructor is rejected by clang

[Rush10233]

Very surprised to see that:

class S {
  ~S()=default;
};


int main(){
    S *ss = new S[100];
}

This is rejected by clang:

<source>:7:17: error: temporary of type 'S' has private destructor
    7 |     S *ss = new S[100];
      |                 ^
<source>:2:3: note: implicitly declared private here
    2 |   ~S()=default;
      |   ^

I wonder if I have missed some instructions on the standard, but it appears that other compilers including GCC, MSVC and EDG can normally accept it.

https://godbolt.org/z/9d6Y5b3Mr

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (Rush10233)

Very surprised to see that:

class S {
  ~S()=default;
};


int main(){
    S *ss = new S[100];
}

This is rejected by clang:

<source>:7:17: error: temporary of type 'S' has private destructor
    7 |     S *ss = new S[100];
      |                 ^
<source>:2:3: note: implicitly declared private here
    2 |   ~S()=default;
      |   ^

I wonder if I have missed some instructions on the standard, but it appears that other compilers including GCC, MSVC and EDG can normally accept it.

https://godbolt.org/z/9d6Y5b3Mr

[cor3ntin]

I think Clang is correct

https://eel.is/c++draft/expr.new#26

If the new-expression creates an array of objects of class type, the destructor is potentially invoked ([class.dtor]).

https://eel.is/c++draft/class.dtor#14.sentence-7

A program is ill-formed if a destructor that is potentially invoked is deleted or not accessible from the context of the invocation.

The fact that we diverge from everyone else gives me pause though.
GCC produce the error message I would expect with a private non-defaulted destructor https://godbolt.org/z/9zxs8srKf

[shafik]

Looks similar to: #47370

[shafik]

Also see cwg2426 which covers a similar situation for return statements.

Worth noting gcc/clang agree that the code is ill-formed, if it is not defaulted: https://godbolt.org/z/GW55zs6fW

class S {
  ~S() ;
};


int main(){
    S *ss = new S[100];
}

[zygoloid]

I'd guess the other compilers are incorrectly skipping the check when the type is trivially destructible.