Address PR comments.

Author: tynasello

clang/lib/Sema/SemaDeclAttr.cpp

@@ -2156,24 +2156,24 @@ static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   D->addAttr(::new (S.Context) UnusedAttr(S.Context, AL));
 }
 
-static std::optional<Expr *>
-sharedGetConstructorDestructorAttrExpr(Sema &S, const ParsedAttr &AL) {
-  // If no Expr node exists on the attribute, return a nullptr (default priority
-  // to be used). If Expr node exists but is not valid, return a nullopt.
-  // Otherwise, return the Expr.
+static ExprResult sharedGetConstructorDestructorAttrExpr(Sema &S,
+                                                         const ParsedAttr &AL) {
+  // If no Expr node exists on the attribute, return a nullptr result (default
+  // priority to be used). If Expr node exists but is not valid, return an
+  // invalid result. Otherwise, return the Expr.
   Expr *E = nullptr;
   if (AL.getNumArgs() == 1) {
     E = AL.getArgAsExpr(0);
     if (E->isValueDependent()) {
       if (!E->isTypeDependent() && !E->getType()->isIntegerType()) {
         S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
             << AL << AANT_ArgumentIntegerConstant << E->getSourceRange();
-        return std::nullopt;
+        return ExprResult(/*Invalid=*/true);
       }
     } else {
       uint32_t priority;
       if (!S.checkUInt32Argument(AL, AL.getArgAsExpr(0), priority)) {
-        return std::nullopt;
+        return ExprResult(/*Invalid=*/true);
       }
       return ConstantExpr::Create(S.Context, E,
                                   APValue(llvm::APSInt::getUnsigned(priority)));
@@ -2187,20 +2187,20 @@ static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
     S.Diag(AL.getLoc(), diag::err_hlsl_init_priority_unsupported);
     return;
   }
-  auto E = sharedGetConstructorDestructorAttrExpr(S, AL);
-  if (!E.has_value())
+  ExprResult E = sharedGetConstructorDestructorAttrExpr(S, AL);
+  if (!E.isUsable())
     return;
   S.Diag(D->getLocation(), diag::warn_global_constructor)
       << D->getSourceRange();
-  D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, E.value()));
+  D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, E.get()));
 }
 
 static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
-  auto E = sharedGetConstructorDestructorAttrExpr(S, AL);
-  if (!E.has_value())
+  ExprResult E = sharedGetConstructorDestructorAttrExpr(S, AL);
+  if (!E.isUsable())
     return;
   S.Diag(D->getLocation(), diag::warn_global_destructor) << D->getSourceRange();
