[clang-tidy] add concurrency-async-no-new-threads

[segoon]

Summary

Checks for functions and types that create new system threads.

The check by default searches for types/functions from the following categories:

• C++ std
• Boost.Thread, part of Boost.Compute
• C11 threads
• POSIX threads (pthreads)
• Linux syscalls

Custom functions and types can be added via options.

[Eugene.Zelenko]

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

7

Please make first statement same as in Release Notes.

26

Please add information about default value. Same below.

[segoon]

• fix the first document line
• add default values

[segoon]

Eugene.Zelenko, thanks for the review! fixed

[segoon]

Eugene.Zelenko, njames93, any comments on the patch?

[Eugene.Zelenko]

In D94622#2509323, @segoon wrote:

Eugene.Zelenko, njames93, any comments on the patch?

Sorry, you need to wait for approval from one of maintainers mentioned as reviewers. I check only documentation and for minor code issues.

[segoon]

• explicitly state in docs that the check must be used only for async code

[segoon]

alexfh, aaron.ballman, hi! Any comments on the patch?

[aaron.ballman]

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.cpp

23

The trailing comment markers don't really add much.

34

If we're going to add these, we should probably also add ones for Win32 and Mac OS as well, like CreateThread, CreateRemoteThread, _beginthread, _beginthreadex, etc.

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

9–11

FWIW, this suggests to me that what you really want is a way for APIs to opt into this behavior. There's no reason why you wouldn't have a complex system that has both threads and coroutines in it, but it does stand to reason that you may want to say "this function, and everything called within this function, should not create any system threads" in some situations.

The note below helps call out the expectations from the check, but it requires the developer to restructure the way they write code pretty drastically in order to make the checking behavior more reasonable, which does not seem ideal.

[segoon]

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.cpp

23

it's a hack for clang-format, otherwise it contatenates the lines, creating unmaintainable mess of strings. "One line - one name" is much more suitable.

34

I don't mind, but I'm not an expert in WinAPI or Windows programming. So, this part should be by someone with expertise of Windows in separate patches.

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

9–11

I think it is a complex problem, so it should be separated into smaller tasks.

Step one - checks with hardcoded functions/types with user-guided enabling on a per-file basis. A semi-automated check.

Step two - try to solve other parts of the puzzle. Maybe try to add [clang:coroutine_safe] tag and teach clang static analyzer to deduce coroutine safety property and use it for enabling/disabling the cheks. Maybe reuse other (not yet implemented) heuristics from static analyzer (or other tools) to identify coroutine functions and check only these functions. I'm not an expert in static analyzer, so other LLVM developers might find a clever heuristics when to enable/disable these checks or maybe how to deduce blacklisted/whitelisted functions/types lists (e.g. for concurrency-async-{fs,blocking}).

Indeed, the current approach has its own limitations. But it may be a first step in the right direction.

[aaron.ballman]

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.cpp

23

Ah, I didn't know that'd change the behavior of clang-format, that's neat!

FWIW, we usually don't do a whole lot of markup to avoid clang-format issues (such as the clang-format: on/off markers). Instead, we usually just ignore the LINT warnings in code review and check the code in as-is. This helps reduce clutter in the code base. In this case, the comments aren't adding a ton of clutter so maybe they're fine. But they definitely look odd as a reader of the code, which is a bit distracting.

34

I don't think it needs to be done in separate patches. I can give you the full list of things I care about.

CreateThread (https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createthread)
CreateRemoteThread (https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread)
CreateRemoteThreadEx (https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethreadex)
_beginthread
_beginthreadex (https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/beginthread-beginthreadex?view=msvc-160)

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

9–11

My fear with the current approach is that I don't think projects usually split their code in the way this check requires, and so the check will not be very useful in practice because it will be too chatty. Have you tried running this check over some large projects that use coroutines to see what the diagnostic results look like?

[curdeius]

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

15

Typo: Insead -> Instead

[segoon]

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.cpp

