[clang-tidy] Implement cppcoreguidelines CP.52

[ccotter]

Summary

Flag code that suspends a coroutine while a lock is held.

[ccotter]

• Specify version

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

162

Please keep alphabetical order in new checks list.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/no-suspend-with-lock.rst

7

Please synchronize with statement in Release Notes.

[PiotrZSL]

clang-tools-extra/clang-tidy/cppcoreguidelines/NoSuspendWithLockCheck.cpp

25–27

add configuration option for lock types, many big project got own types or wrappers.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/no-suspend-with-lock.rst

14

add info to documentation that manual locking/unlocking is not supported.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/no-suspend-with-lock.cpp

190

add test with lambda, something like:

std::unique_lock<std::mutex> lock(mtx);

auto lambda = [] { co_yeld 0; }

And add test with class defined in function with co_yeld in class, and lock in function.

[PiotrZSL]

Consider ignoring template instances, to avoid generating lot of warnings for each instance.

[ccotter]

clang-tools-extra/clang-tidy/cppcoreguidelines/NoSuspendWithLockCheck.cpp

25–27

I was just thinking about this case...my code base had its own lock types that I would want to be able to include.

[ccotter]

• Add tests, do not inspect instantiations, add option

[PiotrZSL]

clang-tools-extra/clang-tidy/cppcoreguidelines/NoSuspendWithLockCheck.cpp

28

consider using matchers::matchesAnyListedName

[ccotter]

• Use matchesAnyListedName and fix windows build

[PiotrZSL]

LGTM

[ccotter]

@PiotrZSL would you mind landing this for me? Thanks

clang-tools-extra/clang-tidy/cppcoreguidelines/CMakeLists.txt

add_clang_library(clangTidyCppCoreGuidelinesModule
   CppCoreGuidelinesTidyModule.cpp
   InitVariablesCheck.cpp
   InterfacesGlobalInitCheck.cpp
   MacroUsageCheck.cpp
   MisleadingCaptureDefaultByValueCheck.cpp
   MissingStdForwardCheck.cpp
   NarrowingConversionsCheck.cpp
   NoMallocCheck.cpp
+  NoSuspendWithLockCheck.cpp
   OwningMemoryCheck.cpp
   PreferMemberInitializerCheck.cpp
   ProBoundsArrayToPointerDecayCheck.cpp
   ProBoundsConstantArrayIndexCheck.cpp
   ProBoundsPointerArithmeticCheck.cpp
   ProTypeConstCastCheck.cpp
   ProTypeCstyleCastCheck.cpp
   ProTypeMemberInitCheck.cpp
add_clang_library(clangTidyCppCoreGuidelinesModule
 
   DEPENDS
   omp_gen
   ClangDriverOptions
   )
 
 clang_target_link_libraries(clangTidyCppCoreGuidelinesModule
   PRIVATE
+  clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangSerialization
   clangTooling
   )

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 #include "AvoidReferenceCoroutineParametersCheck.h"
 #include "InitVariablesCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "MacroUsageCheck.h"
 #include "MisleadingCaptureDefaultByValueCheck.h"
 #include "MissingStdForwardCheck.h"
 #include "NarrowingConversionsCheck.h"
 #include "NoMallocCheck.h"
+#include "NoSuspendWithLockCheck.h"
 #include "OwningMemoryCheck.h"
 #include "PreferMemberInitializerCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
 #include "ProBoundsConstantArrayIndexCheck.h"
 #include "ProBoundsPointerArithmeticCheck.h"
 #include "ProTypeConstCastCheck.h"
 #include "ProTypeCstyleCastCheck.h"
 #include "ProTypeMemberInitCheck.h"
CheckFactories.registerCheck<MacroUsageCheck>(
         "cppcoreguidelines-macro-usage");
     CheckFactories.registerCheck<MisleadingCaptureDefaultByValueCheck>(
         "cppcoreguidelines-misleading-capture-default-by-value");
     CheckFactories.registerCheck<MissingStdForwardCheck>(
         "cppcoreguidelines-missing-std-forward");
     CheckFactories.registerCheck<NarrowingConversionsCheck>(
         "cppcoreguidelines-narrowing-conversions");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
+    CheckFactories.registerCheck<NoSuspendWithLockCheck>(
+        "cppcoreguidelines-no-suspend-with-lock");
     CheckFactories.registerCheck<performance::NoexceptDestructorCheck>(
         "cppcoreguidelines-noexcept-destructor");
     CheckFactories.registerCheck<performance::NoexceptMoveConstructorCheck>(
         "cppcoreguidelines-noexcept-move-operations");
     CheckFactories.registerCheck<performance::NoexceptSwapCheck>(
         "cppcoreguidelines-noexcept-swap");
     CheckFactories.registerCheck<misc::NonPrivateMemberVariablesInClassesCheck>(
         "cppcoreguidelines-non-private-member-variables-in-classes");

clang-tools-extra/clang-tidy/cppcoreguidelines/NoSuspendWithLockCheck.h

+//===--- NoSuspendWithLockCheck.h - clang-tidy ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NOSUSPENDWITHLOCKCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NOSUSPENDWITHLOCKCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::cppcoreguidelines {
+
+/// Flag coroutines that suspend while any lock guard is alive.
+/// This check implements CppCoreGuideline CP.52.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines/no-suspend-with-lock.html
+class NoSuspendWithLockCheck : public ClangTidyCheck {
+public:
+  NoSuspendWithLockCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context),
+        LockGuards(Options.get("LockGuards",
+                               "::std::unique_lock;::std::scoped_lock;::"
+                               "std::shared_lock;::std::lock_guard")) {}
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus20;
+  }
+
+private:
+  /// Semicolon-separated list of fully qualified names of lock guard template
+  /// types. Defaults to
+  /// `::std::unique_lock;::std::scoped_lock;::std::shared_lock;::std::lock_guard`.
+  const StringRef LockGuards;
+};
+
+} // namespace clang::tidy::cppcoreguidelines
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NOSUSPENDWITHLOCKCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/NoSuspendWithLockCheck.cpp

