bugprone-exception-escape

.clang-tidy

@@ -31,7 +31,6 @@ Checks:
   - 'clang-diagnostic-*'
   - 'bugprone-*'
   - '-bugprone-misplaced-widening-cast'
-  - '-bugprone-exception-escape'
   - '-bugprone-crtp-constructor-accessibility'
   - '-bugprone-branch-clone'
   - '-bugprone-argument-comment'

cmake/CCCLAddTidyTarget.cmake

@@ -24,6 +24,16 @@ function(cccl_tidy_init)
 
   find_program(CCCL_CLANG_TIDY clang-tidy REQUIRED)
 
+  execute_process(
+    COMMAND ${CCCL_CLANG_TIDY} --version
+    OUTPUT_VARIABLE version
+    ERROR_VARIABLE version
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    COMMAND_ERROR_IS_FATAL ANY
+  )
+
+  message(STATUS "Found clang-tidy: ${CCCL_CLANG_TIDY} (${version})")
+
   add_custom_target(cccl.tidy COMMENT "clang-tidy CCCL")
 
   set(

cub/examples/device/example_device_radix_sort_custom.cu

@@ -41,7 +41,8 @@ std::bitset<64> to_binary_representation(custom_t value)
   return std::bitset<64>{bits};
 }
 
-int main()
+// TODO(jfaibussowit): Remove when CI clang-tidy is bumped to clang-22
+int main() // NOLINT(bugprone-exception-escape)
 {
   std::cout << "This example illustrates use of radix sort with custom type.\n";
   std::cout << "Let's define a simple structure of the following form:\n\n";

cub/examples/device/example_device_topk_keys.cu

@@ -67,7 +67,9 @@ thrust::host_vector<float> sort_unordered_results(thrust::host_vector<float> h_r
 //---------------------------------------------------------------------
 // Main
 //--------------------------------------------------------------------
-int main(int argc, char** argv)
+
+// TODO(jfaibussowit): Remove when CI clang-tidy is bumped to clang-22
+int main(int argc, char** argv) // NOLINT(bugprone-exception-escape)
 {
   int num_items = 10240;
   int k         = 10;

cub/examples/device/example_device_topk_pairs.cu

@@ -78,7 +78,9 @@ sort_unordered_results(thrust::host_vector<float> h_res_keys, thrust::host_vecto
 //---------------------------------------------------------------------
 // Main
 //---------------------------------------------------------------------
-int main(int argc, char** argv)
+
+// TODO(jfaibussowit): Remove when CI clang-tidy is bumped to clang-22
+int main(int argc, char** argv) // NOLINT(bugprone-exception-escape)
 {
   int num_items = 10240;
   int k         = 10;

cub/test/test_device_batch_copy.cu

@@ -331,7 +331,8 @@ void nontrivial_constructor_test()
   }
 }
 
-int main(int argc, char** argv)
+// TODO(jfaibussowit): Remove when CI clang-tidy is bumped to clang-22
+int main(int argc, char** argv) // NOLINT(bugprone-exception-escape)
 {
   CommandLineArgs args(argc, argv);
 

cub/test/test_namespace_wrapped.cu

@@ -24,7 +24,9 @@
 // Test that we can use a few common utilities and algorithms from wrapped
 // Thrust/CUB namespaces at runtime. More extensive testing is performed by the
 // header tests and the check_namespace.cmake test.
-int main(int argc, char** argv)
+
+// TODO(jfaibussowit): Remove when CI clang-tidy is bumped to clang-22
+int main(int argc, char** argv) // NOLINT(bugprone-exception-escape)
 {
   CommandLineArgs args(argc, argv);
   CubDebugExit(args.DeviceInit());

cudax/examples/vector.cuh

@@ -93,7 +93,7 @@ private:
     using __cv_vector = ::cuda::std::__maybe_const<_Kind == __detail::__param_kind::_in, vector>;
 
   public:
-    explicit __action(::cuda::stream_ref __str, __cv_vector& __v) noexcept
+    explicit __action(::cuda::stream_ref __str, __cv_vector& __v)
         : __str_(__str)
         , __v_(__v)
     {
@@ -102,7 +102,7 @@ private:
 
     __action(__action&&) = delete;
 
-    ~__action()
+    ~__action() noexcept(false)
     {
       __v_.sync_device_to_host(__str_, _Kind);
     }
@@ -118,20 +118,20 @@ private:
   };
 
   [[nodiscard]] friend __action<__detail::__param_kind::_inout>
-  transform_launch_argument(::cuda::stream_ref __str, vector& __v) noexcept
+  transform_launch_argument(::cuda::stream_ref __str, vector& __v)
   {
     return __action<__detail::__param_kind::_inout>{__str, __v};
   }
 
   [[nodiscard]] friend __action<__detail::__param_kind::_in>
-  transform_launch_argument(::cuda::stream_ref __str, const vector& __v) noexcept
+  transform_launch_argument(::cuda::stream_ref __str, const vector& __v)
   {
     return __action<__detail::__param_kind::_in>{__str, __v};
   }
 
   template <__detail::__param_kind _Kind>
   [[nodiscard]] friend __action<_Kind>
-  transform_launch_argument(::cuda::stream_ref __str, __detail::__box<vector, _Kind> __b) noexcept
+  transform_launch_argument(::cuda::stream_ref __str, __detail::__box<vector, _Kind> __b)
   {
     return __action<_Kind>{__str, __b.__val};
   }

libcudacxx/include/cuda/__driver/driver_api.h

@@ -96,7 +96,8 @@ _CCCL_SUPPRESS_DEPRECATED_NVRTC_DIAG
 }
 #  else // ^^^ _CCCL_HOSTED() ^^^ / vvv !_CCCL_HOSTED() vvv
 [[nodiscard]]
-_CCCL_PUBLIC_HOST_API inline auto __getProcAddressFn(decltype(cuGetProcAddress)* __ptr = nullptr, bool __set = false)
+_CCCL_PUBLIC_HOST_API inline auto
+__getProcAddressFn(decltype(cuGetProcAddress)* __ptr = nullptr, bool __set = false) noexcept
   -> decltype(cuGetProcAddress)*
 {
   static decltype(cuGetProcAddress)* __fn = __ptr;
@@ -291,7 +292,8 @@ _CCCL_HOST_API inline void __deviceGetName(char* __name_out, int __len, int __or
   return __result;
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __primaryCtxReleaseNoThrow(::CUdevice __dev)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__primaryCtxReleaseNoThrow(::CUdevice __dev) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuDevicePrimaryCtxRelease);
   return static_cast<::cudaError_t>(__driver_fn(__dev));
@@ -428,8 +430,9 @@ _CCCL_HOST_API void __memsetAsync(void* __dst, _Tp __value, ::cuda::std::size_t
   }
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__mempoolCreateNoThrow(::CUmemoryPool* __pool, ::CUmemPoolProps* __props)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __mempoolCreateNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUmemoryPool* __pool,
+  ::CUmemPoolProps* __props) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuMemPoolCreate);
   return static_cast<::cudaError_t>(__driver_fn(__pool, __props));
@@ -449,7 +452,8 @@ _CCCL_HOST_API inline ::cuda::std::size_t __mempoolGetAttribute(::CUmemoryPool _
   return __value;
 }
 
-_CCCL_HOST_API inline ::cudaError_t __mempoolDestroyNoThrow(::CUmemoryPool __pool) noexcept
+_CCCL_HOST_API inline ::cudaError_t
+__mempoolDestroyNoThrow(::CUmemoryPool __pool) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuMemPoolDestroy);
   return static_cast<::cudaError_t>(__driver_fn(__pool));
@@ -480,7 +484,8 @@ _CCCL_HOST_API inline void __mempoolTrimTo(::CUmemoryPool __pool, ::cuda::std::s
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to trim a memory pool", __pool, __min_bytes_to_keep);
 }
 
-_CCCL_HOST_API inline ::cudaError_t __freeAsyncNoThrow(::CUdeviceptr __dptr, ::CUstream __stream)
+_CCCL_HOST_API inline ::cudaError_t
+__freeAsyncNoThrow(::CUdeviceptr __dptr, ::CUstream __stream) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuMemFreeAsync);
   return static_cast<::cudaError_t>(__driver_fn(__dptr, __stream));
@@ -501,8 +506,10 @@ _CCCL_HOST_API inline ::CUmemAccess_flags __mempoolGetAccess(::CUmemoryPool __po
   return __flags;
 }
 
-_CCCL_HOST_API inline ::cudaError_t
-__mempoolGetAccessNoThrow(::CUmemAccess_flags& __flags, ::CUmemoryPool __pool, ::CUmemLocation* __location) noexcept
+_CCCL_HOST_API inline ::cudaError_t __mempoolGetAccessNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUmemAccess_flags& __flags,
+  ::CUmemoryPool __pool,
+  ::CUmemLocation* __location) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuMemPoolGetAccess);
   return static_cast<::cudaError_t>(__driver_fn(&__flags, __pool, __location));
