Merge remote-tracking branch 'origin/main' into pr/63790

Author: topperc

.ci/monolithic-windows.sh

@@ -55,7 +55,7 @@ start-group "ninja"
 ninja -C "${BUILD_DIR}" -k 0 ${targets} |& tee ninja.log
 cp ${BUILD_DIR}/.ninja_log ninja.ninja_log
 
-if [[ "${runtime_targets}" != "" ]]; then
+if [[ "${runtimes_targets}" != "" ]]; then
   start-group "ninja runtimes"
 
   ninja -C "${BUILD_DIR}" -k 0 ${runtimes_targets} |& tee ninja_runtimes.log

.github/workflows/bazel-checks.yml

@@ -33,7 +33,11 @@ jobs:
   
   bazel-build:
     name: "Bazel Build/Test"
-    runs-on: llvm-premerge-linux-runners
+    # Only run on US Central workers so we only have to keep one cache warm as
+    # the cache buckets are per cluster.
+    runs-on:
+      group: llvm-premerge-cluster-us-central
+      labels: llvm-premerge-linux-runners
     if: github.repository == 'llvm/llvm-project'
     steps:
       - name: Fetch LLVM sources
@@ -44,7 +48,7 @@ jobs:
       - name: Setup System Dependencies
         run: |
           sudo apt-get update
-          sudo apt-get install -y libmpfr-dev libpfm4-dev
+          sudo apt-get install -y libmpfr-dev libpfm4-dev m4 libedit-dev
           sudo curl -L https://github.com/bazelbuild/bazelisk/releases/download/v1.27.0/bazelisk-amd64.deb > /tmp/bazelisk.deb
           sudo apt-get install -y /tmp/bazelisk.deb
           rm /tmp/bazelisk.deb
@@ -54,4 +58,4 @@ jobs:
           bazelisk test --config=ci --sandbox_base="" \
             --remote_cache=https://storage.googleapis.com/$CACHE_GCS_BUCKET-bazel \
             --google_default_credentials \
-            @llvm-project//llvm/unittests:adt_tests
+            @llvm-project//... //...

clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.cpp