23

IMO having an ability to run clang-format for sources is very handy. It makes me sad if running clang-format against the source forces me to set some markers or reverting a part of clang-format changes in the source parts I have never touched. An ability to simply rerun checks/linters is very powerful.

34

Oh, great, thank you! Added.

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

9–11

I haven't conducted a survey, but I can say for Yandex.Taxi where the patch has originated. The codebase is ~350KLOC. The main parts are:

1. a coroutine framework that uses blocking functions / threads creation /etc. inside - concurrency-async-* disabled
2. coroutine libraries consisting of coroutine-only code - concurrency-async-* enabled
3. services with coroutine-only code - concurrency-async-* enabled

All 3 parts are clearly separated from each other from the filesystem prospective. Actually I think there are plenty of other invariants that must be met for coroutine code, so separate coroutine/non-coroutine namespaces (and consequently, filesystem separation) is a must. E.g. there are filesystem::RewriteFileContents() and filesystem::blocking::RewriteFileContents() - trivial to realize whether you may call it or not. I admit that other projects may have quite different approach to namespaces/modules, though.

[segoon]

• add WinAPI support

[segoon]

-fix typo

[aaron.ballman]

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.cpp

23

I empathize, but clang-format is a moving target that hasn't existed as long as the rest of the project, so the project has a mismatch of formats. This is why the usual rule of thumb is: clang-format a full file and accept what it produces (on new files, like this one) or clang-format your diff (on existing files). If you don't like what clang-format produces in either situation, we typically format it by hand and then don't worry about it until the next time someone touches that code. Of course, I notice that we don't mention clang-format anywhere in the style guide at all. :-(

I won't insist on a change here, but I also would not be surprised if the useless comment markers were removed by someone during a "cleanup" either.

41

Missing the :: in front of all of these identifiers.

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

9–11

I admit that other projects may have quite different approach to namespaces/modules, though.

That's why I'm hoping you can take some measurements of other projects -- it wouldn't be good to add a check that's highly specific to one project's coding style (unless it's a check for a particular style guide that's published somewhere), and I worry a bit that's what is happening here.

[segoon]

It seems that the related file structure (IOW, "separated coroutine code and non-coroutine code" rule) is indeed specific to Yandex.Taxi. I asked multiple developers in different companies and no one could confirm they align with the rule. The checks in the current form seem to have lower value outside of Yandex.Taxi than I thought. So, I'll close PRs with the checks in the current form (unless someone tell me what part of the check(s) could be used in another way). Thanks for all who reviewed the patches and made suggestions :)

FWIW, we'll still use the checks in Yandex.Taxi. A clang static analyzer check or some other graph analysis / manual attributes marking approach would fit better for the LLVM upstream.

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.h

+//===--- AsyncNoNewThreadsCheck.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_CONCURRENCY_ASYNCNONEWTHREADSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_ASYNCNONEWTHREADSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace concurrency {
+
+/// Checks for types/functions that create new system threads
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/concurrency-async-no-new-threads.html
+class AsyncNoNewThreadsCheck : public ClangTidyCheck {
+public:
+  AsyncNoNewThreadsCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  const std::string FunctionsExtra;
+  const std::string TypesExtra;
+};
+
+} // namespace concurrency
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_ASYNCNONEWTHREADSCHECK_H

clang-tools-extra/clang-tidy/concurrency/AsyncNoNewThreadsCheck.cpp

