Fix/relax CMake linter rules (#35574)

Summary:
Ignore mixed upper-case/lower-case style for now
Fix space between function and its arguments violation
Pull Request resolved: https://github.com/pytorch/pytorch/pull/35574

Test Plan: CI

Differential Revision: D20712969

Pulled By: malfet

fbshipit-source-id: 0012d430aed916b4518599a0b535e82d15721f78

.cmakelintrc

@@ -1 +1 @@
-filter=-convention/filename,-linelength,-package/consistency,-readability/logic,+readability/mixedcase,-readability/wonkycase,-syntax,-whitespace/eol,+whitespace/extra,-whitespace/indent,-whitespace/mismatch,-whitespace/newline,-whitespace/tabs
+filter=-convention/filename,-linelength,-package/consistency,-readability/logic,-readability/mixedcase,-readability/wonkycase,-syntax,-whitespace/eol,+whitespace/extra,-whitespace/indent,-whitespace/mismatch,-whitespace/newline,-whitespace/tabs

CMakeLists.txt

@@ -488,8 +488,8 @@ if(NOT MSVC)
     endif()
   endif()
   if((APPLE AND (NOT ("${CLANG_VERSION_STRING}" VERSION_LESS "9.0")))
-    OR (CMAKE_COMPILER_IS_GNUCXX
+    OR(CMAKE_COMPILER_IS_GNUCXX
-    AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0 AND NOT APPLE)))
+    AND(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0 AND NOT APPLE)))
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -faligned-new")
   endif()
   if(WERROR)
@@ -504,10 +504,10 @@ if(NOT MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-but-set-variable")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-maybe-uninitialized")
   endif()
-  set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -O0")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -O0")
-  set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -O0")
+  set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -O0")
-  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-math-errno")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-math-errno")
-  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-trapping-math")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-trapping-math")
   check_cxx_compiler_flag("-Werror=format" HAS_WERROR_FORMAT)
   if(HAS_WERROR_FORMAT)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=format")
@@ -515,8 +515,8 @@ if(NOT MSVC)
 endif()
 
 if(USE_ASAN)
-    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
-    set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS_DEBUG} -fsanitize=address")
+    set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS_DEBUG} -fsanitize=address")
 endif()
 
 if(APPLE)

android/pytorch_android/CMakeLists.txt

@@ -16,14 +16,14 @@ endif()
 
 set(pytorch_android_DIR ${CMAKE_CURRENT_LIST_DIR}/src/main/cpp)
 
-if (ANDROID_ABI)
+if(ANDROID_ABI)
   set(libtorch_include_DIR ${pytorch_android_DIR}/libtorch_include/${ANDROID_ABI})
   set(BUILD_SUBDIR ${ANDROID_ABI})
 elseif(BUILD_LIBTORCH_WITH_JNI)
   # Don't need LIBTORCH_HOME if we're building from within PyTorch.
 else()
   # Building against a pre-built libtorch.
-  if (NOT LIBTORCH_HOME)
+  if(NOT LIBTORCH_HOME)
     message(FATAL_ERROR
       "pytorch_android requires LIBTORCH_HOME to be defined for non-Android builds.")
   endif()
@@ -48,7 +48,7 @@ add_library(pytorch_jni SHARED
     ${pytorch_android_SOURCES}
 )
 