+//===--- NoSuspendWithLockCheck.cpp - clang-tidy --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "NoSuspendWithLockCheck.h"
+#include "../utils/ExprSequence.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Analysis/CFG.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::cppcoreguidelines {
+
+void NoSuspendWithLockCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "LockGuards", LockGuards);
+}
+
+void NoSuspendWithLockCheck::registerMatchers(MatchFinder *Finder) {
+  auto LockType = elaboratedType(namesType(templateSpecializationType(
+      hasDeclaration(namedDecl(matchers::matchesAnyListedName(
+          utils::options::parseStringList(LockGuards)))))));
+
+  StatementMatcher Lock =
+      declStmt(has(varDecl(hasType(LockType)).bind("lock-decl")))
+          .bind("lock-decl-stmt");
+  Finder->addMatcher(
+      expr(anyOf(coawaitExpr(), coyieldExpr(), dependentCoawaitExpr()),
+           forCallable(functionDecl().bind("function")),
+           unless(isInTemplateInstantiation()),
+           hasAncestor(
+               compoundStmt(has(Lock), forCallable(equalsBoundNode("function")))
+                   .bind("block")))
+          .bind("suspend"),
+      this);
+}
+
+void NoSuspendWithLockCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *Block = Result.Nodes.getNodeAs<CompoundStmt>("block");
+  const auto *Suspend = Result.Nodes.getNodeAs<Expr>("suspend");
+  const auto *LockDecl = Result.Nodes.getNodeAs<VarDecl>("lock-decl");
+  const auto *LockStmt = Result.Nodes.getNodeAs<Stmt>("lock-decl-stmt");
+
+  if (!Block || !Suspend || !LockDecl || !LockStmt)
+    return;
+
+  ASTContext &Context = *Result.Context;
+  CFG::BuildOptions Options;
+  Options.AddImplicitDtors = true;
+  Options.AddTemporaryDtors = true;
+
+  std::unique_ptr<CFG> TheCFG = CFG::buildCFG(
+      nullptr, const_cast<clang::CompoundStmt *>(Block), &Context, Options);
+  if (!TheCFG)
+    return;
+
+  utils::ExprSequence Sequence(TheCFG.get(), Block, &Context);
+  const Stmt *LastBlockStmt = Block->body_back();
+  if (Sequence.inSequence(LockStmt, Suspend) &&
+      (Suspend == LastBlockStmt ||
+       Sequence.inSequence(Suspend, LastBlockStmt))) {
+    diag(Suspend->getBeginLoc(), "coroutine suspended with lock %0 held")
+        << LockDecl;
+  }
+}
+
+} // namespace clang::tidy::cppcoreguidelines

