Merge branch 'main' into flang/fix-pause-lowering

Author: sathvikreddy853

clang-tools-extra/clang-tidy/ClangTidy.cpp

@@ -356,7 +356,7 @@ ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
   if (Context.canExperimentalCustomChecks() && custom::RegisterCustomChecks)
     custom::RegisterCustomChecks(Context.getOptions(), *CheckFactories);
 #endif
-  for (ClangTidyModuleRegistry::entry const E :
+  for (const ClangTidyModuleRegistry::entry E :
        ClangTidyModuleRegistry::entries()) {
     std::unique_ptr<ClangTidyModule> Module = E.instantiate();
     Module->addCheckFactories(*CheckFactories);

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

@@ -146,7 +146,6 @@ void QualifiedAutoCheck::registerMatchers(MatchFinder *Finder) {
     return qualType(anyOf(qualType(pointerType(pointee(InnerMatchers...))),
                           qualType(substTemplateTypeParmType(hasReplacementType(
                               pointerType(pointee(InnerMatchers...)))))));
-   
   };
 
   auto IsAutoDeducedToPointer =

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp

@@ -562,17 +562,6 @@ ExceptionAnalyzer::throwsException(const Stmt *St,
       }
     }
     Results.merge(Uncaught);
-  } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
-    if (const FunctionDecl *Func = Call->getDirectCallee()) {
-      const ExceptionInfo Excs =
-          throwsException(Func, Caught, CallStack, Call->getBeginLoc());
-      Results.merge(Excs);
-    }
-  } else if (const auto *Construct = dyn_cast<CXXConstructExpr>(St)) {
-    const ExceptionInfo Excs =
-        throwsException(Construct->getConstructor(), Caught, CallStack,
-                        Construct->getBeginLoc());
-    Results.merge(Excs);
   } else if (const auto *DefaultInit = dyn_cast<CXXDefaultInitExpr>(St)) {
     const ExceptionInfo Excs =
         throwsException(DefaultInit->getExpr(), Caught, CallStack);
@@ -602,10 +591,25 @@ ExceptionAnalyzer::throwsException(const Stmt *St,
       Results.merge(Excs);
     }
   } else {
+    // Check whether any of this node's subexpressions throws.
     for (const Stmt *Child : St->children()) {
       const ExceptionInfo Excs = throwsException(Child, Caught, CallStack);
       Results.merge(Excs);
     }
+
+    // If this node is a call to a function or constructor, also check
+    // whether the call itself throws.
+    if (const auto *Call = dyn_cast<CallExpr>(St)) {
+      if (const FunctionDecl *Func = Call->getDirectCallee()) {
+        ExceptionInfo Excs =
+            throwsException(Func, Caught, CallStack, Call->getBeginLoc());
+        Results.merge(Excs);
+      }
+    } else if (const auto *Construct = dyn_cast<CXXConstructExpr>(St)) {
+      ExceptionInfo Excs = throwsException(Construct->getConstructor(), Caught,
+                                           CallStack, Construct->getBeginLoc());
+      Results.merge(Excs);
+    }
   }
   return Results;
 }

clang-tools-extra/docs/ReleaseNotes.rst

@@ -300,7 +300,9 @@ Changes in existing checks
 - Improved :doc:`bugprone-exception-escape
   <clang-tidy/checks/bugprone/exception-escape>` check's handling of lambdas:
   exceptions from captures are now diagnosed, exceptions in the bodies of
-  lambdas that aren't actually invoked are not.
+  lambdas that aren't actually invoked are not. Additionally, fixed an issue
+  where the check wouldn't diagnose throws in arguments to functions or
+  constructors.
 
 - Improved :doc:`bugprone-infinite-loop
   <clang-tidy/checks/bugprone/infinite-loop>` check by adding detection for

clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.rst

@@ -146,7 +146,7 @@ If calls are made using reverse iterators on containers, The code will be
 fixed using the ``boost::adaptors::reverse`` adaptor.
 
 .. code-block:: c++
-  
+
   auto AreSame = std::equal(Items1.rbegin(), Items1.rend(),
                             std::crbegin(Items2), std::crend(Items2));
 
@@ -166,7 +166,7 @@ Options
    is `llvm`.
 
 .. option:: IncludeBoostSystem
-   
+
    If `true` (default value) the boost headers are included as system headers
    with angle brackets (`#include <boost.hpp>`), otherwise quotes are used
    (`#include "boost.hpp"`).