+//===--- AsyncNoNewThreadsCheck.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 "AsyncNoNewThreadsCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+static const char Function[] = "func";
+static const char TypeName[] = "type";
+static const char Identifier[] = "id";
+static const char Name[] = "name";
+
+static const clang::StringRef ThreadFunctions[] = {
+    /* C++ std */
+    "::std::async", //
+
+    /* Boost.Thread */
+    "::boost::async",
+
+    /* POSIX */
+    "::pthread_create", //
+
+    /* С11 */
+    "::thrd_create", //
+
+    /* Linux */
+    "::fork",     //
+    "::vfork",    //
+    "::clone",    //
+    "::__clone2", //
+    "::clone3",   //
+
+    /* WinAPI */
+    "CreateThread",         //
+    "CreateRemoteThread",   //
+    "CreateRemoteThreadEx", //
+    "_beginthread",         //
+    "_beginthreadex",       //
+};
+
+static const clang::StringRef ThreadTypes[] = {
+    /* C++ std */
+    "::std::thread",                                 //
+    "::std::jthread",                                //
+    "::std::execution::parallel_policy",             //
+    "::std::execution::parallel_unsequenced_policy", //
+    "::std::execution::unsequenced_policy",          //
+
+    /* Boost.Thread */
+    "::boost::thread",        //
+    "::boost::thread_group",  //
+    "::boost::scoped_thread", //
+
+    /* Boost.Compute */
+    "::boost::compute::device", //
+};
+
+static const clang::StringRef ThreadIdentifiers[] = {
+    /* C++ std */
+    "::std::execution::par",       //
+    "::std::execution::par_unseq", //
+    "::std::execution::unseq",     //
+};
+
+static std::vector<llvm::StringRef>
+toVector(llvm::ArrayRef<llvm::StringRef> Base, llvm::StringRef Extra) {
+  llvm::SmallVector<llvm::StringRef, 4> Tmp{Base.begin(), Base.end()};
+  if (!Extra.empty()) {
+    Extra.split(Tmp, ";");
+  }
+
+  return {Tmp.begin(), Tmp.end()};
+}
+
+namespace clang {
+namespace tidy {
+namespace concurrency {
+
+AsyncNoNewThreadsCheck::AsyncNoNewThreadsCheck(StringRef Name,
+                                               ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      FunctionsExtra(Options.get("FunctionsExtra", "")),
+      TypesExtra(Options.get("TypesExtra", "")) {}
+
+void AsyncNoNewThreadsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "FunctionsExtra", FunctionsExtra);
+  Options.store(Opts, "TypesExtra", TypesExtra);
+}
+
+void AsyncNoNewThreadsCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      callExpr(callee(functionDecl(
+                          hasAnyName(toVector(ThreadFunctions, FunctionsExtra)))
+                          .bind(Name)))
+          .bind(Function),
+      this);
+
+  Finder->addMatcher(
+      valueDecl(
+          hasType(cxxRecordDecl(hasAnyName(toVector(ThreadTypes, TypesExtra)))
+                      .bind(Name)))
+          .bind(TypeName),
+      this);
+
+  Finder->addMatcher(
+      declRefExpr(
+          hasDeclaration(namedDecl(hasAnyName(ThreadIdentifiers)).bind(Name)))
+          .bind(Identifier),
+      this);
+}
+
+void AsyncNoNewThreadsCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *N = Result.Nodes.getNodeAs<NamedDecl>(Name);
+  assert(N);
+
+  if (const auto *CE = Result.Nodes.getNodeAs<CallExpr>(Function)) {
+    diag(CE->getBeginLoc(), "function %0 creates new threads")
+        << N << CE->getSourceRange();
+  } else if (const auto *Decl = Result.Nodes.getNodeAs<ValueDecl>(TypeName)) {
+    diag(Decl->getBeginLoc(), "type %0 creates new threads")
+        << N << Decl->getSourceRange();
+  } else if (const auto *Id = Result.Nodes.getNodeAs<DeclRefExpr>(Identifier)) {
+    diag(Id->getBeginLoc(), "use of %0 creates new threads")
+        << N << Id->getSourceRange();
+  } else {
+    assert(false);
+  }
+}
+
+} // namespace concurrency
+} // namespace tidy
+} // namespace clang

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

   )
 
 add_clang_library(clangTidyConcurrencyModule
+  AsyncNoNewThreadsCheck.cpp
   ConcurrencyTidyModule.cpp
   MtUnsafeCheck.cpp
 

clang-tools-extra/clang-tidy/concurrency/ConcurrencyTidyModule.cpp

 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "AsyncNoNewThreadsCheck.h"
 #include "MtUnsafeCheck.h"
 
 namespace clang {

 class ConcurrencyModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<AsyncNoNewThreadsCheck>(
+        "concurrency-async-no-new-threads");
     CheckFactories.registerCheck<concurrency::MtUnsafeCheck>(
         "concurrency-mt-unsafe");
   }

clang-tools-extra/docs/ReleaseNotes.rst

   Finds structs that are inefficiently packed or aligned, and recommends
   packing and/or aligning of said structs as needed.
 
+- New :doc:`concurrency-async-no-new-threads
+  <clang-tidy/checks/concurrency-async-no-new-threads>` check.
+
+  Finds functions and types that create new system threads.
+
 - New :doc:`cppcoreguidelines-prefer-member-initializer
   <clang-tidy/checks/cppcoreguidelines-prefer-member-initializer>` check.
 

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-no-new-threads.rst

+.. title:: clang-tidy - concurrency-async-no-new-threads
+
+concurrency-async-no-new-threads
+================================
+
+Finds functions and types that create new system threads. It is not
+a bug per se, but asynchronous code is expected to use only asynchronous
+functions and types. E.g. if the code uses C++ coroutines, it is expected
+that only new coroutines or coroutine-based primitives are created
+instead of heavy system threads.
+
+.. note::
+
+   The check doesn't identify synchronous and asynchronous code. Instead, it
+   assumes that all analyzed code is asynchronous and all blocking calls have to
+   be found. You should split the sync and async code at the filesystem level
+   and enable `concurrency-async-*` checks for files with asynchronous code
+   only.
+
+The check by default searches for types/functions from the following categories:
+
+* C++ std
+* Boost.Thread, part of Boost.Compute
+* C11 threads
+* POSIX threads (pthreads)
+* Linux syscalls
+
+Options
+-------
+
+.. option:: FunctionsExtra
+
+  Specifies additional functions to search for, separated with semicolon.
+  Defaults to empty string (no functions).
+
+.. option:: TypesExtra
+
+  Specifies additional types to search for, separated with semicolon.
+  Defaults to empty string (no types).

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

    `clang-analyzer-valist.CopyToSelf <clang-analyzer-valist.CopyToSelf.html>`_,
    `clang-analyzer-valist.Uninitialized <clang-analyzer-valist.Uninitialized.html>`_,
    `clang-analyzer-valist.Unterminated <clang-analyzer-valist.Unterminated.html>`_,
+   `concurrency-async-no-new-threads <concurrency-async-no-new-threads.html>`_,
    `concurrency-mt-unsafe <concurrency-mt-unsafe.html>`_,
    `cppcoreguidelines-avoid-goto <cppcoreguidelines-avoid-goto.html>`_,
    `cppcoreguidelines-avoid-non-const-global-variables <cppcoreguidelines-avoid-non-const-global-variables.html>`_,

clang-tools-extra/test/clang-tidy/checkers/concurrency-async-no-new-threads.c

+// RUN: %check_clang_tidy %s concurrency-async-no-new-threads %t
+
+int pthread_create(int *thread, const int *attr,
+                   void *(*start_routine)(void *), void *arg);
+
+int thrd_create(int *thr, int func, void *arg);
+
+int fork();
+
+int vfork();
+
+int clone(int (*fn)(void *), void *child_stack,
+          int flags, void *arg);
+
+long clone3(int *cl_args, int size);
+
+void test_threads() {
+  pthread_create(0, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'pthread_create' creates new threads [concurrency-async-no-new-threads]
+
+  thrd_create(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'thrd_create' creates new threads [concurrency-async-no-new-threads]
+
+  fork();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'fork' creates new threads [concurrency-async-no-new-threads]
+
+  vfork();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'vfork' creates new threads [concurrency-async-no-new-threads]
+
+  clone(0, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'clone' creates new threads [concurrency-async-no-new-threads]
+
+  clone3(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'clone3' creates new threads [concurrency-async-no-new-threads]
+}

clang-tools-extra/test/clang-tidy/checkers/concurrency-async-no-new-threads.cpp

+// RUN: %check_clang_tidy %s concurrency-async-no-new-threads %t -- \
+// RUN: -config='{CheckOptions: [{key: "concurrency-async-no-new-threads.FunctionsExtra", value: "::my::create_thread"},{key: "concurrency-async-no-new-threads.TypesExtra", value: "::my::thread"}]}'
+
+namespace std {
+
+class thread {
+public:
+  void join() {}
+};
+
+class jthread {};
+
+class nothread {};
+
+namespace execution {
+
+class sequenced_policy {};
+
+class parallel_policy {};
+
+class parallel_unsequenced_policy {};
+
+class unsequenced_policy {};
+
+sequenced_policy seq;
+parallel_policy par;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: type 'parallel_policy' creates new threads [concurrency-async-no-new-threads]
+parallel_unsequenced_policy par_unseq;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: type 'parallel_unsequenced_policy' creates new threads [concurrency-async-no-new-threads]
+unsequenced_policy unseq;
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: type 'unsequenced_policy' creates new threads [concurrency-async-no-new-threads]
+
+} // namespace execution
+
+void async(int (*)()) {
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+void sort(T1 &&, T2, T3, T4);
+
+} // namespace std
+
+int pthread_create(int *thread, const int *attr,
+                   void *(*start_routine)(void *), void *arg);
+
+int thrd_create(int *thr, int func, void *arg);
+
+int fork();
+
+int vfork();
+
+int clone(int (*fn)(void *), void *child_stack,
+          int flags, void *arg);
+
+long clone3(int *cl_args, int size);
+
+namespace boost {
+
+class thread {};
+
+class scoped_thread {};
+
+void async(int (*)()) {}
+
+namespace compute {
+class device {};
+
+} // namespace compute
+
+} // namespace boost
+
+void test_threads() {
+  std::thread t;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'thread' creates new threads [concurrency-async-no-new-threads]
+
+  std::jthread j;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'jthread' creates new threads [concurrency-async-no-new-threads]
+
+  std::execution::parallel_policy pp;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'parallel_policy' creates new threads [concurrency-async-no-new-threads]
+
+  std::execution::sequenced_policy sp;
+
+  std::sort(std::execution::par, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of 'par' creates new threads [concurrency-async-no-new-threads]
+
+  boost::thread bt;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'thread' creates new threads [concurrency-async-no-new-threads]
+  boost::scoped_thread bst;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'scoped_thread' creates new threads [concurrency-async-no-new-threads]
+
+  boost::compute::device bcd;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'device' creates new threads [concurrency-async-no-new-threads]
+
+  std::async(fork);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'async' creates new threads [concurrency-async-no-new-threads]
+
+  boost::async(fork);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'async' creates new threads [concurrency-async-no-new-threads]
+
+  pthread_create(0, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'pthread_create' creates new threads [concurrency-async-no-new-threads]
+
+  thrd_create(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'thrd_create' creates new threads [concurrency-async-no-new-threads]
+
+  fork();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'fork' creates new threads [concurrency-async-no-new-threads]
+
+  vfork();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'vfork' creates new threads [concurrency-async-no-new-threads]
+
+  clone(0, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'clone' creates new threads [concurrency-async-no-new-threads]
+
+  clone3(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'clone3' creates new threads [concurrency-async-no-new-threads]
+}
+
+namespace my {
+
+class thread {};
+void create_thread();
+
+} // namespace my
+
+void test_extra() {
+  my::thread t;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'thread' creates new threads [concurrency-async-no-new-threads]
+
+  my::create_thread();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'create_thread' creates new threads [concurrency-async-no-new-threads]
+}