[CI] address cmakelint warnings about whitespace (#9674)

2023-10-13 23:46:07 -05:00 · 2023-10-13 23:46:07 -05:00 · eb562d3829
commit eb562d3829
parent 53049b16b8
15 changed files with 133 additions and 128 deletions
--- 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(
--- 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."
--- 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>
--- 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()
--- 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()
--- 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
--- 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()

--- 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()
--- 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)
--- 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)
--- 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()

--- 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()
--- 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()

--- 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()

--- 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()