clang-tools-extra/docs/clang-tidy/checks/bugprone/assignment-in-if-condition.rst

@@ -8,7 +8,7 @@ Such assignments are bug-prone because they may have been intended as equality t
 
 This check finds all assignments within `if` conditions, including ones that are not flagged
 by `-Wparentheses` due to an extra set of parentheses, and including assignments that call
-an overloaded `operator=()`. The identified assignments violate 
+an overloaded `operator=()`. The identified assignments violate
 `BARR group "Rule 8.2.c" <https://barrgroup.com/embedded-systems/books/embedded-c-coding-standard/statement-rules/if-else-statements>`_.
 
 .. code-block:: c++

clang-tools-extra/docs/clang-tidy/checks/bugprone/capturing-this-in-member-variable.rst

@@ -30,7 +30,7 @@ Possible fixes:
   - marking copy and move constructors and assignment operators deleted.
   - using class member method instead of class member variable with function
     object types.
-  - passing ``this`` pointer as parameter 
+  - passing ``this`` pointer as parameter.
 
 Options
 -------

clang-tools-extra/docs/clang-tidy/checks/bugprone/crtp-constructor-accessibility.rst

@@ -6,7 +6,7 @@ bugprone-crtp-constructor-accessibility
 Detects error-prone Curiously Recurring Template Pattern usage, when the CRTP
 can be constructed outside itself and the derived class.
 
-The CRTP is an idiom, in which a class derives from a template class, where 
+The CRTP is an idiom, in which a class derives from a template class, where
 itself is the template argument. It should be ensured that if a class is
 intended to be a base class in this idiom, it can only be instantiated if
 the derived class is its template argument.
@@ -23,7 +23,7 @@ Example:
 
   class Derived : CRTP<Derived> {};
 
-Below can be seen some common mistakes that will allow the breaking of the 
+Below can be seen some common mistakes that will allow the breaking of the
 idiom.
 
 If the constructor of a class intended to be used in a CRTP is public, then
@@ -62,7 +62,7 @@ Example:
   class Bad : CRTP<Good> {};
   Bad BadInstance;
 
-To ensure that no accidental instantiation happens, the best practice is to 
+To ensure that no accidental instantiation happens, the best practice is to
 make the constructor private and declare the derived class as friend. Note
 that as a tradeoff, this also gives the derived class access to every other
 private members of the CRTP. However, constructors can still be public or

clang-tools-extra/docs/clang-tidy/checks/bugprone/derived-method-shadowing-base-method.rst

@@ -7,7 +7,7 @@ Finds derived class methods that shadow a (non-virtual) base class method.
 
 In order to be considered "shadowing", methods must have the same signature
 (i.e. the same name, same number of parameters, same parameter types, etc).
-Only checks public, non-templated methods. 
+Only checks public, non-templated methods.
 
 The below example is bugprone because consumers of the ``Derived`` class will
 expect the ``reset`` method to do the work of ``Base::reset()`` in addition to extra
@@ -27,4 +27,4 @@ This is also a violation of the Liskov Substitution Principle.
 
   struct Derived : public Base {
     void reset() {/* reset the derived class, but not the base class */};
-  };
+  };

clang-tools-extra/docs/clang-tidy/checks/bugprone/incorrect-enable-shared-from-this.rst

@@ -3,8 +3,8 @@
 bugprone-incorrect-enable-shared-from-this
 ==========================================
 
-Detect classes or structs that do not publicly inherit from 
-``std::enable_shared_from_this``, because unintended behavior will 
+Detect classes or structs that do not publicly inherit from
+``std::enable_shared_from_this``, because unintended behavior will
 otherwise occur when calling ``shared_from_this``.
 
 Consider the following code:
@@ -15,7 +15,7 @@ Consider the following code:
 
     // private inheritance
     class BadExample : std::enable_shared_from_this<BadExample> {
-    
+
     // ``shared_from_this``` unintended behaviour
     // `libstdc++` implementation returns uninitialized ``weak_ptr``
         public:
@@ -29,6 +29,6 @@ Consider the following code:
         b_ex->bar();
     }
 
-Using `libstdc++` implementation, ``shared_from_this`` will throw 
-``std::bad_weak_ptr``. When ``using_not_public()`` is called, this code will 
+Using `libstdc++` implementation, ``shared_from_this`` will throw
+``std::bad_weak_ptr``. When ``using_not_public()`` is called, this code will
 crash without exception handling.