clang-tools-extra/docs/ReleaseNotes.rst

 
 - New :doc:`bugprone-optional-value-conversion
   <clang-tidy/checks/bugprone/optional-value-conversion>` check.
 
   Detects potentially unintentional and redundant conversions where a value is
   extracted from an optional-like type and then used to create a new instance
   of the same optional-like type.
 
+- New :doc:`cppcoreguidelines-no-suspend-with-lock
+  <clang-tidy/checks/cppcoreguidelines/no-suspend-with-lock>` check.
+
+  Flags coroutines that suspend while a lock guard is in scope at the
+  suspension point.
+
 - New :doc:`modernize-use-constraints
   <clang-tidy/checks/modernize/use-constraints>` check.
 
   Replace ``enable_if`` with C++20 requires clauses.
 
 - New :doc:`performance-enum-size
   <clang-tidy/checks/performance/enum-size>` check.
 
   Recommends the smallest possible underlying type for an ``enum`` or ``enum``
   class based on the range of its enumerators.
 
 - New :doc:`readability-reference-to-constructed-temporary
   <clang-tidy/checks/readability/reference-to-constructed-temporary>` check.
 
   Detects C++ code where a reference variable is used to extend the lifetime
   of a temporary object that has just been constructed.
 
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cppcoreguidelines-macro-to-enum
   <clang-tidy/checks/cppcoreguidelines/macro-to-enum>` to :doc:`modernize-macro-to-enum
   <clang-tidy/checks/modernize/macro-to-enum>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/no-suspend-with-lock.rst

+.. title:: clang-tidy - cppcoreguidelines-no-suspend-with-lock
+
+cppcoreguidelines-no-suspend-with-lock
+======================================
+
+Flags coroutines that suspend while a lock guard is in scope at the
+suspension point.
+
+When a coroutine suspends, any mutexes held by the coroutine will remain
+locked until the coroutine resumes and eventually destructs the lock guard.
+This can lead to long periods with a mutex held and runs the risk of deadlock.
+
+Instead, locks should be released before suspending a coroutine.
+
+This check only checks suspending coroutines while a lock_guard is in scope;
+it does not consider manual locking or unlocking of mutexes, e.g., through
+calls to ``std::mutex::lock()``.
+
+Examples:
+
+.. code-block:: c++
+
+  future bad_coro() {
+    std::lock_guard lock{mtx};
+    ++some_counter;
+    co_await something(); // Suspending while holding a mutex
+  }
+
+  future good_coro() {
+    {
+      std::lock_guard lock{mtx};
+      ++some_counter;
+    }
+    // Destroy the lock_guard to release the mutex before suspending the coroutine
+    co_await something(); // Suspending while holding a mutex
+  }
+
+This check implements `CP.52
+<https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rcoro-locks>`_
+from the C++ Core Guidelines.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `cppcoreguidelines-avoid-reference-coroutine-parameters <cppcoreguidelines/avoid-reference-coroutine-parameters.html>`_,
    `cppcoreguidelines-init-variables <cppcoreguidelines/init-variables.html>`_, "Yes"
    `cppcoreguidelines-interfaces-global-init <cppcoreguidelines/interfaces-global-init.html>`_,
    `cppcoreguidelines-macro-usage <cppcoreguidelines/macro-usage.html>`_,
    `cppcoreguidelines-misleading-capture-default-by-value <cppcoreguidelines/misleading-capture-default-by-value.html>`_, "Yes"
    `cppcoreguidelines-missing-std-forward <cppcoreguidelines/missing-std-forward.html>`_,
    `cppcoreguidelines-narrowing-conversions <cppcoreguidelines/narrowing-conversions.html>`_,
    `cppcoreguidelines-no-malloc <cppcoreguidelines/no-malloc.html>`_,