@@ -545,13 +552,13 @@ _CCCL_HOST_API inline void* __mallocHost(::cuda::std::size_t __bytes)
   return __result;
 }
 
-_CCCL_HOST_API inline ::cudaError_t __freeNoThrow(::CUdeviceptr __dptr)
+_CCCL_HOST_API inline ::cudaError_t __freeNoThrow(::CUdeviceptr __dptr) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuMemFree);
   return static_cast<::cudaError_t>(__driver_fn(__dptr));
 }
 
-_CCCL_HOST_API inline ::cudaError_t __freeHostNoThrow(void* __dptr)
+_CCCL_HOST_API inline ::cudaError_t __freeHostNoThrow(void* __dptr) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuMemFreeHost);
   return static_cast<::cudaError_t>(__driver_fn(__dptr));
@@ -597,8 +604,9 @@ template <::CUpointer_attribute _Attr>
 using __pointer_attribute_value_type_t = decltype(::cuda::__driver::__pointer_attribute_value_type_t_impl<_Attr>());
 
 template <::CUpointer_attribute _Attr>
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__pointerGetAttributeNoThrow(__pointer_attribute_value_type_t<_Attr>& __result, const void* __ptr)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __pointerGetAttributeNoThrow( // NOLINT(bugprone-exception-escape)
+  __pointer_attribute_value_type_t<_Attr>& __result,
+  const void* __ptr) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuPointerGetAttribute);
   ::cudaError_t __status{};