@@ -73,15 +73,19 @@ CoroutineHostileRAIICheck::CoroutineHostileRAIICheck(StringRef Name,
       RAIITypesList(utils::options::parseStringList(
           Options.get("RAIITypesList", "std::lock_guard;std::scoped_lock"))),
       AllowedAwaitablesList(utils::options::parseStringList(
-          Options.get("AllowedAwaitablesList", ""))) {}
+          Options.get("AllowedAwaitablesList", ""))),
+      AllowedCallees(
+          utils::options::parseStringList(Options.get("AllowedCallees", ""))) {}
 
 void CoroutineHostileRAIICheck::registerMatchers(MatchFinder *Finder) {
   // A suspension happens with co_await or co_yield.
   auto ScopedLockable = varDecl(hasType(hasCanonicalType(hasDeclaration(
                                     hasAttr(attr::Kind::ScopedLockable)))))
                             .bind("scoped-lockable");
   auto OtherRAII = varDecl(typeWithNameIn(RAIITypesList)).bind("raii");
-  auto AllowedSuspend = awaitable(typeWithNameIn(AllowedAwaitablesList));
+  auto AllowedSuspend = awaitable(
+      anyOf(typeWithNameIn(AllowedAwaitablesList),
+            callExpr(callee(functionDecl(hasAnyName(AllowedCallees))))));
   Finder->addMatcher(
       expr(anyOf(coawaitExpr(unless(AllowedSuspend)), coyieldExpr()),
            forEachPrevStmt(
@@ -111,5 +115,7 @@ void CoroutineHostileRAIICheck::storeOptions(
                 utils::options::serializeStringList(RAIITypesList));
   Options.store(Opts, "SafeAwaitableList",
                 utils::options::serializeStringList(AllowedAwaitablesList));
+  Options.store(Opts, "SafeCallees",
+                utils::options::serializeStringList(AllowedCallees));
 }
 } // namespace clang::tidy::misc

clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.h

@@ -46,6 +46,9 @@ class CoroutineHostileRAIICheck : public ClangTidyCheck {
   // List of fully qualified awaitable types which are considered safe to
   // co_await.
   std::vector<StringRef> AllowedAwaitablesList;
+  // List of callees whose return values are considered safe to directly
+  // co_await.
+  std::vector<StringRef> AllowedCallees;
 };
 
 } // namespace clang::tidy::misc

clang-tools-extra/docs/ReleaseNotes.rst

@@ -423,6 +423,11 @@ Changes in existing checks
   positives on return of non-const pointer and fix false positives on
   pointer-to-member operator.
 
+- Improved :doc:`misc-coroutine-hostile-raii
+  <clang-tidy/checks/misc/coroutine-hostile-raii>` check by adding the option
+  `AllowedCallees`, that allows exempting safely awaitable callees from the
+  check.
+
 - Improved :doc:`misc-header-include-cycle
   <clang-tidy/checks/misc/header-include-cycle>` check performance.
 

clang-tools-extra/docs/clang-tidy/checks/abseil/duration-addition.rst

@@ -3,10 +3,10 @@
 abseil-duration-addition
 ========================
 
-Check for cases where addition should be performed in the ``absl::Time`` domain.
-When adding two values, and one is known to be an ``absl::Time``, we can infer
-that the other should be interpreted as an ``absl::Duration`` of a similar
-scale, and make that inference explicit.
+Checks for cases where addition should be performed in the ``absl::Time``
+domain. When adding two values, and one is known to be an ``absl::Time``,
+we can infer that the other should be interpreted as an ``absl::Duration``
+of a similar scale, and make that inference explicit.
 
 Examples:
 

clang-tools-extra/docs/clang-tidy/checks/abseil/duration-division.rst

@@ -4,8 +4,10 @@ abseil-duration-division
 ========================
 
 ``absl::Duration`` arithmetic works like it does with integers. That means that
-division of two ``absl::Duration`` objects returns an ``int64`` with any fractional
-component truncated toward 0. See `this link <https://github.com/abseil/abseil-cpp/blob/29ff6d4860070bf8fcbd39c8805d0c32d56628a3/absl/time/time.h#L137>`_ for more information on arithmetic with ``absl::Duration``.
+division of two ``absl::Duration`` objects returns an ``int64`` with any
+fractional component truncated toward 0.
+See `this link <https://github.com/abseil/abseil-cpp/blob/29ff6d4860070bf8fcbd39c8805d0c32d56628a3/absl/time/time.h#L137>`_
+for more information on arithmetic with ``absl::Duration``.
 
 For example:
 

clang-tools-extra/docs/clang-tidy/checks/abseil/faster-strsplit-delimiter.rst

@@ -5,9 +5,9 @@ abseil-faster-strsplit-delimiter
 
 Finds instances of ``absl::StrSplit()`` or ``absl::MaxSplits()`` where the
 delimiter is a single character string literal and replaces with a character.
-The check will offer a suggestion to change the string literal into a character.
-It will also catch code using ``absl::ByAnyChar()`` for just a single character
-and will transform that into a single character as well.
+The check will offer a suggestion to change the string literal into a
+character. It will also catch code using ``absl::ByAnyChar()`` for just a
+single character and will transform that into a single character as well.
 
 These changes will give the same result, but using characters rather than
 single character string literals is more efficient and readable.

clang-tools-extra/docs/clang-tidy/checks/abseil/string-find-str-contains.rst

@@ -3,8 +3,8 @@
 abseil-string-find-str-contains
 ===============================
 
-Finds ``s.find(...) == string::npos`` comparisons (for various string-like types)
-and suggests replacing with ``absl::StrContains()``.
+Finds ``s.find(...) == string::npos`` comparisons (for various string-like
+types) and suggests replacing with ``absl::StrContains()``.
 
 This improves readability and reduces the likelihood of accidentally mixing
 ``find()`` and ``npos`` from different string-like types.

clang-tools-extra/docs/clang-tidy/checks/abseil/upgrade-duration-conversions.rst

@@ -8,17 +8,17 @@ argument needs an explicit cast to continue compiling after upcoming API
 changes.
 
 The operators ``*=``, ``/=``, ``*``, and ``/`` for ``absl::Duration`` currently
-accept an argument of class type that is convertible to an arithmetic type. Such
-a call currently converts the value to an ``int64_t``, even in a case such as
-``std::atomic<float>`` that would result in lossy conversion.
+accept an argument of class type that is convertible to an arithmetic type.
+Such a call currently converts the value to an ``int64_t``, even in a case such
+as ``std::atomic<float>`` that would result in lossy conversion.
 
 Additionally, the ``absl::Duration`` factory functions (``absl::Hours``,
 ``absl::Minutes``, etc) currently accept an ``int64_t`` or a floating-point
 type. Similar to the arithmetic operators, calls with an argument of class type
 that is convertible to an arithmetic type go through the ``int64_t`` path.
 
-These operators and factories will be changed to only accept arithmetic types to
-prevent unintended behavior. After these changes are released, passing an
+These operators and factories will be changed to only accept arithmetic types
+to prevent unintended behavior. After these changes are released, passing an
 argument of class type will no longer compile, even if the type is implicitly
 convertible to an arithmetic type.