-if (APPLE)
+if(APPLE)
   # Need to add rpath so dlopen can find dependencies.
   add_custom_command(TARGET pytorch_jni
       POST_BUILD COMMAND
@@ -69,7 +69,7 @@ set(fbjni_BUILD_DIR ${CMAKE_BINARY_DIR}/fbjni/${BUILD_SUBDIR})
 
 add_subdirectory(${fbjni_DIR} ${fbjni_BUILD_DIR})
 
-if (ANDROID_ABI)
+if(ANDROID_ABI)
 
   function(import_static_lib name)
     add_library(${name} STATIC IMPORTED)

aten/CMakeLists.txt

@@ -1,9 +1,9 @@
-if (NOT INTERN_BUILD_ATEN_OPS)
+if(NOT INTERN_BUILD_ATEN_OPS)
   return()
 endif()
 
 # Find modules
-if (NOT INTERN_BUILD_MOBILE)
+if(NOT INTERN_BUILD_MOBILE)
   list(APPEND CMAKE_MODULE_PATH /usr/lib/x86_64-linux-gnu/)
   list(APPEND CMAKE_LIBRARY_PATH /usr/lib/x86_64-linux-gnu/ /usr/lib/aarch64-linux-gnu/)
 endif()
@@ -53,7 +53,7 @@ list(APPEND ATen_CPU_INCLUDE ${TH_CPU_INCLUDE})
 # Find the HIP package, set the HIP paths, load the HIP CMake.
 IF(USE_ROCM)
   include(LoadHIP)
-  if (NOT PYTORCH_FOUND_HIP)
+  if(NOT PYTORCH_FOUND_HIP)
     set(USE_ROCM OFF)
   endif()
 ENDIF()

aten/src/ATen/CMakeLists.txt

@@ -18,7 +18,7 @@ ENDIF()
 
 # this flag is used in Config but set externally, we must normalize it
 # to 0/1 otherwise `#if ON` will be evaluated to false.
-if (CAFFE2_STATIC_LINK_CUDA)
+if(CAFFE2_STATIC_LINK_CUDA)
   set(CAFFE2_STATIC_LINK_CUDA_INT 1)
 else()
   set(CAFFE2_STATIC_LINK_CUDA_INT 0)
@@ -128,14 +128,14 @@ list(APPEND ATen_CPU_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/..)
 # so the build can find the generated header files
 list(APPEND ATen_CPU_INCLUDE ${CMAKE_CURRENT_BINARY_DIR})
 
-IF (USE_TBB)
+IF(USE_TBB)
   message("ATen is compiled with TBB (${TBB_ROOT_DIR})")
   list(APPEND ATen_CPU_INCLUDE ${TBB_ROOT_DIR}/include)
   list(APPEND ATen_CPU_DEPENDENCY_LIBS tbb)
 ENDIF()
 
 IF(BLAS_FOUND)
-  IF ($ENV{TH_BINARY_BUILD})
+  IF($ENV{TH_BINARY_BUILD})
     MESSAGE(STATUS "TH_BINARY_BUILD detected. Enabling special linkage.")
     list(APPEND ATen_CPU_DEPENDENCY_LIBS
       "${BLAS_LIBRARIES};${BLAS_LIBRARIES};${BLAS_LIBRARIES}")
@@ -147,7 +147,7 @@ IF(BLAS_FOUND)
       list(APPEND ATen_HIP_DEPENDENCY_LIBS
         "${BLAS_LIBRARIES};${BLAS_LIBRARIES};${BLAS_LIBRARIES}")
     endif()
-  ELSE ($ENV{TH_BINARY_BUILD})
+  ELSE($ENV{TH_BINARY_BUILD})
     list(APPEND ATen_CPU_DEPENDENCY_LIBS ${BLAS_LIBRARIES})
     if(USE_CUDA)
       list(APPEND ATen_CUDA_DEPENDENCY_LIBS "${BLAS_LIBRARIES}")
@@ -155,7 +155,7 @@ IF(BLAS_FOUND)
     if(USE_ROCM)
       list(APPEND ATen_HIP_DEPENDENCY_LIBS "${BLAS_LIBRARIES}")
     endif()
-  ENDIF ($ENV{TH_BINARY_BUILD})
+  ENDIF($ENV{TH_BINARY_BUILD})
 ENDIF(BLAS_FOUND)
 
 IF(LAPACK_FOUND)
@@ -176,7 +176,7 @@ IF(LAPACK_FOUND)
   endif()
 ENDIF(LAPACK_FOUND)
 
-IF (UNIX AND NOT APPLE)
+IF(UNIX AND NOT APPLE)
    INCLUDE(CheckLibraryExists)
    # https://github.com/libgit2/libgit2/issues/2128#issuecomment-35649830
    CHECK_LIBRARY_EXISTS(rt clock_gettime "time.h" NEED_LIBRT)
@@ -275,7 +275,7 @@ if(NOT MSVC AND NOT EMSCRIPTEN AND NOT INTERN_BUILD_MOBILE)
 endif()
 
 IF(USE_CUDA AND NOT USE_ROCM)
-  IF ($ENV{ATEN_STATIC_CUDA})
+  IF($ENV{ATEN_STATIC_CUDA})
     # CuFFT has a complicated static story (especially around CUDA < 9) because it has device callback support
     # we first have to build a fake lib that links with no device callbacks,
     # and then we link against this object file.
@@ -330,12 +330,12 @@ IF(USE_CUDA AND NOT USE_ROCM)
 
   IF(USE_MAGMA)
     list(APPEND ATen_CUDA_DEPENDENCY_LIBS ${MAGMA_LIBRARIES})
-    IF ($ENV{TH_BINARY_BUILD})
+    IF($ENV{TH_BINARY_BUILD})
       list(APPEND ATen_CUDA_DEPENDENCY_LIBS
         "${BLAS_LIBRARIES};${BLAS_LIBRARIES};${BLAS_LIBRARIES}")
     ENDIF($ENV{TH_BINARY_BUILD})
   ENDIF(USE_MAGMA)
-  IF ($ENV{ATEN_STATIC_CUDA})
+  IF($ENV{ATEN_STATIC_CUDA})
     list(APPEND ATen_CUDA_DEPENDENCY_LIBS "${CUDA_TOOLKIT_ROOT_DIR}/lib64/libculibos.a")
     list(APPEND ATen_CUDA_DEPENDENCY_LIBS "${CUDA_TOOLKIT_ROOT_DIR}/lib64/libcudart_static.a")
   ENDIF($ENV{ATEN_STATIC_CUDA})

aten/src/ATen/cpu/tbb/CMakeLists.txt

@@ -1,8 +1,8 @@
 # Based on https://github.com/wjakob/tbb/blob/master/CMakeLists.txt
 # All credit goes to Wenzel Jakob!
 
-cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
-project (tbb CXX)
+project(tbb CXX)
 
 include(CheckCXXCompilerFlag)
 include(CheckCXXSourceRuns)
@@ -119,25 +119,25 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 endif()
 
 if(UNIX)
-  add_definitions (-DUSE_PTHREAD)
+  add_definitions(-DUSE_PTHREAD)
 
-   check_cxx_compiler_flag ("-std=c++14" SUPPORTS_STDCXX14)
+   check_cxx_compiler_flag("-std=c++14" SUPPORTS_STDCXX14)
   if(SUPPORTS_STDCXX14)
-    set (CMAKE_CXX_FLAGS "-std=c++14 ${CMAKE_CXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-std=c++14 ${CMAKE_CXX_FLAGS}")
   endif()
 
-   check_cxx_compiler_flag ("-mrtm -Werror" SUPPORTS_MRTM)
+   check_cxx_compiler_flag("-mrtm -Werror" SUPPORTS_MRTM)
   if(SUPPORTS_MRTM)
-    set (CMAKE_CXX_FLAGS "-mrtm ${CMAKE_CXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-mrtm ${CMAKE_CXX_FLAGS}")
   endif()
 
 elseif(WIN32)
   if(MSVC)
-    cmake_minimum_required (VERSION 3.1)
+    cmake_minimum_required(VERSION 3.1)
     enable_language(ASM_MASM)
     set(CMAKE_CXX_FLAGS "/GS- /Zc:wchar_t /Zc:forScope /DUSE_WINTHREAD ${CMAKE_CXX_FLAGS}")
     set(CMAKE_CXX_FLAGS "/D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0600 ${CMAKE_CXX_FLAGS}")
-    check_cxx_compiler_flag ("/volatile:iso" SUPPORTS_VOLATILE_FLAG)
+    check_cxx_compiler_flag("/volatile:iso" SUPPORTS_VOLATILE_FLAG)
     if(SUPPORTS_VOLATILE_FLAG)
       set(CMAKE_CXX_FLAGS "/volatile:iso ${CMAKE_CXX_FLAGS}")
     endif()
@@ -191,7 +191,7 @@ endif()
 ##-------
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-  check_cxx_compiler_flag ("-flifetime-dse=1" SUPPORTS_FLIFETIME)
+  check_cxx_compiler_flag("-flifetime-dse=1" SUPPORTS_FLIFETIME)
   if(SUPPORTS_FLIFETIME)
     add_definitions(-flifetime-dse=1)
   endif()
@@ -199,11 +199,11 @@ endif()
 
 # Linker export definitions
 if(APPLE)
-  set (ARCH_PREFIX "mac")
+  set(ARCH_PREFIX "mac")
 elseif(WIN32)
-  set (ARCH_PREFIX "win")
+  set(ARCH_PREFIX "win")
 else()
-  set (ARCH_PREFIX "lin")
+  set(ARCH_PREFIX "lin")
 endif()
 
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
@@ -213,9 +213,9 @@ else()
 endif()
 
 if(MINGW)
-  set (ARCH_PREFIX "${ARCH_PREFIX}-gcc")
+  set(ARCH_PREFIX "${ARCH_PREFIX}-gcc")
   # there's no win32-gcc-tbb-export.def, use lin32-tbb-export.def
-  execute_process (COMMAND ${CMAKE_COMMAND} -E copy ${TBB_ROOT_DIR}/src/tbb/lin32-tbb-export.def ${TBB_ROOT_DIR}/src/tbb/win32-gcc-tbb-export.def)
+  execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${TBB_ROOT_DIR}/src/tbb/lin32-tbb-export.def ${TBB_ROOT_DIR}/src/tbb/win32-gcc-tbb-export.def)
 endif()
 
 if(MSVC)