+   `cppcoreguidelines-no-suspend-with-lock <cppcoreguidelines/no-suspend-with-lock.html>`_,
    `cppcoreguidelines-owning-memory <cppcoreguidelines/owning-memory.html>`_,
    `cppcoreguidelines-prefer-member-initializer <cppcoreguidelines/prefer-member-initializer.html>`_, "Yes"
    `cppcoreguidelines-pro-bounds-array-to-pointer-decay <cppcoreguidelines/pro-bounds-array-to-pointer-decay.html>`_,
    `cppcoreguidelines-pro-bounds-constant-array-index <cppcoreguidelines/pro-bounds-constant-array-index.html>`_, "Yes"
    `cppcoreguidelines-pro-bounds-pointer-arithmetic <cppcoreguidelines/pro-bounds-pointer-arithmetic.html>`_,
    `cppcoreguidelines-pro-type-const-cast <cppcoreguidelines/pro-type-const-cast.html>`_,
    `cppcoreguidelines-pro-type-cstyle-cast <cppcoreguidelines/pro-type-cstyle-cast.html>`_, "Yes"
    `cppcoreguidelines-pro-type-member-init <cppcoreguidelines/pro-type-member-init.html>`_, "Yes"

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/no-suspend-with-lock.cpp

+// RUN: %check_clang_tidy -std=c++20 %s cppcoreguidelines-no-suspend-with-lock %t -- -- -fno-delayed-template-parsing
+
+// NOLINTBEGIN
+namespace std {
+template <typename T, typename... Args>
+struct coroutine_traits {
+  using promise_type = typename T::promise_type;
+};
+template <typename T = void>
+struct coroutine_handle;
+template <>
+struct coroutine_handle<void> {
+  coroutine_handle() noexcept;
+  coroutine_handle(decltype(nullptr)) noexcept;
+  static constexpr coroutine_handle from_address(void*);
+};
+template <typename T>
+struct coroutine_handle {
+  coroutine_handle() noexcept;
+  coroutine_handle(decltype(nullptr)) noexcept;
+  static constexpr coroutine_handle from_address(void*);
+  operator coroutine_handle<>() const noexcept;
+};
+
+template <class Mutex>
+class unique_lock {
+public:
+  unique_lock() noexcept;
+  explicit unique_lock(Mutex &m);
+  unique_lock& operator=(unique_lock&&);
+  void unlock();
+  Mutex* release() noexcept;
+  Mutex* mutex() const noexcept;
+  void swap(unique_lock& other) noexcept;
+};
+
+class mutex {
+public:
+  mutex() noexcept;
+  ~mutex();
+  mutex(const mutex &) = delete;
+  mutex &operator=(const mutex &) = delete;
+
+  void lock();
+  void unlock();
+};
+} // namespace std
+
+class my_own_mutex {
+public:
+  void lock();
+  void unlock();
+};
+
+struct Awaiter {
+  bool await_ready() noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
+  void await_resume() noexcept;
+};
+
+struct Coro {
+  struct promise_type {
+    Awaiter initial_suspend();
+    Awaiter final_suspend() noexcept;
+    void return_void();
+    Coro get_return_object();
+    void unhandled_exception();
+    Awaiter yield_value(int);
+  };
+};
+// NOLINTEND
+
+std::mutex mtx;
+std::mutex mtx2;
+
+Coro awaits_with_lock() {
+  std::unique_lock<std::mutex> lock(mtx);
+
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+
+  if (true) {
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  if (true) {
+    std::unique_lock<std::mutex> lock2;
+    lock2.unlock();
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock2' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+}
+
+Coro awaits_with_lock_in_try() try {
+  std::unique_lock<std::mutex> lock(mtx);
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+} catch (...) {}
+
+Coro lock_possibly_unlocked() {
+  // CppCoreGuideline CP.52's enforcement strictly requires flagging
+  // code that suspends while any lock guard is not destructed.
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    lock.unlock();
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    lock.release();
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    std::unique_lock<std::mutex> lock2;
+    lock.swap(lock2);
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    std::unique_lock<std::mutex> lock2{mtx2};
+    lock.swap(lock2);
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    lock = std::unique_lock<std::mutex>{};
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    lock = std::unique_lock<std::mutex>{mtx2};
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+}
+
+Coro await_with_underlying_mutex_unlocked() {
+  std::unique_lock<std::mutex> lock(mtx);
+
+  // Even though we unlock the mutex here, 'lock' is still active unless
+  // there is a call to lock.unlock(). This is a bug in the program since
+  // it will result in locking the mutex twice. The check does not track
+  // unlock calls on the underlying mutex held by a lock guard object.
+  mtx.unlock();
+
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+Coro await_with_empty_lock() {
+  std::unique_lock<std::mutex> lock;
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+Coro await_before_lock() {
+  co_await Awaiter{};
+  std::unique_lock<std::mutex> lock(mtx);
+}
+
+Coro await_with_lock_different_scope() {
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+  }
+  co_await Awaiter{};
+}
+
+Coro await_with_goto() {
+first:
+  co_await Awaiter{};
+  std::unique_lock<std::mutex> lock(mtx);
+  goto first;
+}
+
+void await_in_lambda() {
+  auto f1 = []() -> Coro {
+    std::unique_lock<std::mutex> lock(mtx);
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  };
+
+  auto f2 = [](auto& m) -> Coro {
+    std::unique_lock<decltype(m)> lock(m);
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  };
+}
+
+void await_in_lambda_without_immediate_mutex() {
+  std::unique_lock<std::mutex> lock(mtx);
+
+  auto f1 = []() -> Coro {
+    co_await Awaiter{};
+  };
+
+  // The check only finds suspension points where there is a lock held in the
+  // immediate callable.
+  f1();
+}
+
+Coro yields_with_lock() {
+  std::unique_lock<std::mutex> lock(mtx);
+  co_yield 0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+template <class Mutex>
+Coro awaits_templated_type(Mutex& m) {
+  std::unique_lock<Mutex> lock(m);
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+template <class T>
+Coro awaits_in_template_function(T) {
+  std::unique_lock<std::mutex> lock(mtx);
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+template <class Mutex>
+Coro awaits_in_never_instantiated_template_of_mutex(Mutex& m) {
+  // Nothing should instantiate this function
+  std::unique_lock<Mutex> lock(m);
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+template <class T>
+Coro awaits_in_never_instantiated_templated_function(T) {
+  // Nothing should instantiate this function
+  std::unique_lock<std::mutex> lock(mtx);
+  co_await Awaiter{};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+}
+
+template <class T>
+struct my_container {
+
+  Coro push_back() {
+    std::unique_lock<std::mutex> lock(mtx_);
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  template <class... Args>
+  Coro emplace_back(Args&&...) {
+    std::unique_lock<std::mutex> lock(mtx_);
+    co_await Awaiter{};
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: coroutine suspended with lock 'lock' held [cppcoreguidelines-no-suspend-with-lock]
+  }
+
+  std::mutex mtx_;
+};
+
+void calls_templated_functions() {
+  my_own_mutex m2;
+  awaits_templated_type(mtx);
+  awaits_templated_type(m2);
+
+  awaits_in_template_function(1);
+  awaits_in_template_function(1.0);
+}