@@ -626,8 +634,10 @@ template <::CUpointer_attribute _Attr>
 }
 
 template <::cuda::std::size_t _Np>
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__pointerGetAttributesNoThrow(::CUpointer_attribute (&__attrs)[_Np], void* (&__results)[_Np], const void* __ptr)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __pointerGetAttributesNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUpointer_attribute (&__attrs)[_Np],
+  void* (&__results)[_Np],
+  const void* __ptr) noexcept
 {
   static const auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuPointerGetAttributes);
   return static_cast<::cudaError_t>(
@@ -651,7 +661,8 @@ __streamAddCallback(::CUstream __stream, ::CUstreamCallback __cb, void* __data,
   return __stream;
 }
 
-_CCCL_HOST_API inline ::cudaError_t __streamSynchronizeNoThrow(::CUstream __stream)
+_CCCL_HOST_API inline ::cudaError_t
+__streamSynchronizeNoThrow(::CUstream __stream) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuStreamSynchronize);
   return static_cast<::cudaError_t>(__driver_fn(__stream));
@@ -731,7 +742,8 @@ _CCCL_HOST_API inline void __streamWaitEvent(::CUstream __stream, ::CUevent __ev
     __driver_fn, "Failed to make a stream wait for an event", __stream, __evnt, ::CU_EVENT_WAIT_DEFAULT);
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __streamQueryNoThrow(::CUstream __stream)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__streamQueryNoThrow(::CUstream __stream) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuStreamQuery);
   return static_cast<::cudaError_t>(__driver_fn(__stream));
@@ -753,7 +765,8 @@ _CCCL_HOST_API inline void __streamWaitEvent(::CUstream __stream, ::CUevent __ev
   return __id;
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __streamDestroyNoThrow(::CUstream __stream)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__streamDestroyNoThrow(::CUstream __stream) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuStreamDestroy);
   return static_cast<::cudaError_t>(__driver_fn(__stream));
@@ -769,7 +782,8 @@ _CCCL_HOST_API inline void __streamWaitEvent(::CUstream __stream, ::CUevent __ev
   return __evnt;
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __eventDestroyNoThrow(::CUevent __evnt)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__eventDestroyNoThrow(::CUevent __evnt) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuEventDestroy);
   return static_cast<::cudaError_t>(__driver_fn(__evnt));
@@ -783,7 +797,8 @@ _CCCL_HOST_API inline void __streamWaitEvent(::CUstream __stream, ::CUevent __ev
   return __result;
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __eventQueryNoThrow(::CUevent __evnt)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__eventQueryNoThrow(::CUevent __evnt) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuEventQuery);
   return static_cast<::cudaError_t>(__driver_fn(__evnt));
@@ -863,7 +878,8 @@ __kernelGetAttribute(::CUfunction_attribute __attr, ::CUkernel __kernel, ::CUdev
   return __result;
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __libraryUnloadNoThrow(::CUlibrary __library)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__libraryUnloadNoThrow(::CUlibrary __library) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuLibraryUnload);
   return static_cast<::cudaError_t>(__driver_fn(__library));
