diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8e1a38929..7e5f2c556 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,7 @@ cmake_policy(SET CMP0076 NEW)
 set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
 cmake_policy(SET CMP0063 NEW)
 
-if ((${CMAKE_VERSION} VERSION_GREATER 3.13) OR (${CMAKE_VERSION} VERSION_EQUAL 3.13))
+if((${CMAKE_VERSION} VERSION_GREATER 3.13) OR (${CMAKE_VERSION} VERSION_EQUAL 3.13))
   cmake_policy(SET CMP0077 NEW)
 endif()
 
@@ -86,91 +86,93 @@ option(PLUGIN_UPDATER_ONEAPI "DPC++ updater" OFF)
 option(ADD_PKGCONFIG "Add xgboost.pc into system." ON)
 
 #-- Checks for building XGBoost
-if (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
+if(USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
   message(SEND_ERROR "Do not enable `USE_DEBUG_OUTPUT' with release build.")
 endif()
-if (USE_NCCL AND NOT (USE_CUDA))
+if(USE_NCCL AND NOT (USE_CUDA))
   message(SEND_ERROR "`USE_NCCL` must be enabled with `USE_CUDA` flag.")
 endif()
-if (USE_DEVICE_DEBUG AND NOT (USE_CUDA))
+if(USE_DEVICE_DEBUG AND NOT (USE_CUDA))
   message(SEND_ERROR "`USE_DEVICE_DEBUG` must be enabled with `USE_CUDA` flag.")
 endif()
-if (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
+if(BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
   message(SEND_ERROR "Build XGBoost with -DUSE_NCCL=ON to enable BUILD_WITH_SHARED_NCCL.")
 endif()
-if (JVM_BINDINGS AND R_LIB)
+if(JVM_BINDINGS AND R_LIB)
   message(SEND_ERROR "`R_LIB' is not compatible with `JVM_BINDINGS' as they both have customized configurations.")
 endif()
-if (R_LIB AND GOOGLE_TEST)
-  message(WARNING "Some C++ unittests will fail with `R_LIB` enabled,
- as R package redirects some functions to R runtime implementation.")
+if(R_LIB AND GOOGLE_TEST)
+  message(
+    WARNING
+    "Some C++ tests will fail with `R_LIB` enabled, as R package redirects some functions to R runtime implementation."
+  )
 endif()
-if (PLUGIN_RMM AND NOT (USE_CUDA))
+if(PLUGIN_RMM AND NOT (USE_CUDA))
   message(SEND_ERROR "`PLUGIN_RMM` must be enabled with `USE_CUDA` flag.")
 endif()
-if (PLUGIN_RMM AND NOT ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")))
+if(PLUGIN_RMM AND NOT ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")))
   message(SEND_ERROR "`PLUGIN_RMM` must be used with GCC or Clang compiler.")
 endif()
-if (PLUGIN_RMM AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
+if(PLUGIN_RMM AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
   message(SEND_ERROR "`PLUGIN_RMM` must be used with Linux.")
 endif()
-if (ENABLE_ALL_WARNINGS)
-  if ((NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
+if(ENABLE_ALL_WARNINGS)
+  if((NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
     message(SEND_ERROR "ENABLE_ALL_WARNINGS is only available for Clang and GCC.")
   endif()
 endif()
-if (BUILD_STATIC_LIB AND (R_LIB OR JVM_BINDINGS))
+if(BUILD_STATIC_LIB AND (R_LIB OR JVM_BINDINGS))
   message(SEND_ERROR "Cannot build a static library libxgboost.a when R or JVM packages are enabled.")
 endif()
-if (PLUGIN_FEDERATED)
-  if (CMAKE_CROSSCOMPILING)
+if(PLUGIN_FEDERATED)
+  if(CMAKE_CROSSCOMPILING)
     message(SEND_ERROR "Cannot cross compile with federated learning support")
   endif()
-  if (BUILD_STATIC_LIB)
+  if(BUILD_STATIC_LIB)
     message(SEND_ERROR "Cannot build static lib with federated learning support")
   endif()
-  if (R_LIB OR JVM_BINDINGS)
+  if(R_LIB OR JVM_BINDINGS)
     message(SEND_ERROR "Cannot enable federated learning support when R or JVM packages are enabled.")
   endif()
-  if (WIN32)
+  if(WIN32)
     message(SEND_ERROR "Federated learning not supported for Windows platform")
   endif()
 endif()
 
 #-- Removed options
-if (USE_AVX)
+if(USE_AVX)
   message(SEND_ERROR  "The option `USE_AVX` is deprecated as experimental AVX features have been removed from XGBoost.")
 endif()
-if (PLUGIN_LZ4)
+if(PLUGIN_LZ4)
   message(SEND_ERROR  "The option `PLUGIN_LZ4` is removed from XGBoost.")
 endif()
-if (RABIT_BUILD_MPI)
+if(RABIT_BUILD_MPI)
   message(SEND_ERROR "The option `RABIT_BUILD_MPI` has been removed from XGBoost.")
 endif()
-if (USE_S3)
+if(USE_S3)
   message(SEND_ERROR "The option `USE_S3` has been removed from XGBoost")
 endif()
-if (USE_AZURE)
+if(USE_AZURE)
   message(SEND_ERROR "The option `USE_AZURE` has been removed from XGBoost")
 endif()
-if (USE_HDFS)
+if(USE_HDFS)
   message(SEND_ERROR "The option `USE_HDFS` has been removed from XGBoost")
 endif()
 
 #-- Sanitizer
-if (USE_SANITIZER)
+if(USE_SANITIZER)
   include(cmake/Sanitizer.cmake)
   enable_sanitizers("${ENABLED_SANITIZERS}")
 endif()
 
-if (USE_CUDA)
+if(USE_CUDA)
   set(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
   # `export CXX=' is ignored by CMake CUDA.
   set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
   message(STATUS "Configured CUDA host compiler: ${CMAKE_CUDA_HOST_COMPILER}")
 
   enable_language(CUDA)
-  if (${CMAKE_CUDA_COMPILER_VERSION} VERSION_LESS 11.0)
+  if(${CMAKE_CUDA_COMPILER_VERSION} VERSION_LESS 11.0)
     message(FATAL_ERROR "CUDA version must be at least 11.0!")
   endif()
   set(GEN_CODE "")
@@ -180,7 +182,7 @@ if (USE_CUDA)
   find_package(CUDAToolkit REQUIRED)
 endif()
 
-if (FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
+if(FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
     ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR
       (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")))
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always")
@@ -188,10 +190,10 @@ endif()
 
 find_package(Threads REQUIRED)
 
-if (USE_OPENMP)
-  if (APPLE)
+if(USE_OPENMP)
+  if(APPLE)
     find_package(OpenMP)
-    if (NOT OpenMP_FOUND)
+    if(NOT OpenMP_FOUND)
       # Try again with extra path info; required for libomp 15+ from Homebrew
       execute_process(COMMAND brew --prefix libomp
                       OUTPUT_VARIABLE HOMEBREW_LIBOMP_PREFIX
@@ -205,31 +207,33 @@ if (USE_OPENMP)
       set(OpenMP_omp_LIBRARY ${HOMEBREW_LIBOMP_PREFIX}/lib/libomp.dylib)
       find_package(OpenMP REQUIRED)
     endif()
-  else ()
+  else()
     find_package(OpenMP REQUIRED)
   endif()
 endif()
 #Add for IBM i
-if (${CMAKE_SYSTEM_NAME} MATCHES "OS400")
+if(${CMAKE_SYSTEM_NAME} MATCHES "OS400")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
   set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -X64 qc <TARGET> <OBJECTS>")
 endif()
 
-if (USE_NCCL)
+if(USE_NCCL)
   find_package(Nccl REQUIRED)
 endif()
 
 # dmlc-core
 msvc_use_static_runtime()
-if (FORCE_SHARED_CRT)
+if(FORCE_SHARED_CRT)
   set(DMLC_FORCE_SHARED_CRT ON)
 endif()
 add_subdirectory(${xgboost_SOURCE_DIR}/dmlc-core)
 
-if (MSVC)
-  if (TARGET dmlc_unit_tests)
-    target_compile_options(dmlc_unit_tests PRIVATE
-                           -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE)
+if(MSVC)
+  if(TARGET dmlc_unit_tests)
+    target_compile_options(
+        dmlc_unit_tests PRIVATE
+        -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE
+    )
   endif()
 endif()
 
@@ -241,19 +245,19 @@ add_subdirectory(${xgboost_SOURCE_DIR}/src)
 target_link_libraries(objxgboost PUBLIC dmlc)
 
 # Exports some R specific definitions and objects
-if (R_LIB)
+if(R_LIB)
   add_subdirectory(${xgboost_SOURCE_DIR}/R-package)
 endif()
 
 # This creates its own shared library `xgboost4j'.
-if (JVM_BINDINGS)
+if(JVM_BINDINGS)
   add_subdirectory(${xgboost_SOURCE_DIR}/jvm-packages)
 endif()
 
 # Plugin
 add_subdirectory(${xgboost_SOURCE_DIR}/plugin)
 
-if (PLUGIN_RMM)
+if(PLUGIN_RMM)
   find_package(rmm REQUIRED)
 
   # Patch the rmm targets so they reference the static cudart
@@ -267,7 +271,7 @@ if (PLUGIN_RMM)
 endif()
 
 #-- library
-if (BUILD_STATIC_LIB)
+if(BUILD_STATIC_LIB)
   add_library(xgboost STATIC)
 else()
   add_library(xgboost SHARED)
@@ -280,7 +284,7 @@ target_include_directories(xgboost
 #-- End shared library
 
 #-- CLI for xgboost
-if (BUILD_DEPRECATED_CLI)
+if(BUILD_DEPRECATED_CLI)
   add_executable(runxgboost ${xgboost_SOURCE_DIR}/src/cli_main.cc)
   target_link_libraries(runxgboost PRIVATE objxgboost)
   target_include_directories(runxgboost
@@ -294,9 +298,9 @@ if (BUILD_DEPRECATED_CLI)
   xgboost_target_link_libraries(runxgboost)
   xgboost_target_defs(runxgboost)
 
-  if (KEEP_BUILD_ARTIFACTS_IN_BINARY_DIR)
+  if(KEEP_BUILD_ARTIFACTS_IN_BINARY_DIR)
     set_output_directory(runxgboost ${xgboost_BINARY_DIR})
-  else ()
+  else()
     set_output_directory(runxgboost ${xgboost_SOURCE_DIR})
   endif()
 endif()
@@ -309,38 +313,38 @@ foreach(target xgboost objxgboost dmlc)
   xgboost_target_defs(${target})
 endforeach()
 
-if (JVM_BINDINGS)
+if(JVM_BINDINGS)
   xgboost_target_properties(xgboost4j)
   xgboost_target_link_libraries(xgboost4j)
   xgboost_target_defs(xgboost4j)
 endif()
 
-if (KEEP_BUILD_ARTIFACTS_IN_BINARY_DIR)
+if(KEEP_BUILD_ARTIFACTS_IN_BINARY_DIR)
   set_output_directory(xgboost ${xgboost_BINARY_DIR}/lib)
-else ()
+else()
   set_output_directory(xgboost ${xgboost_SOURCE_DIR}/lib)
 endif()
 
 # Ensure these two targets do not build simultaneously, as they produce outputs with conflicting names
-if (BUILD_DEPRECATED_CLI)
+if(BUILD_DEPRECATED_CLI)
   add_dependencies(xgboost runxgboost)
 endif()
 
 #-- Installing XGBoost
-if (R_LIB)
+if(R_LIB)
   include(cmake/RPackageInstallTargetSetup.cmake)
   set_target_properties(xgboost PROPERTIES PREFIX "")
-  if (APPLE)
+  if(APPLE)
     set_target_properties(xgboost PROPERTIES SUFFIX ".so")
   endif()
   setup_rpackage_install_target(xgboost "${CMAKE_CURRENT_BINARY_DIR}/R-package-install")
   set(CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/dummy_inst")
 endif()
-if (MINGW)
+if(MINGW)
   set_target_properties(xgboost PROPERTIES PREFIX "")
 endif()
 
-if (BUILD_C_DOC)
+if(BUILD_C_DOC)
   include(cmake/Doc.cmake)
   run_doxygen()
 endif()
@@ -359,14 +363,14 @@ install(DIRECTORY ${xgboost_SOURCE_DIR}/include/xgboost
 #  > in any export set.
 #
 # https://github.com/dmlc/xgboost/issues/6085
-if (BUILD_STATIC_LIB)
-  if (BUILD_DEPRECATED_CLI)
+if(BUILD_STATIC_LIB)
+  if(BUILD_DEPRECATED_CLI)
     set(INSTALL_TARGETS xgboost runxgboost objxgboost dmlc)
   else()
     set(INSTALL_TARGETS xgboost objxgboost dmlc)
   endif()
 else()
-  if (BUILD_DEPRECATED_CLI)
+  if(BUILD_DEPRECATED_CLI)
     set(INSTALL_TARGETS xgboost runxgboost)
   else()
     set(INSTALL_TARGETS xgboost)
@@ -400,7 +404,7 @@ install(
   DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/xgboost)
 
 #-- Test
-if (GOOGLE_TEST)
+if(GOOGLE_TEST)
   enable_testing()
   # Unittests.
   add_executable(testxgboost)
@@ -420,7 +424,7 @@ if (GOOGLE_TEST)
     ${xgboost_SOURCE_DIR}/tests/cli/machine.conf.in
     ${xgboost_BINARY_DIR}/tests/cli/machine.conf
     @ONLY)
-  if (BUILD_DEPRECATED_CLI)
+  if(BUILD_DEPRECATED_CLI)
     add_test(
       NAME TestXGBoostCLI
       COMMAND runxgboost ${xgboost_BINARY_DIR}/tests/cli/machine.conf
@@ -437,7 +441,7 @@ endif()
 msvc_use_static_runtime()
 
 # Add xgboost.pc
-if (ADD_PKGCONFIG)
+if(ADD_PKGCONFIG)
   configure_file(${xgboost_SOURCE_DIR}/cmake/xgboost.pc.in ${xgboost_BINARY_DIR}/xgboost.pc @ONLY)
 
   install(
diff --git a/cmake/Doc.cmake b/cmake/Doc.cmake
index cf4ef26f4..41c4fc961 100644
--- a/cmake/Doc.cmake
+++ b/cmake/Doc.cmake
@@ -1,14 +1,15 @@
-function (run_doxygen)
+function(run_doxygen)
   find_package(Doxygen REQUIRED)
 
-  if (NOT DOXYGEN_DOT_FOUND)
+  if(NOT DOXYGEN_DOT_FOUND)
     message(FATAL_ERROR "Command `dot` not found.  Please install graphviz.")
   endif()
 
   configure_file(
     ${xgboost_SOURCE_DIR}/doc/Doxyfile.in
     ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
-  add_custom_target( doc_doxygen ALL
+  add_custom_target(
+    doc_doxygen ALL
     COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     COMMENT "Generate C APIs documentation."
diff --git a/cmake/FindPrefetchIntrinsics.cmake b/cmake/FindPrefetchIntrinsics.cmake
index 94e65de32..71ae5899f 100644
--- a/cmake/FindPrefetchIntrinsics.cmake
+++ b/cmake/FindPrefetchIntrinsics.cmake
@@ -1,4 +1,4 @@
-function (find_prefetch_intrinsics)
+function(find_prefetch_intrinsics)
   include(CheckCXXSourceCompiles)
   check_cxx_source_compiles("
   #include <xmmintrin.h>
diff --git a/cmake/Sanitizer.cmake b/cmake/Sanitizer.cmake
index 919d5c695..176d967d0 100644
--- a/cmake/Sanitizer.cmake
+++ b/cmake/Sanitizer.cmake
@@ -12,7 +12,7 @@ macro(enable_sanitizer sanitizer)
   elseif(${sanitizer} MATCHES "thread")
     find_package(TSan)
     set(SAN_COMPILE_FLAGS "${SAN_COMPILE_FLAGS} -fsanitize=thread")
-    if (TSan_FOUND)
+    if(TSan_FOUND)
       link_libraries(${TSan_LIBRARY})
     endif()
 
@@ -33,16 +33,16 @@ macro(enable_sanitizers SANITIZERS)
   # Check sanitizers compatibility.
   # Idealy, we should use if(san IN_LIST SANITIZERS) ... endif()
   # But I haven't figure out how to make it work.
-  foreach ( _san ${SANITIZERS} )
+  foreach( _san ${SANITIZERS} )
     string(TOLOWER ${_san} _san)
-    if (_san MATCHES "thread")
-      if (${_use_other_sanitizers})
+    if(_san MATCHES "thread")
+      if(${_use_other_sanitizers})
         message(FATAL_ERROR
           "thread sanitizer is not compatible with ${_san} sanitizer.")
       endif()
       set(_use_thread_sanitizer 1)
-    else ()
-      if (${_use_thread_sanitizer})
+    else()
+      if(${_use_thread_sanitizer})
         message(FATAL_ERROR
           "${_san} sanitizer is not compatible with thread sanitizer.")
       endif()
diff --git a/cmake/Utils.cmake b/cmake/Utils.cmake
index f1e9a5904..586e32ee5 100644
--- a/cmake/Utils.cmake
+++ b/cmake/Utils.cmake
@@ -76,10 +76,10 @@ endfunction()
 function(set_default_configuration_release)
     if(CMAKE_CONFIGURATION_TYPES STREQUAL "Debug;Release;MinSizeRel;RelWithDebInfo") # multiconfig generator?
         set(CMAKE_CONFIGURATION_TYPES Release CACHE STRING "" FORCE)
-	elseif(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-	  message(STATUS "Setting build type to 'Release' as none was specified.")
-	  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE )
-	endif()
+    elseif(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+      message(STATUS "Setting build type to 'Release' as none was specified.")
+      set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+    endif()
 endfunction()
 
 # Generate nvcc compiler flags given a list of architectures
@@ -90,9 +90,9 @@ function(format_gencode_flags flags out)
   endif()
   # Set up architecture flags
   if(NOT flags)
-    if (CUDA_VERSION VERSION_GREATER_EQUAL "11.8")
+    if(CUDA_VERSION VERSION_GREATER_EQUAL "11.8")
       set(flags "50;60;70;80;90")
-    elseif (CUDA_VERSION VERSION_GREATER_EQUAL "11.0")
+    elseif(CUDA_VERSION VERSION_GREATER_EQUAL "11.0")
       set(flags "50;60;70;80")
     elseif(CUDA_VERSION VERSION_GREATER_EQUAL "10.0")
       set(flags "35;50;60;70")
@@ -103,7 +103,7 @@ function(format_gencode_flags flags out)
     endif()
   endif()
 
-  if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
     cmake_policy(SET CMP0104 NEW)
     list(GET flags -1 latest_arch)
     list(TRANSFORM flags APPEND "-real")
@@ -133,17 +133,17 @@ function(xgboost_set_cuda_flags target)
     $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=${OpenMP_CXX_FLAGS}>
     $<$<COMPILE_LANGUAGE:CUDA>:-Xfatbin=-compress-all>)
 
-  if (USE_PER_THREAD_DEFAULT_STREAM)
+  if(USE_PER_THREAD_DEFAULT_STREAM)
     target_compile_options(${target} PRIVATE
             $<$<COMPILE_LANGUAGE:CUDA>:--default-stream per-thread>)
   endif()
 
-  if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
     set_property(TARGET ${target} PROPERTY CUDA_ARCHITECTURES ${CMAKE_CUDA_ARCHITECTURES})
   endif()
 
-  if (FORCE_COLORED_OUTPUT)
-    if (FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
+  if(FORCE_COLORED_OUTPUT)
+    if(FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
         ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR
           (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")))
       target_compile_options(${target} PRIVATE
@@ -151,7 +151,7 @@ function(xgboost_set_cuda_flags target)
     endif()
   endif()
 
-  if (USE_DEVICE_DEBUG)
+  if(USE_DEVICE_DEBUG)
     target_compile_options(${target} PRIVATE
       $<$<AND:$<CONFIG:DEBUG>,$<COMPILE_LANGUAGE:CUDA>>:-G;-src-in-ptx>)
   else()
@@ -159,7 +159,7 @@ function(xgboost_set_cuda_flags target)
       $<$<COMPILE_LANGUAGE:CUDA>:-lineinfo>)
   endif()
 
-  if (USE_NVTX)
+  if(USE_NVTX)
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_NVTX=1)
   endif()
 
@@ -169,7 +169,7 @@ function(xgboost_set_cuda_flags target)
     ${xgboost_SOURCE_DIR}/gputreeshap
     ${CUDAToolkit_INCLUDE_DIRS})
 
-  if (MSVC)
+  if(MSVC)
     target_compile_options(${target} PRIVATE
       $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=/utf-8>)
   endif()
@@ -182,11 +182,11 @@ function(xgboost_set_cuda_flags target)
 endfunction()
 
 macro(xgboost_link_nccl target)
-  if (BUILD_STATIC_LIB)
+  if(BUILD_STATIC_LIB)
     target_include_directories(${target} PUBLIC ${NCCL_INCLUDE_DIR})
     target_compile_definitions(${target} PUBLIC -DXGBOOST_USE_NCCL=1)
     target_link_libraries(${target} PUBLIC ${NCCL_LIBRARY})
-  else ()
+  else()
     target_include_directories(${target} PRIVATE ${NCCL_INCLUDE_DIR})
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_NCCL=1)
     target_link_libraries(${target} PRIVATE ${NCCL_LIBRARY})
@@ -200,7 +200,7 @@ macro(xgboost_target_properties target)
     CXX_STANDARD_REQUIRED ON
     POSITION_INDEPENDENT_CODE ON)
 
-  if (HIDE_CXX_SYMBOLS)
+  if(HIDE_CXX_SYMBOLS)
     #-- Hide all C++ symbols
     set_target_properties(${target} PROPERTIES
       C_VISIBILITY_PRESET hidden
@@ -209,7 +209,7 @@ macro(xgboost_target_properties target)
     )
   endif()
 
-  if (ENABLE_ALL_WARNINGS)
+  if(ENABLE_ALL_WARNINGS)
     target_compile_options(${target} PUBLIC
       $<IF:$<COMPILE_LANGUAGE:CUDA>,
       -Xcompiler=-Wall -Xcompiler=-Wextra -Xcompiler=-Wno-expansion-to-defined,
@@ -222,7 +222,7 @@ macro(xgboost_target_properties target)
     $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<COMPILE_LANGUAGE:CXX>>:/MP>
     $<$<AND:$<NOT:$<CXX_COMPILER_ID:MSVC>>,$<COMPILE_LANGUAGE:CXX>>:-funroll-loops>)
 
-  if (MSVC)
+  if(MSVC)
     target_compile_options(${target} PRIVATE
       $<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:/utf-8>
       -D_CRT_SECURE_NO_WARNINGS
@@ -230,72 +230,72 @@ macro(xgboost_target_properties target)
     )
   endif()
 
-  if (WIN32 AND MINGW)
+  if(WIN32 AND MINGW)
     target_compile_options(${target} PUBLIC -static-libstdc++)
   endif()
 endmacro()
 
 # Custom definitions used in xgboost.
 macro(xgboost_target_defs target)
-  if (NOT ${target} STREQUAL "dmlc") # skip dmlc core for custom logging.
+  if(NOT ${target} STREQUAL "dmlc") # skip dmlc core for custom logging.
     target_compile_definitions(${target}
       PRIVATE
       -DDMLC_LOG_CUSTOMIZE=1
       $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:_MWAITXINTRIN_H_INCLUDED>)
   endif()
-  if (USE_DEBUG_OUTPUT)
+  if(USE_DEBUG_OUTPUT)
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_DEBUG_OUTPUT=1)
   endif()
-  if (XGBOOST_MM_PREFETCH_PRESENT)
+  if(XGBOOST_MM_PREFETCH_PRESENT)
     target_compile_definitions(${target}
       PRIVATE
       -DXGBOOST_MM_PREFETCH_PRESENT=1)
   endif()
-  if (XGBOOST_BUILTIN_PREFETCH_PRESENT)
+  if(XGBOOST_BUILTIN_PREFETCH_PRESENT)
     target_compile_definitions(${target}
       PRIVATE
       -DXGBOOST_BUILTIN_PREFETCH_PRESENT=1)
   endif()
 
-  if (PLUGIN_RMM)
+  if(PLUGIN_RMM)
     target_compile_definitions(objxgboost PUBLIC -DXGBOOST_USE_RMM=1)
   endif()
 endmacro()
 
 # handles dependencies
 macro(xgboost_target_link_libraries target)
-  if (BUILD_STATIC_LIB)
+  if(BUILD_STATIC_LIB)
     target_link_libraries(${target} PUBLIC Threads::Threads ${CMAKE_THREAD_LIBS_INIT})
   else()
     target_link_libraries(${target} PRIVATE Threads::Threads ${CMAKE_THREAD_LIBS_INIT})
   endif()
 
-  if (USE_OPENMP)
-    if (BUILD_STATIC_LIB)
+  if(USE_OPENMP)
+    if(BUILD_STATIC_LIB)
       target_link_libraries(${target} PUBLIC OpenMP::OpenMP_CXX)
     else()
       target_link_libraries(${target} PRIVATE OpenMP::OpenMP_CXX)
     endif()
   endif()
 
-  if (USE_CUDA)
+  if(USE_CUDA)
     xgboost_set_cuda_flags(${target})
     target_link_libraries(${target} PUBLIC CUDA::cudart_static)
   endif()
 
-  if (PLUGIN_RMM)
+  if(PLUGIN_RMM)
     target_link_libraries(${target} PRIVATE rmm::rmm)
   endif()
 
-  if (USE_NCCL)
+  if(USE_NCCL)
     xgboost_link_nccl(${target})
   endif()
 
-  if (USE_NVTX)
+  if(USE_NVTX)
     target_link_libraries(${target} PRIVATE CUDA::nvToolsExt)
   endif()
 
-  if (MINGW)
+  if(MINGW)
     target_link_libraries(${target} PRIVATE wsock32 ws2_32)
   endif()
 endmacro()
diff --git a/cmake/Version.cmake b/cmake/Version.cmake
index a64d1b65e..4af6b27d6 100644
--- a/cmake/Version.cmake
+++ b/cmake/Version.cmake
@@ -1,4 +1,4 @@
-function (write_version)
+function(write_version)
   message(STATUS "xgboost VERSION: ${xgboost_VERSION}")
   configure_file(
     ${xgboost_SOURCE_DIR}/cmake/version_config.h.in
diff --git a/cmake/modules/FindNVML.cmake b/cmake/modules/FindNVML.cmake
index a7061aa29..f0e72f371 100644
--- a/cmake/modules/FindNVML.cmake
+++ b/cmake/modules/FindNVML.cmake
@@ -1,4 +1,4 @@
-if (NVML_LIBRARY)
+if(NVML_LIBRARY)
   unset(NVML_LIBRARY CACHE)
 endif()
 
diff --git a/cmake/modules/FindNccl.cmake b/cmake/modules/FindNccl.cmake
index 6fd2ed981..02ee731a1 100644
--- a/cmake/modules/FindNccl.cmake
+++ b/cmake/modules/FindNccl.cmake
@@ -35,17 +35,17 @@
 #
 # This module assumes that the user has already called find_package(CUDA)
 
-if (NCCL_LIBRARY)
+if(NCCL_LIBRARY)
   if(NOT USE_NCCL_LIB_PATH)
     # Don't cache NCCL_LIBRARY to enable switching between static and shared.
     unset(NCCL_LIBRARY CACHE)
   endif()
 endif()
 
-if (BUILD_WITH_SHARED_NCCL)
+if(BUILD_WITH_SHARED_NCCL)
   # libnccl.so
   set(NCCL_LIB_NAME nccl)
-else ()
+else()
   # libnccl_static.a
   set(NCCL_LIB_NAME nccl_static)
 endif()
diff --git a/demo/c-api/basic/CMakeLists.txt b/demo/c-api/basic/CMakeLists.txt
index f0cc8a744..74567c9c8 100644
--- a/demo/c-api/basic/CMakeLists.txt
+++ b/demo/c-api/basic/CMakeLists.txt
@@ -3,7 +3,7 @@ find_package(xgboost REQUIRED)
 
 # xgboost is built as static libraries, all cxx dependencies need to be linked into the
 # executable.
-if (XGBOOST_BUILD_STATIC_LIB)
+if(XGBOOST_BUILD_STATIC_LIB)
   enable_language(CXX)
   # find again for those  cxx libraries.
   find_package(xgboost REQUIRED)
diff --git a/demo/c-api/inference/CMakeLists.txt b/demo/c-api/inference/CMakeLists.txt
index 70ddb256c..5eded43e2 100644
--- a/demo/c-api/inference/CMakeLists.txt
+++ b/demo/c-api/inference/CMakeLists.txt
@@ -4,7 +4,7 @@ find_package(xgboost REQUIRED)
 
 # xgboost is built as static libraries, all cxx dependencies need to be linked into the
 # executable.
-if (XGBOOST_BUILD_STATIC_LIB)
+if(XGBOOST_BUILD_STATIC_LIB)
   enable_language(CXX)
   # find again for those  cxx libraries.
   find_package(xgboost REQUIRED)
diff --git a/jvm-packages/CMakeLists.txt b/jvm-packages/CMakeLists.txt
index f89970dea..d87301753 100644
--- a/jvm-packages/CMakeLists.txt
+++ b/jvm-packages/CMakeLists.txt
@@ -4,14 +4,14 @@ list(APPEND JVM_SOURCES
   ${PROJECT_SOURCE_DIR}/jvm-packages/xgboost4j/src/native/xgboost4j.cpp
   ${PROJECT_SOURCE_DIR}/jvm-packages/xgboost4j-gpu/src/native/xgboost4j-gpu.cpp)
 
-if (USE_CUDA)
+if(USE_CUDA)
   list(APPEND JVM_SOURCES
     ${PROJECT_SOURCE_DIR}/jvm-packages/xgboost4j-gpu/src/native/xgboost4j-gpu.cu)
 endif()
 
 add_library(xgboost4j SHARED ${JVM_SOURCES} ${XGBOOST_OBJ_SOURCES})
 
-if (ENABLE_ALL_WARNINGS)
+if(ENABLE_ALL_WARNINGS)
   target_compile_options(xgboost4j PUBLIC -Wall -Wextra)
 endif()
 
diff --git a/plugin/CMakeLists.txt b/plugin/CMakeLists.txt
index 3a1889d2e..6089ae486 100644
--- a/plugin/CMakeLists.txt
+++ b/plugin/CMakeLists.txt
@@ -1,8 +1,8 @@
-if (PLUGIN_DENSE_PARSER)
+if(PLUGIN_DENSE_PARSER)
   target_sources(objxgboost PRIVATE ${xgboost_SOURCE_DIR}/plugin/dense_parser/dense_libsvm.cc)
 endif()
 
-if (PLUGIN_UPDATER_ONEAPI)
+if(PLUGIN_UPDATER_ONEAPI)
   add_library(oneapi_plugin OBJECT
     ${xgboost_SOURCE_DIR}/plugin/updater_oneapi/regression_obj_oneapi.cc
     ${xgboost_SOURCE_DIR}/plugin/updater_oneapi/predictor_oneapi.cc)
@@ -18,7 +18,7 @@ if (PLUGIN_UPDATER_ONEAPI)
     CXX_STANDARD 17
     CXX_STANDARD_REQUIRED ON
     POSITION_INDEPENDENT_CODE ON)
-  if (USE_OPENMP)
+  if(USE_OPENMP)
     find_package(OpenMP REQUIRED)
     target_link_libraries(oneapi_plugin PUBLIC OpenMP::OpenMP_CXX)
   endif()
@@ -29,6 +29,6 @@ if (PLUGIN_UPDATER_ONEAPI)
 endif()
 
 # Add the Federate Learning plugin if enabled.
-if (PLUGIN_FEDERATED)
+if(PLUGIN_FEDERATED)
   add_subdirectory(federated)
 endif()
diff --git a/rabit/CMakeLists.txt b/rabit/CMakeLists.txt
index f1adcb6e0..4562f864f 100644
--- a/rabit/CMakeLists.txt
+++ b/rabit/CMakeLists.txt
@@ -6,9 +6,9 @@ set(RABIT_SOURCES
   ${CMAKE_CURRENT_LIST_DIR}/src/allreduce_base.cc
   ${CMAKE_CURRENT_LIST_DIR}/src/rabit_c_api.cc)
 
-if (RABIT_MOCK)
+if(RABIT_MOCK)
   list(APPEND RABIT_SOURCES ${CMAKE_CURRENT_LIST_DIR}/src/engine_mock.cc)
-else ()
+else()
   list(APPEND RABIT_SOURCES ${CMAKE_CURRENT_LIST_DIR}/src/engine.cc)
 endif()
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9b2a803ab..f0dfe061f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -11,7 +11,7 @@ set_source_files_properties(
   PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 target_sources(objxgboost PRIVATE ${RABIT_SOURCES})
 
-if (USE_CUDA)
+if(USE_CUDA)
   file(GLOB_RECURSE CUDA_SOURCES *.cu *.cuh)
   target_sources(objxgboost PRIVATE ${CUDA_SOURCES})
 endif()
@@ -22,7 +22,7 @@ target_include_directories(objxgboost
   ${xgboost_SOURCE_DIR}/dmlc-core/include
   ${xgboost_SOURCE_DIR}/rabit/include)
 
-if (LOG_CAPI_INVOCATION)
+if(LOG_CAPI_INVOCATION)
   target_compile_definitions(objxgboost PRIVATE -DLOG_CAPI_INVOCATION=1)
 endif()
 
diff --git a/tests/cpp/CMakeLists.txt b/tests/cpp/CMakeLists.txt
index 5b61f5328..cf34caf81 100644
--- a/tests/cpp/CMakeLists.txt
+++ b/tests/cpp/CMakeLists.txt
@@ -1,5 +1,5 @@
-if (USE_DMLC_GTEST)
-  if (NOT TARGET gtest)
+if(USE_DMLC_GTEST)
+  if(NOT TARGET gtest)
     message(FATAL_ERROR "USE_DMLC_GTEST=ON but dmlc-core didn't bundle gtest")
   endif()
   set(GTEST_LIBRARIES gtest)
@@ -8,17 +8,17 @@ else()
 endif()
 file(GLOB_RECURSE TEST_SOURCES "*.cc")
 
-if (USE_CUDA)
+if(USE_CUDA)
   file(GLOB_RECURSE CUDA_TEST_SOURCES "*.cu")
   list(APPEND TEST_SOURCES ${CUDA_TEST_SOURCES})
 endif()
 
 file(GLOB_RECURSE ONEAPI_TEST_SOURCES "plugin/*_oneapi.cc")
-if (NOT PLUGIN_UPDATER_ONEAPI)
+if(NOT PLUGIN_UPDATER_ONEAPI)
   list(REMOVE_ITEM TEST_SOURCES ${ONEAPI_TEST_SOURCES})
 endif()
 
-if (PLUGIN_FEDERATED)
+if(PLUGIN_FEDERATED)
   target_include_directories(testxgboost PRIVATE ${xgboost_SOURCE_DIR}/plugin/federated)
   target_link_libraries(testxgboost PRIVATE federated_client)
 else()
@@ -28,7 +28,7 @@ endif()
 
 target_sources(testxgboost PRIVATE ${TEST_SOURCES} ${xgboost_SOURCE_DIR}/plugin/example/custom_obj.cc)
 
-if (USE_CUDA AND PLUGIN_RMM)
+if(USE_CUDA AND PLUGIN_RMM)
   find_package(CUDA)
   target_include_directories(testxgboost PRIVATE ${CUDA_INCLUDE_DIRS})
 endif()