[clang-tools-extra] [clang-tidy] Added bugprone-exception-rethrow check (PR #86448)

[Julian Schmidt via cfe-commits]

================
@@ -0,0 +1,84 @@
+.. title:: clang-tidy - bugprone-exception-rethrow
+
+bugprone-exception-rethrow
+==========================
+
+Identifies problematic exception rethrowing, especially with caught exception
+variables or empty throw statements outside catch blocks.
+
+In C++ exception handling, a common pitfall occurs when developers rethrow
+caught exceptions within catch blocks by directly passing the caught exception
+variable to the ``throw`` statement. While this approach can propagate
+exceptions to higher levels of the program, it often leads to code that is less
+clear and more error-prone. Rethrowing caught exceptions with the same exception
+object within catch blocks can obscure the original context of the exception and
+make it challenging to trace program flow. Additionally, this method can
+introduce issues such as exception object slicing and performance overhead due
+to the invocation of the copy constructor.
+
+.. code-block:: c++
+
+  try {
+    // Code that may throw an exception
+  } catch (const std::exception& e) {
+    throw e; // Bad, 'e' is copied
+  }
+
+.. code-block:: c++
+
+  class derived_exception : public std::exception { ... };
+
+  void throwDerived() { throw derived_exception{}; }
+
+  try {
+    throwDerived();
+  } catch (const std::exception& e) {
+    throw e; // Bad, exception slicing occurs when 'derived_exception' is
+             // being rethrown as 'std::exception'
+  }
+
+To prevent these issues, it is advised to utilize ``throw;`` statements to
+rethrow the original exception object for currently handled exceptions.
+
+.. code-block:: c++
+
+  try {
+    // Code that may throw an exception
+  } catch (const std::exception&) {
+    throw; // Good
+  }
+
+However, when an empty throw statement is used without an active exception, it
----------------
5chmidti wrote:

`empty throw statement is used without an active exception` sounds too close to meaning `throw e;`. I think it would be better to write `However, when an empty throw statement is used and no exception is currently being handled,`

https://github.com/llvm/llvm-project/pull/86448