@@ -879,45 +895,58 @@ __kernelGetAttribute(::CUfunction_attribute __attr, ::CUkernel __kernel, ::CUdev
 }
 #  endif // _CCCL_CTK_AT_LEAST(12, 5)
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__libraryGetKernelNoThrow(::CUkernel& __kernel, ::CUlibrary __lib, const char* __name)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __libraryGetKernelNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUkernel& __kernel,
+  ::CUlibrary __lib,
+  const char* __name) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuLibraryGetKernel);
   return static_cast<cudaError_t>(__driver_fn(&__kernel, __lib, __name));
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__libraryGetGlobalNoThrow(::CUdeviceptr& __dptr, ::cuda::std::size_t& __nbytes, ::CUlibrary __lib, const char* __name)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __libraryGetGlobalNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUdeviceptr& __dptr,
+  ::cuda::std::size_t& __nbytes,
+  ::CUlibrary __lib,
+  const char* __name) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuLibraryGetGlobal);
   return static_cast<::cudaError_t>(__driver_fn(&__dptr, &__nbytes, __lib, __name));
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__libraryGetManagedNoThrow(::CUdeviceptr& __dptr, ::cuda::std::size_t& __nbytes, ::CUlibrary __lib, const char* __name)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __libraryGetManagedNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUdeviceptr& __dptr,
+  ::cuda::std::size_t& __nbytes,
+  ::CUlibrary __lib,
+  const char* __name) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuLibraryGetManaged);
   return static_cast<::cudaError_t>(__driver_fn(&__dptr, &__nbytes, __lib, __name));
 }
 
 // Execution control
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__functionGetAttributeNoThrow(int& __value, ::CUfunction_attribute __attr, ::CUfunction __kernel)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __functionGetAttributeNoThrow( // NOLINT(bugprone-exception-escape)
+  int& __value,
+  ::CUfunction_attribute __attr,
+  ::CUfunction __kernel) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuFuncGetAttribute);
   return static_cast<::cudaError_t>(__driver_fn(&__value, __attr, __kernel));
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __functionLoadNoThrow(::CUfunction __kernel) noexcept
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__functionLoadNoThrow(::CUfunction __kernel) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = reinterpret_cast<::CUresult(CUDAAPI*)(::CUfunction)>(
     ::cuda::__driver::__get_driver_entry_point("cuFuncLoad", 12, 4));
   return static_cast<::cudaError_t>(__driver_fn(__kernel));
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__functionSetAttributeNoThrow(::CUfunction __kernel, ::CUfunction_attribute __attr, int __value)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __functionSetAttributeNoThrow( // NOLINT(bugprone-exception-escape)
+  ::CUfunction __kernel,
+  ::CUfunction_attribute __attr,
+  int __value) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuFuncSetAttribute);
   return static_cast<::cudaError_t>(__driver_fn(__kernel, __attr, __value));
@@ -966,8 +995,10 @@ __graphKernelNodeSetAttribute(::CUgraphNode __node, ::CUkernelNodeAttrID __id, c
   return static_cast<bool>(__result);
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
-__deviceCanAccessPeerNoThrow(int& __result, ::CUdevice __dev, ::CUdevice __peer_dev) noexcept
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __deviceCanAccessPeerNoThrow( // NOLINT(bugprone-exception-escape)
+  int& __result,
+  ::CUdevice __dev,
+  ::CUdevice __peer_dev) noexcept
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION(cuDeviceCanAccessPeer);
   return static_cast<::cudaError_t>(__driver_fn(&__result, __dev, __peer_dev));
@@ -986,12 +1017,12 @@ __deviceCanAccessPeerNoThrow(int& __result, ::CUdevice __dev, ::CUdevice __peer_
   return __result;
 }
 
-[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __greenCtxDestroyNoThrow(::CUgreenCtx __green_ctx)
+[[nodiscard]] _CCCL_HOST_API inline ::cudaError_t
+__greenCtxDestroyNoThrow(::CUgreenCtx __green_ctx) noexcept // NOLINT(bugprone-exception-escape)
 {
   static auto __driver_fn = _CCCLRT_GET_DRIVER_FUNCTION_VERSIONED(cuGreenCtxDestroy, cuGreenCtxDestroy, 12, 5);
   return static_cast<::cudaError_t>(__driver_fn(__green_ctx));
 }
-
 [[nodiscard]] _CCCL_HOST_API inline ::CUcontext __ctxFromGreenCtx(::CUgreenCtx __green_ctx)
 {
   ::CUcontext __result;

libcudacxx/include/cuda/std/__memory/allocator_traits.h

@@ -363,7 +363,10 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT allocator_traits
   }
 
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 static void deallocate(allocator_type& __a, pointer __p, size_type __n) noexcept
+  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 static void deallocate( // NOLINT(bugprone-exception-escape)
+    allocator_type& __a,
+    pointer __p,
+    size_type __n) noexcept
   {
     __a.deallocate(__p, __n);
   }