@@ -377,15 +377,15 @@ install(DIRECTORY "${TBB_ROOT_DIR}/include/tbb" DESTINATION ${TBB_INSTALL_INCLUD
 
 # version_string.ver
 if(UNIX)
-  execute_process (COMMAND date "+%a, %d %b %Y %H:%M:%S %z"
+  execute_process(COMMAND date "+%a, %d %b %Y %H:%M:%S %z"
                   OUTPUT_VARIABLE _configure_date
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 elseif(WIN32)
-  execute_process (COMMAND cmd " /C date /T"
+  execute_process(COMMAND cmd " /C date /T"
                   OUTPUT_VARIABLE _configure_date
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 else()
-  set (_configure_date "Unknown")
+  set(_configure_date "Unknown")
 endif()
-include_directories (${CMAKE_BINARY_DIR})
+include_directories(${CMAKE_BINARY_DIR})
-configure_file (extra/version_string.ver.in version_string.ver @ONLY)
+configure_file(extra/version_string.ver.in version_string.ver @ONLY)

aten/src/ATen/test/CMakeLists.txt

@@ -1,5 +1,5 @@
-IF (MSVC)
+IF(MSVC)
-  IF (MSVC_VERSION LESS 1911)
+  IF(MSVC_VERSION LESS 1911)
     return()
   ENDIF()
 ENDIF(MSVC)
@@ -49,7 +49,7 @@ list(APPEND ATen_CUDA_TEST_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/cuda_tensor_interop_test.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/cuda_vectorized_test.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/cuda_generator_test.cu)
-if (CAFFE2_USE_CUDNN)
+if(CAFFE2_USE_CUDNN)
   list(APPEND ATen_CUDA_TEST_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/cuda_cudnn_test.cpp)
 endif()

aten/src/ATen/test/test_install/CMakeLists.txt

@@ -3,7 +3,7 @@ find_package(ATen REQUIRED)
 include_directories(${ATEN_INCLUDE_DIR})
 
 # C++14
-if (not MSVC)
+if(not MSVC)
     set(CMAKE_CXX_FLAGS "--std=c++14 ${CMAKE_CXX_FLAGS}")
 endif()
 add_executable(main main.cpp)

binaries/CMakeLists.txt

@@ -1,5 +1,5 @@
-if (INTERN_BUILD_MOBILE)
+if(INTERN_BUILD_MOBILE)
-  if (BUILD_CAFFE2_MOBILE)
+  if(BUILD_CAFFE2_MOBILE)
     caffe2_binary_target("predictor_verifier.cc")
     caffe2_binary_target("speed_benchmark.cc")
   else()
@@ -33,36 +33,36 @@ caffe2_binary_target("split_db.cc")
 
 caffe2_binary_target("db_throughput.cc")
 
-if (BUILD_TEST)
+if(BUILD_TEST)
   # Core overhead benchmark
   caffe2_binary_target("core_overhead_benchmark.cc")
   target_link_libraries(core_overhead_benchmark benchmark)
 endif()
 
-if (USE_CUDA)
+if(USE_CUDA)
   caffe2_binary_target("inspect_gpu.cc")
   target_link_libraries(inspect_gpu ${CUDA_LIBRARIES})
   caffe2_binary_target("print_core_object_sizes_gpu.cc")
 
-  if (BUILD_TEST)
+  if(BUILD_TEST)
     # Core overhead benchmark
     caffe2_binary_target("core_overhead_benchmark_gpu.cc")
     target_link_libraries(core_overhead_benchmark_gpu benchmark ${CUDA_curand_LIBRARY})
   endif()
 endif()
 
-if (USE_ROCM)
+if(USE_ROCM)
   caffe2_hip_binary_target("hip/inspect_gpu.cc")
   caffe2_hip_binary_target("hip/print_core_object_sizes_gpu.cc")
 
-  if (BUILD_TEST)
+  if(BUILD_TEST)
     # Core overhead benchmark
     caffe2_hip_binary_target("hip/core_overhead_benchmark_gpu.cc")
     target_link_libraries(core_overhead_benchmark_gpu benchmark)
   endif()
 endif()
 
-if (USE_ZMQ)
+if(USE_ZMQ)
   caffe2_binary_target("zmq_feeder.cc")
   target_link_libraries(zmq_feeder ${ZMQ_LIBRARIES})
 endif()
@@ -72,25 +72,25 @@ if(USE_MPI)
   target_link_libraries(run_plan_mpi ${MPI_CXX_LIBRARIES})
 endif()
 
-if (USE_OPENCV AND USE_LEVELDB)
+if(USE_OPENCV AND USE_LEVELDB)
   caffe2_binary_target("convert_encoded_to_raw_leveldb.cc")
   target_link_libraries(
       convert_encoded_to_raw_leveldb
       ${OpenCV_LIBS} ${LevelDB_LIBRARIES} ${Snappy_LIBRARIES})
 endif()
 
-if (USE_OPENCV)
+if(USE_OPENCV)
   caffe2_binary_target("make_image_db.cc")
   target_link_libraries(make_image_db ${OpenCV_LIBS})
   caffe2_binary_target("convert_image_to_tensor.cc")
   target_link_libraries(convert_image_to_tensor ${OpenCV_LIBS})
 endif()
 
-if (USE_OBSERVERS)
+if(USE_OBSERVERS)
   caffe2_binary_target(caffe2_benchmark "caffe2_benchmark.cc" "benchmark_helper.cc")
 endif()
 
-if (USE_OBSERVERS AND USE_OPENCV)
+if(USE_OBSERVERS AND USE_OPENCV)
   caffe2_binary_target("convert_and_benchmark.cc")
   target_link_libraries(convert_and_benchmark ${OpenCV_LIBS})
 endif()

caffe2/CMakeLists.txt

@@ -495,7 +495,7 @@ if(NOT INTERN_BUILD_MOBILE OR NOT BUILD_CAFFE2_MOBILE)
     )
 
   if(NOT INTERN_DISABLE_MOBILE_INTERP)
-    set (MOBILE_SRCS
+    set(MOBILE_SRCS
        ${TORCH_SRC_DIR}/csrc/jit/mobile/function.cpp
        ${TORCH_SRC_DIR}/csrc/jit/mobile/import.cpp
        ${TORCH_SRC_DIR}/csrc/jit/mobile/module.cpp
@@ -503,7 +503,7 @@ if(NOT INTERN_BUILD_MOBILE OR NOT BUILD_CAFFE2_MOBILE)
        ${TORCH_SRC_DIR}/csrc/jit/mobile/register_mobile_autograd.cpp
        ${TORCH_SRC_DIR}/csrc/jit/mobile/interpreter.cpp
        )
-    list (APPEND TORCH_SRCS ${MOBILE_SRCS})
+    list(APPEND TORCH_SRCS ${MOBILE_SRCS})
   endif()
 
   if(NOT INTERN_DISABLE_AUTOGRAD)

cmake/Dependencies.cmake

@@ -886,13 +886,13 @@ if(USE_OPENMP)
 
   # macOS + GCC
   if(APPLE AND CMAKE_COMPILER_IS_GNUCC)
-    EXEC_PROGRAM (uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
+    EXEC_PROGRAM(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
-    STRING (REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
+    STRING(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
-    MESSAGE (STATUS "macOS Darwin version: ${DARWIN_VERSION}")
+    MESSAGE(STATUS "macOS Darwin version: ${DARWIN_VERSION}")
     if(DARWIN_VERSION GREATER 9)
       SET(APPLE_OPENMP_SUCKS 1)
     endif(DARWIN_VERSION GREATER 9)
-    EXECUTE_PROCESS (COMMAND ${CMAKE_C_COMPILER} -dumpversion
+    EXECUTE_PROCESS(COMMAND ${CMAKE_C_COMPILER} -dumpversion
       OUTPUT_VARIABLE GCC_VERSION)
     if(APPLE_OPENMP_SUCKS AND GCC_VERSION VERSION_LESS 4.6.2)
       MESSAGE(WARNING "Disabling OpenMP (unstable with this version of GCC). "
@@ -911,7 +911,7 @@ if(USE_OPENMP)
     SET(OPENMP_FOUND ON CACHE BOOL "OpenMP Support found")
     if(NOT MKL_FOUND)
       execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_VARIABLE clang_version_output)
-      string (REGEX REPLACE ".*InstalledDir: ([^\n]+).*" "\\1" CLANG_BINDIR ${clang_version_output})
+      string(REGEX REPLACE ".*InstalledDir: ([^\n]+).*" "\\1" CLANG_BINDIR ${clang_version_output})
 
       get_filename_component(CLANG_ROOT ${CLANG_BINDIR} DIRECTORY)
       set(CLANG_OPENMP_LIBRARY "${CLANG_ROOT}/lib/libiomp5md.lib")
@@ -1248,7 +1248,7 @@ if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO AND NOT INTERN_DISABLE_ONNX)
 endif()
 
 # --[ TensorRT integration with onnx-trt
-function (add_onnx_tensorrt_subdir)
+function(add_onnx_tensorrt_subdir)
   # We pass the paths we found to onnx tensorrt.
   set(CUDNN_INCLUDE_DIR "${CUDNN_INCLUDE_PATH}")
   set(CUDNN_LIBRARY "${CUDNN_LIBRARY_PATH}")

cmake/External/rccl.cmake

@@ -5,14 +5,14 @@ if(NOT __NCCL_INCLUDED)
     # NCCL_ROOT, NCCL_LIB_DIR, NCCL_INCLUDE_DIR will be accounted in the following line.
     find_package(RCCL REQUIRED)
     if(RCCL_FOUND)
-      message (STATUS "RCCL Found!")
+      message(STATUS "RCCL Found!")
       add_library(__caffe2_nccl INTERFACE)
       target_link_libraries(__caffe2_nccl INTERFACE ${PYTORCH_RCCL_LIBRARIES})
       target_include_directories(__caffe2_nccl INTERFACE ${RCCL_INCLUDE_DIRS})
     else()
-      message (STATUS "RCCL NOT Found!")
+      message(STATUS "RCCL NOT Found!")
     endif()
   else()
-    message (STATUS "USE_SYSTEM_NCCL=OFF is not supported yet when using RCCL")
+    message(STATUS "USE_SYSTEM_NCCL=OFF is not supported yet when using RCCL")
   endif()
 endif()

cmake/Summary.cmake

@@ -1,5 +1,5 @@
 # Prints accumulated Caffe2 configuration summary
-function (caffe2_print_configuration_summary)
+function(caffe2_print_configuration_summary)
   message(STATUS "")
   message(STATUS "******** Summary ********")
   message(STATUS "General:")

cmake/Utils.cmake

@@ -1,6 +1,6 @@
 ################################################################################################
 # Exclude and prepend functionalities
-function (exclude OUTPUT INPUT)
+function(exclude OUTPUT INPUT)
 set(EXCLUDES ${ARGN})
 foreach(EXCLUDE ${EXCLUDES})
         list(REMOVE_ITEM INPUT "${EXCLUDE}")
@@ -8,7 +8,7 @@ endforeach()
 set(${OUTPUT} ${INPUT} PARENT_SCOPE)
 endfunction(exclude)
 
-function (prepend OUTPUT PREPEND)
+function(prepend OUTPUT PREPEND)
 set(OUT "")
 foreach(ITEM ${ARGN})
         list(APPEND OUT "${PREPEND}${ITEM}")
@@ -229,12 +229,12 @@ function(print_target_properties tgt)
   STRING(REGEX REPLACE ";" "\\\\;" CMAKE_PROPERTY_LIST "${CMAKE_PROPERTY_LIST}")
   STRING(REGEX REPLACE "\n" ";" CMAKE_PROPERTY_LIST "${CMAKE_PROPERTY_LIST}")
 
-  foreach (prop ${CMAKE_PROPERTY_LIST})
+  foreach(prop ${CMAKE_PROPERTY_LIST})
     string(REPLACE "<CONFIG>" "${CMAKE_BUILD_TYPE}" prop ${prop})
     get_property(propval TARGET ${tgt} PROPERTY ${prop} SET)
     if(propval)
       get_target_property(propval ${tgt} ${prop})
-      message ("${tgt} ${prop} = ${propval}")
+      message("${tgt} ${prop} = ${propval}")
     endif()
   endforeach(prop)
 endfunction(print_target_properties)

cmake/Whitelist.cmake

@@ -3,7 +3,7 @@ if(__caffe2_whitelist_included)
   return()
 endif()
 
-set (__caffe2_whitelist_included TRUE)
+set(__caffe2_whitelist_included TRUE)
 
 set(CAFFE2_WHITELISTED_FILES)
 if(NOT CAFFE2_WHITELIST)

cmake/iOS.cmake

@@ -29,20 +29,20 @@
 #  Thanks to the android-cmake project for providing the command
 
 # Standard settings
-set (CMAKE_SYSTEM_NAME Darwin)
+set(CMAKE_SYSTEM_NAME Darwin)
-set (CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_VERSION 1)
-set (UNIX True)
+set(UNIX True)
-set (APPLE True)
+set(APPLE True)
-set (IOS True)
+set(IOS True)
 
 # Required as of cmake 2.8.10
-set (CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING "Force unset of the deployment target for iOS" FORCE)
+set(CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING "Force unset of the deployment target for iOS" FORCE)
 
 # Determine the cmake host system version so we know where to find the iOS SDKs
-find_program (CMAKE_UNAME uname /bin /usr/bin /usr/local/bin)
+find_program(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin)
 if(CMAKE_UNAME)
     exec_program(uname ARGS -r OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION)
-    string (REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1" DARWIN_MAJOR_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
+    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1" DARWIN_MAJOR_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
 endif(CMAKE_UNAME)
 
 # Force the compilers to gcc for iOS
@@ -54,65 +54,65 @@ set(PKG_CONFIG_EXECUTABLE pkg-config CACHE FILEPATH "" FORCE)
 
 # Setup iOS platform unless specified manually with IOS_PLATFORM
 if(NOT DEFINED IOS_PLATFORM)
-    set (IOS_PLATFORM "OS")
+    set(IOS_PLATFORM "OS")
 endif(NOT DEFINED IOS_PLATFORM)
-set (IOS_PLATFORM ${IOS_PLATFORM} CACHE STRING "Type of iOS Platform")
+set(IOS_PLATFORM ${IOS_PLATFORM} CACHE STRING "Type of iOS Platform")
 
 # Check the platform selection and setup for developer root
 if(${IOS_PLATFORM} STREQUAL "OS")
-    set (IOS_PLATFORM_LOCATION "iPhoneOS.platform")
+    set(IOS_PLATFORM_LOCATION "iPhoneOS.platform")
-    set (XCODE_IOS_PLATFORM iphoneos)
+    set(XCODE_IOS_PLATFORM iphoneos)
 
     # This causes the installers to properly locate the output libraries
-    set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphoneos")
+    set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphoneos")
 elseif(${IOS_PLATFORM} STREQUAL "SIMULATOR")
-    set (IOS_PLATFORM_LOCATION "iPhoneSimulator.platform")
+    set(IOS_PLATFORM_LOCATION "iPhoneSimulator.platform")
-    set (XCODE_IOS_PLATFORM iphonesimulator)
+    set(XCODE_IOS_PLATFORM iphonesimulator)
 
     # This causes the installers to properly locate the output libraries
-    set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphonesimulator")
+    set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphonesimulator")
 elseif(${IOS_PLATFORM} STREQUAL "WATCHOS")
-    set (IOS_PLATFORM_LOCATION "WatchOS.platform")
+    set(IOS_PLATFORM_LOCATION "WatchOS.platform")
-    set (XCODE_IOS_PLATFORM watchos)
+    set(XCODE_IOS_PLATFORM watchos)
 
     # This causes the installers to properly locate the output libraries
-    set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-watchos")
+    set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-watchos")
 else(${IOS_PLATFORM} STREQUAL "OS")
-    message (FATAL_ERROR
+    message(FATAL_ERROR
             "Unsupported IOS_PLATFORM value selected. "
             "Please choose OS, SIMULATOR, or WATCHOS.")
 endif()
 
 # All iOS/Darwin specific settings - some may be redundant
-set (CMAKE_SHARED_LIBRARY_PREFIX "lib")
+set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
-set (CMAKE_SHARED_LIBRARY_SUFFIX ".dylib")
+set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib")
-set (CMAKE_SHARED_MODULE_PREFIX "lib")
+set(CMAKE_SHARED_MODULE_PREFIX "lib")
-set (CMAKE_SHARED_MODULE_SUFFIX ".so")
+set(CMAKE_SHARED_MODULE_SUFFIX ".so")
-set (CMAKE_MODULE_EXISTS 1)
+set(CMAKE_MODULE_EXISTS 1)
-set (CMAKE_DL_LIBS "")
+set(CMAKE_DL_LIBS "")
 
-set (CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
+set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
-set (CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
+set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
-set (CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
+set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
-set (CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
+set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
 
 if(IOS_DEPLOYMENT_TARGET)
   set(XCODE_IOS_PLATFORM_VERSION_FLAGS "-m${XCODE_IOS_PLATFORM}-version-min=${IOS_DEPLOYMENT_TARGET}")
 endif()
 
 # Hidden visibilty is required for cxx on iOS 
-set (CMAKE_C_FLAGS_INIT "${XCODE_IOS_PLATFORM_VERSION_FLAGS}")
+set(CMAKE_C_FLAGS_INIT "${XCODE_IOS_PLATFORM_VERSION_FLAGS}")
-set (CMAKE_CXX_FLAGS_INIT "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -fvisibility-inlines-hidden")
+set(CMAKE_CXX_FLAGS_INIT "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -fvisibility-inlines-hidden")
 
-set (CMAKE_C_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
+set(CMAKE_C_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
-set (CMAKE_CXX_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")
+set(CMAKE_CXX_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")
 
-set (CMAKE_PLATFORM_HAS_INSTALLNAME 1)
+set(CMAKE_PLATFORM_HAS_INSTALLNAME 1)
-set (CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -headerpad_max_install_names")
+set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -headerpad_max_install_names")
-set (CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -headerpad_max_install_names")
+set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -headerpad_max_install_names")
-set (CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
+set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
-set (CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
+set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
-set (CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
+set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
 
 # hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old build tree
 # (where install_name_tool was hardcoded) and where CMAKE_INSTALL_NAME_TOOL isn't in the cache
@@ -123,85 +123,85 @@ if(NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
 endif(NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
 
 # Setup iOS deployment target
-set (IOS_DEPLOYMENT_TARGET ${IOS_DEPLOYMENT_TARGET} CACHE STRING "Minimum iOS version")
+set(IOS_DEPLOYMENT_TARGET ${IOS_DEPLOYMENT_TARGET} CACHE STRING "Minimum iOS version")
 
 # Setup iOS developer location unless specified manually with CMAKE_IOS_DEVELOPER_ROOT
 # Note Xcode 4.3 changed the installation location, choose the most recent one available
 exec_program(/usr/bin/xcode-select ARGS -print-path OUTPUT_VARIABLE CMAKE_XCODE_DEVELOPER_DIR)
-set (XCODE_POST_43_ROOT "${CMAKE_XCODE_DEVELOPER_DIR}/Platforms/${IOS_PLATFORM_LOCATION}/Developer")
+set(XCODE_POST_43_ROOT "${CMAKE_XCODE_DEVELOPER_DIR}/Platforms/${IOS_PLATFORM_LOCATION}/Developer")
-set (XCODE_PRE_43_ROOT "/Developer/Platforms/${IOS_PLATFORM_LOCATION}/Developer")
+set(XCODE_PRE_43_ROOT "/Developer/Platforms/${IOS_PLATFORM_LOCATION}/Developer")
 if(NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
     if(EXISTS ${XCODE_POST_43_ROOT})
-        set (CMAKE_IOS_DEVELOPER_ROOT ${XCODE_POST_43_ROOT})
+        set(CMAKE_IOS_DEVELOPER_ROOT ${XCODE_POST_43_ROOT})
     elseif(EXISTS ${XCODE_PRE_43_ROOT})
-        set (CMAKE_IOS_DEVELOPER_ROOT ${XCODE_PRE_43_ROOT})
+        set(CMAKE_IOS_DEVELOPER_ROOT ${XCODE_PRE_43_ROOT})
     endif(EXISTS ${XCODE_POST_43_ROOT})
 endif(NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
-set (CMAKE_IOS_DEVELOPER_ROOT ${CMAKE_IOS_DEVELOPER_ROOT} CACHE PATH "Location of iOS Platform")
+set(CMAKE_IOS_DEVELOPER_ROOT ${CMAKE_IOS_DEVELOPER_ROOT} CACHE PATH "Location of iOS Platform")
 
 # Find and use the most recent iOS sdk unless specified manually with CMAKE_IOS_SDK_ROOT
 if(NOT DEFINED CMAKE_IOS_SDK_ROOT)
-    file (GLOB _CMAKE_IOS_SDKS "${CMAKE_IOS_DEVELOPER_ROOT}/SDKs/*")
+    file(GLOB _CMAKE_IOS_SDKS "${CMAKE_IOS_DEVELOPER_ROOT}/SDKs/*")
     if(_CMAKE_IOS_SDKS) 
-        list (SORT _CMAKE_IOS_SDKS)
+        list(SORT _CMAKE_IOS_SDKS)
-        list (REVERSE _CMAKE_IOS_SDKS)
+        list(REVERSE _CMAKE_IOS_SDKS)
-        list (GET _CMAKE_IOS_SDKS 0 CMAKE_IOS_SDK_ROOT)
+        list(GET _CMAKE_IOS_SDKS 0 CMAKE_IOS_SDK_ROOT)
     else(_CMAKE_IOS_SDKS)
-        message (FATAL_ERROR "No iOS SDK's found in default search path ${CMAKE_IOS_DEVELOPER_ROOT}. Manually set CMAKE_IOS_SDK_ROOT or install the iOS SDK.")
+        message(FATAL_ERROR "No iOS SDK's found in default search path ${CMAKE_IOS_DEVELOPER_ROOT}. Manually set CMAKE_IOS_SDK_ROOT or install the iOS SDK.")
     endif(_CMAKE_IOS_SDKS)
-    message (STATUS "Toolchain using default iOS SDK: ${CMAKE_IOS_SDK_ROOT}")
+    message(STATUS "Toolchain using default iOS SDK: ${CMAKE_IOS_SDK_ROOT}")
 endif(NOT DEFINED CMAKE_IOS_SDK_ROOT)
-set (CMAKE_IOS_SDK_ROOT ${CMAKE_IOS_SDK_ROOT} CACHE PATH "Location of the selected iOS SDK")
+set(CMAKE_IOS_SDK_ROOT ${CMAKE_IOS_SDK_ROOT} CACHE PATH "Location of the selected iOS SDK")
 
 # Set the sysroot default to the most recent SDK
-set (CMAKE_OSX_SYSROOT ${CMAKE_IOS_SDK_ROOT} CACHE PATH "Sysroot used for iOS support")
+set(CMAKE_OSX_SYSROOT ${CMAKE_IOS_SDK_ROOT} CACHE PATH "Sysroot used for iOS support")
 
 # set the architecture for iOS 
 if(IOS_PLATFORM STREQUAL "OS")
-    set (DEFAULT_IOS_ARCH "arm64")
+    set(DEFAULT_IOS_ARCH "arm64")
 elseif(IOS_PLATFORM STREQUAL "SIMULATOR")
-    set (DEFAULT_IOS_ARCH "x86_64")
+    set(DEFAULT_IOS_ARCH "x86_64")
 elseif(IOS_PLATFORM STREQUAL "WATCHOS")
-    set (DEFAULT_IOS_ARCH "armv7k;arm64_32")
+    set(DEFAULT_IOS_ARCH "armv7k;arm64_32")
 endif()
 
-set (IOS_ARCH ${DEFAULT_IOS_ARCH} CACHE string  "Build architecture for iOS")
+set(IOS_ARCH ${DEFAULT_IOS_ARCH} CACHE string  "Build architecture for iOS")
-set (CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE string  "Build architecture for iOS")
+set(CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE string  "Build architecture for iOS")
 
 # Set the find root to the iOS developer roots and to user defined paths
-set (CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_IOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} CACHE string  "iOS find search path root")
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_IOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} CACHE string  "iOS find search path root")
 
 # default to searching for frameworks first
-set (CMAKE_FIND_FRAMEWORK FIRST)
+set(CMAKE_FIND_FRAMEWORK FIRST)
 
 # set up the default search directories for frameworks
-set (CMAKE_SYSTEM_FRAMEWORK_PATH
+set(CMAKE_SYSTEM_FRAMEWORK_PATH
     ${CMAKE_IOS_SDK_ROOT}/System/Library/Frameworks
     ${CMAKE_IOS_SDK_ROOT}/System/Library/PrivateFrameworks
     ${CMAKE_IOS_SDK_ROOT}/Developer/Library/Frameworks
 )
 
 # only search the iOS sdks, not the remainder of the host filesystem
-set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
-set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 
 # This little macro lets you set any XCode specific property
-macro (set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE)
+macro(set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE)
-    set_property (TARGET ${TARGET} PROPERTY XCODE_ATTRIBUTE_${XCODE_PROPERTY} ${XCODE_VALUE})
+    set_property(TARGET ${TARGET} PROPERTY XCODE_ATTRIBUTE_${XCODE_PROPERTY} ${XCODE_VALUE})
-endmacro (set_xcode_property)
+endmacro(set_xcode_property)
 
 # This macro lets you find executable programs on the host system
-macro (find_host_package)
+macro(find_host_package)
-    set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-    set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER)
+    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER)
-    set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER)
+    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER)
-    set (IOS FALSE)
+    set(IOS FALSE)
 
     find_package(${ARGN})
 
-    set (IOS TRUE)
+    set(IOS TRUE)
-    set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
-    set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-    set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-endmacro (find_host_package)
+endmacro(find_host_package)

cmake/public/utils.cmake

@@ -1,6 +1,6 @@
 ##############################################################################
 # Macro to update cached options.
-macro (caffe2_update_option variable value)
+macro(caffe2_update_option variable value)
   if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
     get_property(__help_string CACHE ${variable} PROPERTY HELPSTRING)
     set(${variable} ${value} CACHE BOOL ${__help_string} FORCE)

modules/detectron/CMakeLists.txt

@@ -2,14 +2,14 @@ file(GLOB Detectron_CPU_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/*.cc)
 file(GLOB Detectron_GPU_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/*.cu)
 file(GLOB_RECURSE Detectron_HIP_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/*.hip)
 
-if (BUILD_CAFFE2_OPS)
+if(BUILD_CAFFE2_OPS)
-  if (USE_OPENMP AND OPENMP_FOUND)
+  if(USE_OPENMP AND OPENMP_FOUND)
     Set(OpenMP_link ${OpenMP_CXX_LIBRARIES})
   endif()
 
   # Note(ilijar): Since Detectron ops currently have no
   # CPU implementation, we only build GPU ops for now.
-  if (USE_CUDA)
+  if(USE_CUDA)
     CUDA_ADD_LIBRARY(
         caffe2_detectron_ops_gpu SHARED
         ${Detectron_CPU_SRCS}
@@ -17,7 +17,7 @@ if (BUILD_CAFFE2_OPS)
 
     target_link_libraries(caffe2_detectron_ops_gpu torch ${OpenMP_link})
     install(TARGETS caffe2_detectron_ops_gpu DESTINATION lib)
-    if (MSVC)
+    if(MSVC)
       install(FILES $<TARGET_PDB_FILE:caffe2_detectron_ops_gpu> DESTINATION lib OPTIONAL)
     endif()
   elseif(USE_ROCM)
@@ -34,7 +34,7 @@ if (BUILD_CAFFE2_OPS)
     add_library(caffe2_detectron_ops SHARED ${Detectron_CPU_SRCS})
     target_link_libraries(caffe2_detectron_ops torch ${OpenMP_link})
     install(TARGETS caffe2_detectron_ops DESTINATION lib)
-    if (MSVC)
+    if(MSVC)
       install(FILES $<TARGET_PDB_FILE:caffe2_detectron_ops> DESTINATION lib OPTIONAL)
     endif()
   endif()

modules/module_test/CMakeLists.txt

@@ -1,4 +1,4 @@
-if (NOT CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
+if(NOT CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
   # If we are building the standalone module, we set the proper cmake variables.
   cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
   find_package(Caffe2 REQUIRED)
@@ -6,14 +6,14 @@ if (NOT CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
   option(BUILD_SHARED_LIBS "Build shared libs." ON)
 endif()
 
-if (BUILD_TEST)
+if(BUILD_TEST)
   add_library(
       caffe2_module_test_dynamic
       ${CMAKE_CURRENT_SOURCE_DIR}/module_test_dynamic.cc)
 
   target_link_libraries(caffe2_module_test_dynamic torch_library)
   install(TARGETS caffe2_module_test_dynamic DESTINATION lib)
-  if (MSVC AND BUILD_SHARED_LIBS)
+  if(MSVC AND BUILD_SHARED_LIBS)
     install(FILES $<TARGET_PDB_FILE:caffe2_module_test_dynamic> DESTINATION lib OPTIONAL)
   endif()
 endif()

modules/observers/CMakeLists.txt

@@ -1,5 +1,5 @@
-if (CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
+if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
-  if (NOT USE_OBSERVERS)
+  if(NOT USE_OBSERVERS)
     return()
   endif()
 else()
@@ -19,11 +19,11 @@ target_include_directories(caffe2_observers PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/.
 target_compile_options(caffe2_observers PRIVATE "-DCAFFE2_BUILD_OBSERVER_LIB")
 install(TARGETS caffe2_observers DESTINATION lib)
 caffe2_interface_library(caffe2_observers caffe2_observers_library)
-if (MSVC AND BUILD_SHARED_LIBS)
+if(MSVC AND BUILD_SHARED_LIBS)
   install(FILES $<TARGET_PDB_FILE:caffe2_observers> DESTINATION lib OPTIONAL)
 endif()
 
-if (CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
+if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
   set(Caffe2_MODULES ${Caffe2_MODULES} caffe2_observers_library PARENT_SCOPE)
 endif()
 

modules/rocksdb/CMakeLists.txt

@@ -19,8 +19,8 @@
 # (2) When we are not building with the main repo, we will need to do the usual
 #     cmake setup: version checks, project options, find dependent packages,
 #     etc.
-if (CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
+if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
-  if (NOT USE_ROCKSDB)
+  if(NOT USE_ROCKSDB)
     return()
   endif()
 else()
@@ -69,6 +69,6 @@ install(TARGETS caffe2_rocksdb DESTINATION lib)
 # them.
 # Note(jiayq): this also depends on a separate cmake move to reorg test builds
 # and binary builds after modules. When it is done, this note should be removed.
-if (CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
+if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
   set(Caffe2_MODULES ${Caffe2_MODULES} caffe2_rocksdb PARENT_SCOPE)
 endif()

test/cpp/api/CMakeLists.txt

@@ -32,7 +32,7 @@ set(TORCH_API_TEST_SOURCES
   ${TORCH_API_TEST_DIR}/torch_include.cpp
 )
 
-if (USE_CUDA)
+if(USE_CUDA)
   list(APPEND TORCH_API_TEST_SOURCES ${TORCH_API_TEST_DIR}/parallel.cpp)
 endif()
 
@@ -40,7 +40,7 @@ add_executable(test_api ${TORCH_API_TEST_SOURCES})
 target_include_directories(test_api PRIVATE ${ATen_CPU_INCLUDE})
 target_link_libraries(test_api PRIVATE torch gtest)
 
-if (USE_CUDA)
+if(USE_CUDA)
   target_link_libraries(test_api PRIVATE
     ${CUDA_LIBRARIES}
     ${CUDA_NVRTC_LIB}
@@ -50,8 +50,8 @@ if (USE_CUDA)
   target_compile_definitions(test_api PRIVATE "USE_CUDA")
 endif()
 
-if (NOT MSVC)
+if(NOT MSVC)
-  if (APPLE)
+  if(APPLE)
     target_compile_options(test_api PRIVATE
       # Clang has an unfixed bug leading to spurious missing braces
       # warnings, see https://bugs.llvm.org/show_bug.cgi?id=21629
@@ -66,10 +66,10 @@ if (NOT MSVC)
   endif()
 endif()
 
-if (INSTALL_TEST)
+if(INSTALL_TEST)
   install(TARGETS test_api DESTINATION bin)
   # Install PDB files for MSVC builds
-  if (MSVC AND BUILD_SHARED_LIBS)
+  if(MSVC AND BUILD_SHARED_LIBS)
     install(FILES $<TARGET_PDB_FILE:test_api> DESTINATION bin OPTIONAL)
   endif()
 endif()

test/cpp/dist_autograd/CMakeLists.txt

@@ -1,4 +1,4 @@
-if (USE_DISTRIBUTED)
+if(USE_DISTRIBUTED)
   set(DIST_AUTOGRAD_TEST_DIR "${TORCH_ROOT}/test/cpp/dist_autograd")
   set(DIST_AUTOGRAD_TEST_SOURCES
     ${TORCH_ROOT}/test/cpp/common/main.cpp
@@ -9,7 +9,7 @@ if (USE_DISTRIBUTED)
   target_include_directories(test_dist_autograd PRIVATE ${ATen_CPU_INCLUDE})
   target_link_libraries(test_dist_autograd PRIVATE torch gtest)
 
-  if (USE_CUDA)
+  if(USE_CUDA)
     target_link_libraries(test_dist_autograd PRIVATE
       ${CUDA_LIBRARIES}
       ${CUDA_NVRTC_LIB}
@@ -19,10 +19,10 @@ if (USE_DISTRIBUTED)
     target_compile_definitions(test_dist_autograd PRIVATE "USE_CUDA")
   endif()
 
-  if (INSTALL_TEST)
+  if(INSTALL_TEST)
     install(TARGETS test_dist_autograd DESTINATION bin)
     # Install PDB files for MSVC builds
-    if (MSVC AND BUILD_SHARED_LIBS)
+    if(MSVC AND BUILD_SHARED_LIBS)
       install(FILES $<TARGET_PDB_FILE:test_dist_autograd> DESTINATION bin OPTIONAL)
     endif()
   endif()

test/cpp/rpc/CMakeLists.txt

@@ -8,7 +8,7 @@ add_executable(test_cpp_rpc ${TORCH_RPC_TEST_SOURCES})
 target_include_directories(test_cpp_rpc PRIVATE ${ATen_CPU_INCLUDE})
 target_link_libraries(test_cpp_rpc PRIVATE torch gtest)
 
-if (USE_CUDA)
+if(USE_CUDA)
   target_link_libraries(test_cpp_rpc PRIVATE
     ${CUDA_LIBRARIES}
     ${CUDA_NVRTC_LIB}
@@ -18,10 +18,10 @@ if (USE_CUDA)
   target_compile_definitions(test_cpp_rpc PRIVATE "USE_CUDA")
 endif()
 
-if (INSTALL_TEST)
+if(INSTALL_TEST)
   install(TARGETS test_cpp_rpc DESTINATION bin)
   # Install PDB files for MSVC builds
-  if (MSVC AND BUILD_SHARED_LIBS)
+  if(MSVC AND BUILD_SHARED_LIBS)
     install(FILES $<TARGET_PDB_FILE:test_cpp_rpc> DESTINATION bin OPTIONAL)
   endif()
 endif()