CallableInfo doesn't need to cache the name.

Clean up traversal of constructor initializers and implicit destructors (with test).

Author: Doug Wyatt

clang/lib/Sema/EffectAnalysis.cpp

@@ -199,7 +199,6 @@ struct CallableInfo {
   // FunctionDecl if CallType::Function or Virtual
   // BlockDecl if CallType::Block
   const Decl *CDecl;
-  mutable std::optional<std::string> MaybeName;
   SpecialFuncType FuncType = SpecialFuncType::None;
   EffectSet Effects;
   CallType CType = CallType::Unknown;
@@ -247,20 +246,17 @@ struct CallableInfo {
 
   /// Generate a name for logging and diagnostics.
   std::string name(Sema &Sem) const {
-    if (!MaybeName) {
-      std::string Name;
-      llvm::raw_string_ostream OS(Name);
-
-      if (auto *FD = dyn_cast<FunctionDecl>(CDecl))
-        FD->getNameForDiagnostic(OS, Sem.getPrintingPolicy(),
-                                 /*Qualified=*/true);
-      else if (auto *BD = dyn_cast<BlockDecl>(CDecl))
-        OS << "(block " << BD->getBlockManglingNumber() << ")";
-      else if (auto *VD = dyn_cast<NamedDecl>(CDecl))
-        VD->printQualifiedName(OS);
-      MaybeName = Name;
-    }
-    return *MaybeName;
+    std::string Name;
+    llvm::raw_string_ostream OS(Name);
+
+    if (auto *FD = dyn_cast<FunctionDecl>(CDecl))
+      FD->getNameForDiagnostic(OS, Sem.getPrintingPolicy(),
+                                /*Qualified=*/true);
+    else if (auto *BD = dyn_cast<BlockDecl>(CDecl))
+      OS << "(block " << BD->getBlockManglingNumber() << ")";
+    else if (auto *VD = dyn_cast<NamedDecl>(CDecl))
+      VD->printQualifiedName(OS);
+    return Name;
   }
 };
 
@@ -955,17 +951,10 @@ class Analyzer {
 
     // -- Entry point --
     void run() {
-      // The target function itself may have some implicit code paths beyond the
-      // body: member and base constructors and destructors. Visit these first.
-      if (const auto *FD = dyn_cast<const FunctionDecl>(CurrentCaller.CDecl)) {
-        if (auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
-          for (const CXXCtorInitializer *Initer : Ctor->inits())
-            if (Expr *Init = Initer->getInit())
-              VisitStmt(Init);
-        } else if (auto *Dtor = dyn_cast<CXXDestructorDecl>(FD))
-          followDestructor(dyn_cast<CXXRecordDecl>(Dtor->getParent()), Dtor);
-      }
-      // else could be BlockDecl
+      // The target function may have implicit code paths beyond the
+      // body: member and base destructors. Visit these first.
+      if (auto *Dtor = dyn_cast<CXXDestructorDecl>(CurrentCaller.CDecl))
+        followDestructor(dyn_cast<CXXRecordDecl>(Dtor->getParent()), Dtor);
 
       // Do an AST traversal of the function/block body
       TraverseDecl(const_cast<Decl *>(CurrentCaller.CDecl));
@@ -1043,18 +1032,18 @@ class Analyzer {
     void followDestructor(const CXXRecordDecl *Rec,
                           const CXXDestructorDecl *Dtor) {
       for (const FieldDecl *Field : Rec->fields())
-        followTypeDtor(Field->getType());
+        followTypeDtor(Field->getType(), Dtor);
 
       if (const auto *Class = dyn_cast<CXXRecordDecl>(Rec)) {
         for (const CXXBaseSpecifier &Base : Class->bases())
-          followTypeDtor(Base.getType());
+          followTypeDtor(Base.getType(), Dtor);
 
         for (const CXXBaseSpecifier &Base : Class->vbases())
-          followTypeDtor(Base.getType());
+          followTypeDtor(Base.getType(), Dtor);
       }
     }
 
-    void followTypeDtor(QualType QT) {
+    void followTypeDtor(QualType QT, const CXXDestructorDecl *OuterDtor) {
       const Type *Ty = QT.getTypePtr();
       while (Ty->isArrayType()) {
         const ArrayType *Arr = Ty->getAsArrayTypeUnsafe();
@@ -1066,7 +1055,7 @@ class Analyzer {
         if (const CXXRecordDecl *Class = Ty->getAsCXXRecordDecl()) {
           if (CXXDestructorDecl *Dtor = Class->getDestructor()) {
             CallableInfo CI(Outer.Sem, *Dtor);
-            followCall(CI, Dtor->getLocation());
+            followCall(CI, OuterDtor->getLocation());
           }
         }
       }

clang/test/Sema/attr-nonblocking-constraints.cpp

@@ -7,18 +7,18 @@
 
 // --- CONSTRAINTS ---
 
-void nl1() [[clang::nonblocking]]
+void nb1() [[clang::nonblocking]]
 {
 	int *pInt = new int; // expected-warning {{'nonblocking' function must not allocate or deallocate memory}}
 	delete pInt; // expected-warning {{'nonblocking' function must not allocate or deallocate memory}}
 }
 
-void nl2() [[clang::nonblocking]]
+void nb2() [[clang::nonblocking]]
 {
 	static int global; // expected-warning {{'nonblocking' function must not have static locals}}
 }
 
-void nl3() [[clang::nonblocking]]
+void nb3() [[clang::nonblocking]]
 {
 	try {
 		throw 42; // expected-warning {{'nonblocking' function must not throw or catch exceptions}}
@@ -27,35 +27,35 @@ void nl3() [[clang::nonblocking]]
 	}
 }
 
-void nl4_inline() {}
-void nl4_not_inline(); // expected-note {{function cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
+void nb4_inline() {}
+void nb4_not_inline(); // expected-note {{function cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
 
-void nl4() [[clang::nonblocking]]
+void nb4() [[clang::nonblocking]]
 {
-	nl4_inline(); // OK
-	nl4_not_inline(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
+	nb4_inline(); // OK
+	nb4_not_inline(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
 }
 
 
 struct HasVirtual {
 	virtual void unsafe(); // expected-note {{virtual method cannot be inferred 'nonblocking'}}
 };
 
-void nl5() [[clang::nonblocking]]
+void nb5() [[clang::nonblocking]]
 {
  	HasVirtual hv;
  	hv.unsafe(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
 }
 
-void nl6_unsafe(); // expected-note {{function cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
-void nl6_transitively_unsafe()
+void nb6_unsafe(); // expected-note {{function cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
+void nb6_transitively_unsafe()
 {
-	nl6_unsafe(); // expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function}}
+	nb6_unsafe(); // expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function}}
 }
 
-void nl6() [[clang::nonblocking]]
+void nb6() [[clang::nonblocking]]
 {
-	nl6_transitively_unsafe(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
+	nb6_transitively_unsafe(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
 }
 
 thread_local int tl_var{ 42 };
@@ -65,15 +65,15 @@ bool tl_test() [[clang::nonblocking]]
 	return tl_var > 0; // expected-warning {{'nonblocking' function must not use thread-local variables}}
 }
 
-void nl7()
+void nb7()
 {
 	// Make sure we verify blocks
 	auto blk = ^() [[clang::nonblocking]] {
 		throw 42; // expected-warning {{'nonblocking' function must not throw or catch exceptions}}
 	};
 }
 
-void nl8()
+void nb8()
 {
 	// Make sure we verify lambdas
 	auto lambda = []() [[clang::nonblocking]] {
@@ -111,7 +111,7 @@ void nl8()
 		}
 	};
 
-void nl9() [[clang::nonblocking]]
+void nb9() [[clang::nonblocking]]
 {
 	Adder<int>::add_explicit(1, 2);
 	Adder<int>::add_implicit(1, 2);
@@ -121,7 +121,7 @@ void nl9() [[clang::nonblocking]]
 		expected-note {{in template expansion here}}
 }
 
-void nl10(
+void nb10(
 	void (*fp1)(), // expected-note {{function pointer cannot be inferred 'nonblocking'}}
 	void (*fp2)() [[clang::nonblocking]]
 	) [[clang::nonblocking]]
@@ -131,20 +131,20 @@ void nl10(
 }
 
 // Interactions with nonblocking(false)
-void nl11_no_inference_1() [[clang::nonblocking(false)]] // expected-note {{function does not permit inference of 'nonblocking'}}
+void nb11_no_inference_1() [[clang::nonblocking(false)]] // expected-note {{function does not permit inference of 'nonblocking'}}
 {
 }
-void nl11_no_inference_2() [[clang::nonblocking(false)]]; // expected-note {{function does not permit inference of 'nonblocking'}}
+void nb11_no_inference_2() [[clang::nonblocking(false)]]; // expected-note {{function does not permit inference of 'nonblocking'}}
 
 template <bool V>
 struct ComputedNB {
 	void method() [[clang::nonblocking(V)]]; // expected-note {{function does not permit inference of 'nonblocking'}}
 };
 
-void nl11() [[clang::nonblocking]]
+void nb11() [[clang::nonblocking]]
 {
-	nl11_no_inference_1(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
-	nl11_no_inference_2(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
+	nb11_no_inference_1(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
+	nb11_no_inference_2(); // expected-warning {{'nonblocking' function must not call non-'nonblocking' function}}
 
 	ComputedNB<true> CNB_true;
 	CNB_true.method();
@@ -154,11 +154,11 @@ void nl11() [[clang::nonblocking]]
 }
 
 // Verify that when attached to a redeclaration, the attribute successfully attaches.
-void nl12() {
+void nb12() {
 	static int x; // expected-warning {{'nonblocking' function must not have static locals}}
 }
-void nl12() [[clang::nonblocking]];
-void nl13() [[clang::nonblocking]] { nl12(); }
+void nb12() [[clang::nonblocking]];
+void nb13() [[clang::nonblocking]] { nb12(); }
 
 // C++ member function pointers
 struct PTMFTester {
@@ -175,21 +175,34 @@ void PTMFTester::convert() [[clang::nonblocking]]
 }
 
 // Block variables
-void nl17(void (^blk)() [[clang::nonblocking]]) [[clang::nonblocking]] {
+void nb17(void (^blk)() [[clang::nonblocking]]) [[clang::nonblocking]] {
 	blk();
 }
 
 // References to blocks
-void nl18(void (^block)() [[clang::nonblocking]]) [[clang::nonblocking]]
+void nb18(void (^block)() [[clang::nonblocking]]) [[clang::nonblocking]]
 {
 	auto &ref = block;
 	ref();
 }
 
+// Verify traversal of implicit code paths - constructors and destructors.
+struct Unsafe {
+  static void problem1(); // expected-note {{function cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
+  static void problem2(); // expected-note {{function cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
+
+  Unsafe() { problem1(); } // expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function 'Unsafe::problem1'}}
+  ~Unsafe() { problem2(); } // expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function 'Unsafe::problem2'}}
+};
+
+struct DerivedFromUnsafe : public Unsafe {
+  DerivedFromUnsafe() [[clang::nonblocking]] {} // expected-warning {{'nonblocking' function must not call non-'nonblocking' function 'Unsafe::Unsafe'}}
+  ~DerivedFromUnsafe() [[clang::nonblocking]] {} // expected-warning {{'nonblocking' function must not call non-'nonblocking' function 'Unsafe::~Unsafe'}}
+};
 
 // --- nonblocking implies noexcept ---
 #pragma clang diagnostic warning "-Wperf-constraint-implies-noexcept"
 
-void nl19() [[clang::nonblocking]] // expected-warning {{'nonblocking' function should be declared noexcept}}
+void nb19() [[clang::nonblocking]] // expected-warning {{'nonblocking' function should be declared noexcept}}
 {
 }