Check ReleaseCapabilityAttr as well

clang/lib/Analysis/ThreadSafety.cpp

@@ -2265,27 +2265,37 @@ static bool neverReturns(const CFGBlock *B) {
   return false;
 }
 
-void ThreadSafetyAnalyzer::checkMismatchedFunctionAttrs(const NamedDecl *ND) {
-  auto collectCapabilities = [&](const Decl *D) {
-    CapExprSet Caps;
-    for (const auto *A : D->specific_attrs<RequiresCapabilityAttr>()) {
-      for (const Expr *E : A->args())
-        Caps.push_back_nodup(SxBuilder.translateAttrExpr(E, nullptr));
-    }
-    return Caps;
-  };
+template <typename AttrT>
+static CapExprSet collectAttrArgs(SExprBuilder &SxBuilder, const Decl *D) {
+  CapExprSet Caps;
+  for (const auto *A : D->specific_attrs<AttrT>()) {
+    for (const Expr *E : A->args())
+      Caps.push_back_nodup(SxBuilder.translateAttrExpr(E, nullptr));
+  }
+  return Caps;
+}
+
+template <typename AttrT>
+static void maybeDiagnoseFunctionAttrs(const NamedDecl *ND,
+                                       SExprBuilder &SxBuilder,
+                                       ThreadSafetyHandler &Handler) {
 
-  CapExprSet NDArgs = collectCapabilities(ND);
+  // FIXME: The diagnostic here is suboptimal. It would be better to print
+  // what attributes are missing in the first declaration.
+  CapExprSet NDArgs = collectAttrArgs<AttrT>(SxBuilder, ND);
   for (const Decl *D = ND->getPreviousDecl(); D; D = D->getPreviousDecl()) {
-    CapExprSet DArgs = collectCapabilities(D);
+    CapExprSet DArgs = collectAttrArgs<AttrT>(SxBuilder, D);
 
-    for (const auto &[A, B] : zip_longest(NDArgs, DArgs)) {
-      if (!A || !B || !A->equals(*B))
-        Handler.handleAttributeMismatch(ND, cast<NamedDecl>(D));
-    }
+    if (NDArgs.size() != DArgs.size())
+      Handler.handleAttributeMismatch(ND, cast<NamedDecl>(D));
   }
 }
 
+void ThreadSafetyAnalyzer::checkMismatchedFunctionAttrs(const NamedDecl *ND) {
+  maybeDiagnoseFunctionAttrs<RequiresCapabilityAttr>(ND, SxBuilder, Handler);
+  maybeDiagnoseFunctionAttrs<ReleaseCapabilityAttr>(ND, SxBuilder, Handler);
+}
+
 /// Check a function's CFG for thread-safety violations.
 ///
 /// We traverse the blocks in the CFG, compute the set of mutexes that are held