-  D->addAttr(::new (S.Context) DestructorAttr(S.Context, AL, E.value()));
+  D->addAttr(::new (S.Context) DestructorAttr(S.Context, AL, E.get()));
 }
 
 template <typename AttrTy>

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -245,12 +245,13 @@ static void sharedInstantiateConstructorDestructorAttr(
     if (Result.isInvalid())
       return;
     tempInstPriority = Result.get();
-    if (auto CE = tempInstPriority->getIntegerConstantExpr(C)) {
+    if (std::optional<llvm::APSInt> CE =
+            tempInstPriority->getIntegerConstantExpr(C)) {
       // Consistent with non-templated priority arguments, which must fit in a
       // 32-bit unsigned integer.
       if (!CE->isIntN(32)) {
         S.Diag(tempInstPriority->getExprLoc(), diag::err_ice_too_large)
-            << toString(*CE, 10, false) << 32 << 1;
+            << toString(*CE, 10, false) << /*Size=*/32 << /*Unsigned=*/1;
         return;
       }
     }

clang/test/Sema/constructor-attribute.cpp

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-strict-prototypes %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify -Wno-strict-prototypes %s
 // RUN: %clang_cc1 -x c -fsyntax-only -verify -Wno-strict-prototypes %s
 
 int x __attribute__((constructor)); // expected-warning {{'constructor' attribute only applies to functions}}
@@ -10,53 +10,65 @@ int f(void) __attribute__((constructor(0x100000000))); // expected-error {{integ
 void knr() __attribute__((constructor));
 
 #ifdef __cplusplus
-template <int *P> 
-[[gnu::constructor(P)]] void f(); // expected-error {{'gnu::constructor' attribute requires an integer constant}}
+template <float P> [[gnu::constructor(P)]] void f(); // expected-error {{'gnu::constructor' attribute requires an integer constant}}
+template <double P> [[gnu::constructor(P)]] void f(); // expected-error {{'gnu::constructor' attribute requires an integer constant}}
+template <int *P> [[gnu::constructor(P)]] void f(); // expected-error {{'gnu::constructor' attribute requires an integer constant}}
 
-template <long long P> 
-[[gnu::constructor(P)]] void f() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
+template <long long P> [[gnu::constructor(P)]] void f() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
 template void f<1LL<<32>(); // expected-note {{in instantiation of function template specialization 'f<4294967296LL>' requested here}}
 template void f<101>();
 
-template <typename T>
-[[gnu::constructor(static_cast<T>(101))]] void f() {}
+template <typename T> [[gnu::constructor(static_cast<T>(1LL<<32))]] void f() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
+template void f<long long>(); // expected-note {{in instantiation of function template specialization 'f<long long>' requested here}}
 template void f<int>();
-template void f<long long>();
 
 template <typename T>
-[[gnu::constructor(static_cast<T>(1LL<<32))]] void g() {}
+[[gnu::constructor(static_cast<T>(101))]] void g() {}
 template void g<int>();
+template void g<long long>();
+
+template <typename T>
+[[gnu::constructor(static_cast<T>(T{101}))]] void h() {}
+template void h<int>();
+template void h<long long>();
 
 template <typename T>
-[[gnu::constructor(static_cast<T>(1LL<<32))]] void h() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
-template void h<long long>(); // expected-note {{in instantiation of function template specialization 'h<long long>' requested here}}
+[[gnu::constructor(static_cast<T>(sizeof(T[101])))]] void a() {}
+template void a<int>();
+template void a<long long>();
 #endif
 
-int y __attribute__((destructor)); // expected-warning {{'destructor' attribute only applies to functions}}
-int f(void) __attribute__((destructor));
-int f(void) __attribute__((destructor(1)));
-int f(void) __attribute__((destructor(1,2))); // expected-error {{'destructor' attribute takes no more than 1 argument}}
-int f(void) __attribute__((destructor(1.0))); // expected-error {{'destructor' attribute requires an integer constant}}
+int yd __attribute__((destructor)); // expected-warning {{'destructor' attribute only applies to functions}}
+int fd(void) __attribute__((destructor));
+int fd(void) __attribute__((destructor(1)));
+int fd(void) __attribute__((destructor(1,2))); // expected-error {{'destructor' attribute takes no more than 1 argument}}
+int fd(void) __attribute__((destructor(1.0))); // expected-error {{'destructor' attribute requires an integer constant}}
 
 #ifdef __cplusplus
-template <int *I> 
-[[gnu::destructor(I)]] void f(); // expected-error {{'gnu::destructor' attribute requires an integer constant}}
+template <float P> [[gnu::destructor(P)]] void fd(); // expected-error {{'gnu::destructor' attribute requires an integer constant}}
+template <double P> [[gnu::destructor(P)]] void fd(); // expected-error {{'gnu::destructor' attribute requires an integer constant}}
+template <int *P> [[gnu::destructor(P)]] void fd(); // expected-error {{'gnu::destructor' attribute requires an integer constant}}
 
-template <long long P> 
-[[gnu::destructor(P)]] void fd() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
+template <long long P> [[gnu::destructor(P)]] void fd() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
 template void fd<1LL<<32>(); // expected-note {{in instantiation of function template specialization 'fd<4294967296LL>' requested here}}
 template void fd<101>();
 
-template <typename T>
-[[gnu::destructor(static_cast<T>(101))]] void fd() {}
+template <typename T> [[gnu::destructor(static_cast<T>(1LL<<32))]] void fd() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
+template void fd<long long>(); // expected-note {{in instantiation of function template specialization 'fd<long long>' requested here}}
 template void fd<int>();
-template void fd<long long>();
 
 template <typename T>
-[[gnu::destructor(static_cast<T>(1LL<<32))]] void gd() {}
+[[gnu::destructor(static_cast<T>(101))]] void gd() {}
 template void gd<int>();
+template void gd<long long>();
+
+template <typename T>
+[[gnu::destructor(static_cast<T>(T{101}))]] void hd() {}
+template void hd<int>();
+template void hd<long long>();
 
 template <typename T>
-[[gnu::destructor(static_cast<T>(1LL<<32))]] void hd() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} 
-template void hd<long long>(); // expected-note {{in instantiation of function template specialization 'hd<long long>' requested here}}
+[[gnu::destructor(static_cast<T>(sizeof(T[101])))]] void ad() {}
+template void ad<int>();
+template void ad<long long>();
 #endif