[Sema] Avoid emitting warnings for constant destruction.

[pkasting]

Summary

Fixes https://github.com/llvm/llvm-project/issues/62436.

[rsmith]

I think this would be an interesting test:

struct S {
  /*not constexpr*/ S();
  constexpr ~S() {}
};
S s; // no warning

struct T {
  /*not constexpr*/ T();
  constexpr ~T() { if (b) {} }
  bool b;
};
T t; // expected-warning {{exit-time destructor}}

(For a non-constexpr variable with a constexpr destructor, our behaviour depends on whether the destructor call is a constant expression.)

[rsmith]

LGTM with the extra test

[pkasting]

Update test per review comments.

[pkasting]

Thanks @rsmith; I don't have commit access, so can you land the updated patch for me?

clang/lib/Sema/SemaDeclCXX.cpp

if (!VD->evaluateDestruction(Notes) && VD->isConstexpr() &&
         HasConstantInit) {
       Diag(VD->getLocation(),
            diag::err_constexpr_var_requires_const_destruction) << VD;
       for (unsigned I = 0, N = Notes.size(); I != N; ++I)
         Diag(Notes[I].first, Notes[I].second);
     }
   }
 
-  if (!VD->hasGlobalStorage()) return;
+  if (!VD->hasGlobalStorage() || !VD->needsDestruction(Context))
+    return;
 
   // Emit warning for non-trivial dtor in global scope (a real global,
   // class-static, function-static).
   Diag(VD->getLocation(), diag::warn_exit_time_destructor);
 
   // TODO: this should be re-enabled for static locals by !CXAAtExit
   if (!VD->isStaticLocal())
     Diag(VD->getLocation(), diag::warn_global_destructor);

clang/test/SemaCXX/warn-exit-time-destructors.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wexit-time-destructors %s -verify
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wexit-time-destructors %s -verify=expected,cxx11
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -Wexit-time-destructors %s -verify=expected
 
 namespace test1 {
   struct A { ~A(); };
   A a; // expected-warning {{declaration requires an exit-time destructor}}
   A b[10]; // expected-warning {{declaration requires an exit-time destructor}}
   A c[10][10]; // expected-warning {{declaration requires an exit-time destructor}}
 
   A &d = a;
namespace test3 {
   };
   E e;
 }
 
 namespace test4 {
 struct A { ~A(); };
 [[clang::no_destroy]] A a; // no warning
 }
+
+namespace test5 {
+#if __cplusplus >= 202002L
+#define CPP20_CONSTEXPR constexpr
+#else
+#define CPP20_CONSTEXPR
+#endif
+  struct S {
+    CPP20_CONSTEXPR ~S() {}
+  };
+  S s; // cxx11-warning {{exit-time destructor}}
+
+  struct T {
+    CPP20_CONSTEXPR ~T() { if (b) {} }
+    bool b;
+  };
+  T t; // expected-warning {{exit-time destructor}}
+#undef CPP20_CONSTEXPR
+}

clang/test/SemaCXX/warn-global-constructors.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wglobal-constructors %s -verify
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wglobal-constructors %s -verify=expected,cxx11
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -Wglobal-constructors %s -verify=expected
 
 int opaque_int();
 
 namespace test0 {
   // These should never require global constructors.
   int a;
   int b = 20;
   float c = 5.0f;
namespace bitfields {
 
   const HasUnnamedBitfield zeroConst{};
   HasUnnamedBitfield zeroMutable{};
   const HasUnnamedBitfield explicitConst{1, 2};
   HasUnnamedBitfield explicitMutable{1, 2};
   const HasUnnamedBitfield nonConstexprConst{1}; // expected-warning {{global constructor}}
   HasUnnamedBitfield nonConstexprMutable{1}; // expected-warning {{global constructor}}
 }
+
+namespace test7 {
+#if __cplusplus >= 202002L
+#define CPP20_CONSTEXPR constexpr
+#else
+#define CPP20_CONSTEXPR
+#endif
+  struct S {
+    CPP20_CONSTEXPR ~S() {}
+  };
+  S s; // cxx11-warning {{global destructor}}
+
+  struct T {
+    CPP20_CONSTEXPR ~T() { if (b) {} }
+    bool b;
+  };
+  T t; // expected-warning {{global destructor}}
+#undef CPP20_CONSTEXPR
+}