add gersemi to pre-commit hooks for CMake formatting like black

(cherry picked from commit 2f6d7f2dad44b40de5850c52a8f44cbc33c8d575)

.pre-commit-config.yaml

@@ -33,6 +33,12 @@ repos:
       - id: codespell
         additional_dependencies: [tomli]
 
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.18.2
+    hooks:
+      - id: gersemi
+        args: ["-i", "--no-warn-about-unknown-commands", "-l", "120"]
+
   - repo: local
     hooks:
       - id: copyright-headers

CMakeLists.txt

@@ -37,23 +37,25 @@ function is run.
 The CMake equivalent is below.
 ]=======================================================================]
 
-include( cmake/godotcpp.cmake )
+include(cmake/godotcpp.cmake)
 
 godotcpp_options()
 
 # Define our project.
-project( godot-cpp
-        VERSION 4.4
-        DESCRIPTION "C++ bindings for the Godot Engine's GDExtensions API."
-        HOMEPAGE_URL "https://github.com/godotengine/godot-cpp"
-        LANGUAGES CXX)
+project(
+    godot-cpp
+    VERSION 4.4
+    DESCRIPTION "C++ bindings for the Godot Engine's GDExtensions API."
+    HOMEPAGE_URL "https://github.com/godotengine/godot-cpp"
+    LANGUAGES CXX
+)
 
 compiler_detection()
 godotcpp_generate()
 
 # Conditionally enable the godot-cpp.test.<target> integration testing targets
-if( GODOTCPP_ENABLE_TESTING )
-    add_subdirectory( test )
+if(GODOTCPP_ENABLE_TESTING)
+    add_subdirectory(test)
 endif()
 
 # If this is the top level CMakeLists.txt, Generators which honor the

cmake/GodotCPPModule.cmake

@@ -26,120 +26,130 @@ The build_profile.py has a __main__ and is used as a tool
 Its usage is listed as:
     $ python build_profile.py BUILD_PROFILE INPUT_JSON [OUTPUT_JSON]
 ]]
-function( build_profile_generate_trimmed_api BUILD_PROFILE INPUT_JSON OUTPUT_JSON )
+function(build_profile_generate_trimmed_api BUILD_PROFILE INPUT_JSON OUTPUT_JSON)
     execute_process(
-            COMMAND "${Python3_EXECUTABLE}"
-                "${godot-cpp_SOURCE_DIR}/build_profile.py"
-                "${BUILD_PROFILE}"
-                "${INPUT_JSON}"
-                "${OUTPUT_JSON}"
-            WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
+        COMMAND
+            "${Python3_EXECUTABLE}" "${godot-cpp_SOURCE_DIR}/build_profile.py" "${BUILD_PROFILE}" "${INPUT_JSON}"
+            "${OUTPUT_JSON}"
+        WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
     )
-endfunction(  )
-
+endfunction()
 
 #[[ Generate File List
 
 Use the binding_generator.py Python script to determine the list of files that
 will be passed to the code generator using extension_api.json.
 NOTE: This happens for every configure.]]
-function( binding_generator_get_file_list OUT_VAR_NAME API_FILEPATH OUTPUT_DIR )
-
+function(binding_generator_get_file_list OUT_VAR_NAME API_FILEPATH OUTPUT_DIR)
     # This code snippet will be squashed into a single line
     # The two strings make this a list, in CMake lists are semicolon delimited strings.
-    set( PYTHON_SCRIPT
-"from binding_generator import print_file_list"
-"print_file_list( api_filepath='${API_FILEPATH}',
+    set(PYTHON_SCRIPT
+        "from binding_generator import print_file_list"
+        "print_file_list( api_filepath='${API_FILEPATH}',
     output_dir='${OUTPUT_DIR}',
     headers=True,
-    sources=True)")
-    message( DEBUG "Python:\n${PYTHON_SCRIPT}" )
+    sources=True)"
+    )
+    message(DEBUG "Python:\n${PYTHON_SCRIPT}")
 
     # Strip newlines and whitespace to make it a one-liner.
-    string( REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT}" )
+    string(REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT}")
 
-    execute_process( COMMAND "${Python3_EXECUTABLE}" "-c" "${PYTHON_SCRIPT}"
-            WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
-            OUTPUT_VARIABLE GENERATED_FILES_LIST
-            OUTPUT_STRIP_TRAILING_WHITESPACE
+    execute_process(
+        COMMAND "${Python3_EXECUTABLE}" "-c" "${PYTHON_SCRIPT}"
+        WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
+        OUTPUT_VARIABLE GENERATED_FILES_LIST
+        OUTPUT_STRIP_TRAILING_WHITESPACE
     )
 
     # Debug output
-    message( DEBUG "FileList-Begin" )
-    foreach( PATH ${GENERATED_FILES_LIST} )
-        message( DEBUG ${PATH} )
+    message(DEBUG "FileList-Begin")
+    foreach(PATH ${GENERATED_FILES_LIST})
+        message(DEBUG ${PATH})
     endforeach()
 
     # Error out if the file list generator returned no files.
-    list( LENGTH GENERATED_FILES_LIST LIST_LENGTH )
-    if( NOT LIST_LENGTH GREATER 0 )
-        message( FATAL_ERROR "File List Generation Failed")
+    list(LENGTH GENERATED_FILES_LIST LIST_LENGTH)
+    if(NOT LIST_LENGTH GREATER 0)
+        message(FATAL_ERROR "File List Generation Failed")
     endif()
-    message( STATUS "There are ${LIST_LENGTH} Files to generate" )
-
-    set( ${OUT_VAR_NAME} ${GENERATED_FILES_LIST} PARENT_SCOPE )
-endfunction(  )
+    message(STATUS "There are ${LIST_LENGTH} Files to generate")
 
+    set(${OUT_VAR_NAME} ${GENERATED_FILES_LIST} PARENT_SCOPE)
+endfunction()
 
 #[[ Generate Bindings
 
 Using the generated file list, use the binding_generator.py to generate the
 godot-cpp bindings. This will run at build time only if there are files
 missing. ]]
-function( binding_generator_generate_bindings API_FILE USE_TEMPLATE_GET_NODE, BITS, PRECISION, OUTPUT_DIR )
+function(
+    binding_generator_generate_bindings
+    API_FILE
+    USE_TEMPLATE_GET_NODE,
+    BITS,
+    PRECISION,
+    OUTPUT_DIR
+)
     # This code snippet will be squashed into a single line
-    set( PYTHON_SCRIPT
-"from binding_generator import generate_bindings"
-"generate_bindings(
+    set(PYTHON_SCRIPT
+        "from binding_generator import generate_bindings"
+        "generate_bindings(
     api_filepath='${API_FILE}',
     use_template_get_node='${USE_TEMPLATE_GET_NODE}',
     bits='${BITS}',
     precision='${PRECISION}',
-    output_dir='${OUTPUT_DIR}')")
+    output_dir='${OUTPUT_DIR}')"
+    )
 
-    message( DEBUG "Python:\n${PYTHON_SCRIPT}" )
+    message(DEBUG "Python:\n${PYTHON_SCRIPT}")
 
     # Strip newlines and whitespace to make it a one-liner.
-    string( REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT}" )
-
-    add_custom_command(OUTPUT ${GENERATED_FILES_LIST}
-            COMMAND "${Python3_EXECUTABLE}" "-c" "${PYTHON_SCRIPT}"
-            VERBATIM
-            WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
-            MAIN_DEPENDENCY ${GODOTCPP_GDEXTENSION_API_FILE}
-            DEPENDS ${godot-cpp_SOURCE_DIR}/binding_generator.py
-            COMMENT "Generating bindings"
+    string(REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT}")
+
+    add_custom_command(
+        OUTPUT ${GENERATED_FILES_LIST}
+        COMMAND "${Python3_EXECUTABLE}" "-c" "${PYTHON_SCRIPT}"
+        VERBATIM
+        WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
+        MAIN_DEPENDENCY ${GODOTCPP_GDEXTENSION_API_FILE}
+        DEPENDS ${godot-cpp_SOURCE_DIR}/binding_generator.py
+        COMMENT "Generating bindings"
     )
-endfunction(  )
+endfunction()
 
 #[[ Generate doc_data.cpp
 The documentation displayed in the Godot editor is compiled into the extension.
 It takes a list of XML source files, and transforms them into a cpp file that
 is added to the sources list.]]
-function( generate_doc_source OUTPUT_PATH SOURCES )
+function(generate_doc_source OUTPUT_PATH SOURCES)
     # Transform SOURCES CMake LIST
     # quote each path with ''
     # join with , to transform into a python list minus the surrounding []
-    set( PYTHON_LIST "${SOURCES}")
-    list( TRANSFORM PYTHON_LIST REPLACE "(.*\.xml)" "'\\1'" )
-    list( JOIN PYTHON_LIST "," PYTHON_LIST )
+    set(PYTHON_LIST "${SOURCES}")
+    list(TRANSFORM PYTHON_LIST REPLACE "(.*\.xml)" "'\\1'")
+    list(JOIN PYTHON_LIST "," PYTHON_LIST)
 
     get_filename_component(OUTPUT_DIR "${OUTPUT_PATH}" DIRECTORY)
-    file(MAKE_DIRECTORY ${OUTPUT_DIR} )
+    file(MAKE_DIRECTORY ${OUTPUT_DIR})
 
     # Python one-liner to run our command
     # lists in CMake are just strings delimited by ';', so this works.
-    set( PYTHON_SCRIPT "from doc_source_generator import generate_doc_source"
-            "generate_doc_source( '${OUTPUT_PATH}', [${PYTHON_LIST}] )" )
-
-    add_custom_command( OUTPUT "${OUTPUT_PATH}"
-            COMMAND "${Python3_EXECUTABLE}" "-c" "${PYTHON_SCRIPT}"
-            VERBATIM
-            WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
-            DEPENDS
+    set(PYTHON_SCRIPT
+        "from doc_source_generator import generate_doc_source"
+        "generate_doc_source( '${OUTPUT_PATH}', [${PYTHON_LIST}] )"
+    )
+
+    add_custom_command(
+        OUTPUT "${OUTPUT_PATH}"
+        COMMAND "${Python3_EXECUTABLE}" "-c" "${PYTHON_SCRIPT}"
+        VERBATIM
+        WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
+        DEPENDS
+        DEPENDS #
             "${godot-cpp_SOURCE_DIR}/doc_source_generator.py"
             "${SOURCES}"
-            COMMENT "Generating: ${OUTPUT_PATH}"
+        COMMENT "Generating: ${OUTPUT_PATH}"
     )
 endfunction()
 
@@ -148,22 +158,22 @@ A simpler interface to add xml files as doc source to a output target.
 TARGET: The gdexension library target
 SOURCES: a list of xml files to use for source generation and inclusion.
 This function also adds a doc_gen target to test source generation.]]
-function( target_doc_sources TARGET SOURCES )
+function(target_doc_sources TARGET SOURCES)
     # set the generated file name
-    set( DOC_SOURCE_FILE "${CMAKE_CURRENT_BINARY_DIR}/gen/doc_source.cpp" )
+    set(DOC_SOURCE_FILE "${CMAKE_CURRENT_BINARY_DIR}/gen/doc_source.cpp")
 
     # Create the file generation target, this won't be triggered unless a target
     # that depends on DOC_SOURCE_FILE is built
     generate_doc_source( "${DOC_SOURCE_FILE}" ${SOURCES} )
 
     # Add DOC_SOURCE_FILE as a dependency to TARGET
-    target_sources( ${TARGET} PRIVATE "${DOC_SOURCE_FILE}" )
+    target_sources(${TARGET} PRIVATE "${DOC_SOURCE_FILE}")
 
     # Create a dummy target that depends on the source so that users can
     # test the file generation task.
-    if( TARGET doc_gen )
+    if(TARGET doc_gen)
     else()
-        add_custom_target( doc_gen )
+        add_custom_target(doc_gen)
     endif()
-    target_sources( doc_gen PRIVATE "${DOC_SOURCE_FILE}"  )
+    target_sources(doc_gen PRIVATE "${DOC_SOURCE_FILE}")
 endfunction()

cmake/android.cmake

@@ -25,16 +25,12 @@ Android platforms.
 There is further information and examples in the doc/cmake.rst file.
 
 ]=======================================================================]
-function( android_options )
+function(android_options)
     # Android Options
 endfunction()
 
-function( android_generate )
-    target_compile_definitions(${TARGET_NAME}
-            PUBLIC
-            ANDROID_ENABLED
-            UNIX_ENABLED
-    )
+function(android_generate)
+    target_compile_definitions(${TARGET_NAME} PUBLIC ANDROID_ENABLED UNIX_ENABLED)
 
     common_compiler_flags()
 endfunction()

cmake/common_compiler_flags.cmake

@@ -10,20 +10,20 @@ features. For target platform specific flags look to each of the
 ]=======================================================================]
 
 #[[ Compiler Configuration, not to be confused with build targets ]]
-set( DEBUG_SYMBOLS "$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>" )
+set(DEBUG_SYMBOLS "$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>")
 
 #[[ Compiler Identification ]]
-set( IS_CLANG "$<CXX_COMPILER_ID:Clang>" )
-set( IS_APPLECLANG "$<CXX_COMPILER_ID:AppleClang>" )
-set( IS_GNU "$<CXX_COMPILER_ID:GNU>" )
-set( IS_MSVC "$<CXX_COMPILER_ID:MSVC>" )
-set( NOT_MSVC "$<NOT:$<CXX_COMPILER_ID:MSVC>>" )
-
-set( GNU_LT_V8 "$<VERSION_LESS:$<CXX_COMPILER_VERSION>,8>" )
-set( GNU_GE_V9 "$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,9>" )
-set( GNU_GT_V11 "$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,11>" )
-set( GNU_LT_V11 "$<VERSION_LESS:$<CXX_COMPILER_VERSION>,11>" )
-set( GNU_GE_V12 "$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,12>" )
+set(IS_CLANG "$<CXX_COMPILER_ID:Clang>")
+set(IS_APPLECLANG "$<CXX_COMPILER_ID:AppleClang>")
+set(IS_GNU "$<CXX_COMPILER_ID:GNU>")
+set(IS_MSVC "$<CXX_COMPILER_ID:MSVC>")
+set(NOT_MSVC "$<NOT:$<CXX_COMPILER_ID:MSVC>>")
+
+set(GNU_LT_V8 "$<VERSION_LESS:$<CXX_COMPILER_VERSION>,8>")
+set(GNU_GE_V9 "$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,9>")
+set(GNU_GT_V11 "$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,11>")
+set(GNU_LT_V11 "$<VERSION_LESS:$<CXX_COMPILER_VERSION>,11>")
+set(GNU_GE_V12 "$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,12>")
 
 #[[ Check for clang-cl with MSVC frontend
 The compiler is tested and set when the project command is called.
@@ -33,32 +33,26 @@ until CMake 3.30 so we can't use it yet.
 
 So to support clang downloaded from llvm.org which uses the MSVC frontend
 by default, we need to test for it. ]]
-function( compiler_detection )
-    if( ${CMAKE_CXX_COMPILER_ID} STREQUAL Clang )
-        if( ${CMAKE_CXX_COMPILER_FRONTEND_VARIANT} STREQUAL MSVC )
-            message( "Using clang-cl" )
-            set( IS_CLANG   "0" PARENT_SCOPE )
-            set( IS_MSVC    "1" PARENT_SCOPE )
-            set( NOT_MSVC   "0" PARENT_SCOPE )
-        endif ()
-    endif ()
-endfunction(  )
-
-function( common_compiler_flags )
-
-    target_compile_features(${TARGET_NAME}
-            PUBLIC
-            cxx_std_17
-    )
+function(compiler_detection)
+    if(${CMAKE_CXX_COMPILER_ID} STREQUAL Clang)
+        if(${CMAKE_CXX_COMPILER_FRONTEND_VARIANT} STREQUAL MSVC)
+            message("Using clang-cl")
+            set(IS_CLANG "0" PARENT_SCOPE)
+            set(IS_MSVC "1" PARENT_SCOPE)
+            set(NOT_MSVC "0" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
 
+function(common_compiler_flags)
+    # gersemi: off
     # These compiler options reflect what is in godot/SConstruct.
-    target_compile_options( ${TARGET_NAME}
+    target_compile_options(
+        ${TARGET_NAME}
         PUBLIC
             # Disable exception handling. Godot doesn't use exceptions anywhere, and this
             # saves around 20% of binary size and very significant build time.
-            $<${DISABLE_EXCEPTIONS}:
-                $<${NOT_MSVC}:-fno-exceptions>
-            >
+            $<${DISABLE_EXCEPTIONS}:$<${NOT_MSVC}:-fno-exceptions>>
 
             # Enabling Debug Symbols
             $<${DEBUG_SYMBOLS}:
@@ -70,78 +64,75 @@ function( common_compiler_flags )
                 >
             >
 
-            $<${IS_DEV_BUILD}:
-                $<${NOT_MSVC}:-fno-omit-frame-pointer -O0>
+            $<${IS_DEV_BUILD}:$<${NOT_MSVC}:-fno-omit-frame-pointer -O0>>
+
+            $<${HOT_RELOAD}:$<${IS_GNU}:-fno-gnu-unique>>
+
+            # MSVC only
+            $<${IS_MSVC}:
+                # /MP isn't valid for clang-cl with msvc frontend
+                $<$<CXX_COMPILER_ID:MSVC>:/MP${PROC_N}>
+                /W4
+
+                # Disable warnings which we don't plan to fix.
+                /wd4100  # C4100 (unreferenced formal parameter): Doesn't play nice with polymorphism.
+                /wd4127  # C4127 (conditional expression is constant)
+                /wd4201  # C4201 (non-standard nameless struct/union): Only relevant for C89.
+                /wd4244  # C4244 C4245 C4267 (narrowing conversions): Unavoidable at this scale.
+                /wd4245
+                /wd4267
+                /wd4305  # C4305 (truncation): double to float or real_t, too hard to avoid.
+                /wd4514  # C4514 (unreferenced inline function has been removed)
+                /wd4714  # C4714 (function marked as __forceinline not inlined)
+                /wd4820  # C4820 (padding added after construct)
+
+                /utf-8
+            >
+
+            # Clang and GNU common options
+            $<$<OR:${IS_CLANG},${IS_GNU}>:
+                -Wall
+                -Wctor-dtor-privacy
+                -Wextra
+                -Wno-unused-parameter
+                -Wnon-virtual-dtor
+                -Wwrite-strings
             >
 
-            $<${HOT_RELOAD}:
-                $<${IS_GNU}:-fno-gnu-unique>
+            # Clang only
+            $<${IS_CLANG}:
+                -Wimplicit-fallthrough
+                -Wno-ordered-compare-function-pointers
             >
 
-        # MSVC only
-        $<${IS_MSVC}:
-            # /MP isn't valid for clang-cl with msvc frontend
-            $<$<CXX_COMPILER_ID:MSVC>:/MP${PROC_N}>
-            /W4
-
-            # Disable warnings which we don't plan to fix.
-            /wd4100  # C4100 (unreferenced formal parameter): Doesn't play nice with polymorphism.
-            /wd4127  # C4127 (conditional expression is constant)
-            /wd4201  # C4201 (non-standard nameless struct/union): Only relevant for C89.
-            /wd4244  # C4244 C4245 C4267 (narrowing conversions): Unavoidable at this scale.
-            /wd4245
-            /wd4267
-            /wd4305  # C4305 (truncation): double to float or real_t, too hard to avoid.
-            /wd4514  # C4514 (unreferenced inline function has been removed)
-            /wd4714  # C4714 (function marked as __forceinline not inlined)
-            /wd4820  # C4820 (padding added after construct)
-
-            /utf-8
-        >
-
-        # Clang and GNU common options
-        $<$<OR:${IS_CLANG},${IS_GNU}>:
-            -Wall
-            -Wctor-dtor-privacy
-            -Wextra
-            -Wno-unused-parameter
-            -Wnon-virtual-dtor
-            -Wwrite-strings
-        >
-
-        # Clang only
-        $<${IS_CLANG}:
-            -Wimplicit-fallthrough
-            -Wno-ordered-compare-function-pointers
-        >
-
-        # GNU only
-        $<${IS_GNU}:
-            -Walloc-zero
-            -Wduplicated-branches
-            -Wduplicated-cond
-            -Wno-misleading-indentation
-            -Wplacement-new=1
-            -Wshadow-local
-            -Wstringop-overflow=4
-
-            # Bogus warning fixed in 8+.
-            $<${GNU_LT_V8}:-Wno-strict-overflow>
-
-            $<${GNU_GE_V9}:-Wattribute-alias=2>
-
-            # Broke on MethodBind templates before GCC 11.
-            $<${GNU_GT_V11}:-Wlogical-op>
-
-            # Regression in GCC 9/10, spams so much in our variadic templates that we need to outright disable it.
-            $<${GNU_LT_V11}:-Wno-type-limits>
-
-            # False positives in our error macros, see GH-58747.
-            $<${GNU_GE_V12}:-Wno-return-type>
-        >
+            # GNU only
+            $<${IS_GNU}:
+                -Walloc-zero
+                -Wduplicated-branches
+                -Wduplicated-cond
+                -Wno-misleading-indentation
+                -Wplacement-new=1
+                -Wshadow-local
+                -Wstringop-overflow=4
+
+                # Bogus warning fixed in 8+.
+                $<${GNU_LT_V8}:-Wno-strict-overflow>
+
+                $<${GNU_GE_V9}:-Wattribute-alias=2>
+
+                # Broke on MethodBind templates before GCC 11.
+                $<${GNU_GT_V11}:-Wlogical-op>
+
+                # Regression in GCC 9/10, spams so much in our variadic templates that we need to outright disable it.
+                $<${GNU_LT_V11}:-Wno-type-limits>
+
+                # False positives in our error macros, see GH-58747.
+                $<${GNU_GE_V12}:-Wno-return-type>
+            >
     )
 
-    target_compile_definitions(${TARGET_NAME}
+    target_compile_definitions(
+        ${TARGET_NAME}
         PUBLIC
             GDEXTENSION
 
@@ -159,7 +150,8 @@ function( common_compiler_flags )
             $<${THREADS_ENABLED}:THREADS_ENABLED>
     )
 
-    target_link_options( ${TARGET_NAME}
+    target_link_options(
+        ${TARGET_NAME}
         PUBLIC
             $<${IS_MSVC}:
                 /WX             # treat link warnings as errors.
@@ -167,11 +159,12 @@ function( common_compiler_flags )
             >
 
             $<${DEBUG_SYMBOLS}:$<${IS_MSVC}:/DEBUG:FULL>>
+
             $<$<NOT:${DEBUG_SYMBOLS}>:
                 $<${IS_GNU}:-s>
                 $<${IS_CLANG}:-s>
                 $<${IS_APPLECLANG}:-Wl,-S -Wl,-x -Wl,-dead_strip>
             >
     )
-
+    # gersemi: on
 endfunction()

cmake/emsdkHack.cmake

@@ -23,18 +23,18 @@ More information on cmake's `code injection`_
 
 Overwrite Shared Library Properties to allow shared libs to be generated.
 ]=======================================================================]
-if( EMSCRIPTEN )
+if(EMSCRIPTEN)
     set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS TRUE)
     set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-sSIDE_MODULE=1")
     set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "-sSIDE_MODULE=1")
     set(CMAKE_SHARED_LIBRARY_SUFFIX) # remove the suffix from the shared lib
-    set(CMAKE_STRIP FALSE)  # used by default in pybind11 on .so modules
+    set(CMAKE_STRIP FALSE) # used by default in pybind11 on .so modules
 
     # The Emscripten toolchain sets the default value for EMSCRIPTEN_SYSTEM_PROCESSOR to x86
     # and CMAKE_SYSTEM_PROCESSOR to this value. I don't want that.
-    set(CMAKE_SYSTEM_PROCESSOR "wasm32" )
+    set(CMAKE_SYSTEM_PROCESSOR "wasm32")
     # the above prevents the need for logic like:
     #if( ${CMAKE_SYSTEM_NAME} STREQUAL Emscripten )
     #    set( SYSTEM_ARCH wasm32 )
     #endif ()
-endif ()
+endif()

cmake/godotcpp.cmake

@@ -8,8 +8,8 @@ C compiler is specified, like in a toolchain, or from an IDE, then it will
 print a warning stating that the CMAKE_C_COMPILER compiler is unused.
 This if statement simply silences that warning.
 ]=======================================================================]
-if( CMAKE_C_COMPILER )
-endif ()
+if(CMAKE_C_COMPILER)
+endif()
 
 #[=======================================================================[.rst:
 Include Platform Files
@@ -23,125 +23,137 @@ project directive, it means that
   directive was
 
 ]=======================================================================]
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/GodotCPPModule.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/common_compiler_flags.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/android.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/ios.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/linux.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/macos.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/web.cmake)
-include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/windows.cmake)
-
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/GodotCPPModule.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/common_compiler_flags.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/android.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/ios.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/linux.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/macos.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/web.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/windows.cmake)
 
 # Detect number of processors
 include(ProcessorCount)
 ProcessorCount(PROC_MAX)
-message( "Auto-detected ${PROC_MAX} CPU cores available for build parallelism." )
+message("Auto-detected ${PROC_MAX} CPU cores available for build parallelism.")
 
 # List of known platforms
-set( PLATFORM_LIST linux macos windows android ios web )
+set(PLATFORM_LIST
+    linux
+    macos
+    windows
+    android
+    ios
+    web
+)
 
 # List of known architectures
-set( ARCH_LIST x86_32 x86_64 arm32 arm64 rv64 ppc32 ppc64 wasm32 )
+set(ARCH_LIST
+    x86_32
+    x86_64
+    arm32
+    arm64
+    rv64
+    ppc32
+    ppc64
+    wasm32
+)
 
 # Function to map processors to known architectures
-function( godot_arch_name OUTVAR )
-
+function(godot_arch_name OUTVAR)
     # Special case for macos universal builds that target both x86_64 and arm64
-    if( DEFINED CMAKE_OSX_ARCHITECTURES)
-        if( "x86_64" IN_LIST CMAKE_OSX_ARCHITECTURES AND "arm64" IN_LIST CMAKE_OSX_ARCHITECTURES)
-            set(${OUTVAR} "universal" PARENT_SCOPE )
+    if(DEFINED CMAKE_OSX_ARCHITECTURES)
+        if("x86_64" IN_LIST CMAKE_OSX_ARCHITECTURES AND "arm64" IN_LIST CMAKE_OSX_ARCHITECTURES)
+            set(${OUTVAR} "universal" PARENT_SCOPE)
             return()
         endif()
     endif()
 
     # Direct match early out.
-    string( TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" ARCH )
-    if( ARCH IN_LIST ARCH_LIST )
-        set( ${OUTVAR} "${ARCH}" PARENT_SCOPE)
+    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" ARCH)
+    if(ARCH IN_LIST ARCH_LIST)
+        set(${OUTVAR} "${ARCH}" PARENT_SCOPE)
         return()
     endif()
 
     # Known aliases
-    set( x86_64 "w64;amd64;x86-64" )
-    set( arm32  "armv7;armv7-a" )
-    set( arm64  "armv8;arm64v8;aarch64;armv8-a" )
-    set( rv64   "rv;riscv;riscv64" )
-    set( ppc32  "ppcle;ppc" )
-    set( ppc64  "ppc64le" )
-
-    if( ARCH IN_LIST x86_64  )
-        set(${OUTVAR} "x86_64" PARENT_SCOPE )
-
-    elseif( ARCH IN_LIST arm32 )
-        set(${OUTVAR} "arm32" PARENT_SCOPE )
-
-    elseif( ARCH IN_LIST arm64 )
-        set(${OUTVAR} "arm64" PARENT_SCOPE )
-
-    elseif( ARCH IN_LIST rv64 )
-        set(${OUTVAR} "rv64" PARENT_SCOPE )
-
-    elseif( ARCH IN_LIST ppc32 )
-        set(${OUTVAR} "ppc32" PARENT_SCOPE )
-
-    elseif( ARCH IN_LIST ppc64 )
-        set(${OUTVAR} "ppc64" PARENT_SCOPE )
-
-    elseif( ARCH MATCHES "86")
+    set(x86_64 "w64;amd64;x86-64")
+    set(arm32 "armv7;armv7-a")
+    set(arm64 "armv8;arm64v8;aarch64;armv8-a")
+    set(rv64 "rv;riscv;riscv64")
+    set(ppc32 "ppcle;ppc")
+    set(ppc64 "ppc64le")
+
+    if(ARCH IN_LIST x86_64)
+        set(${OUTVAR} "x86_64" PARENT_SCOPE)
+    elseif(ARCH IN_LIST arm32)
+        set(${OUTVAR} "arm32" PARENT_SCOPE)
+    elseif(ARCH IN_LIST arm64)
+        set(${OUTVAR} "arm64" PARENT_SCOPE)
+    elseif(ARCH IN_LIST rv64)
+        set(${OUTVAR} "rv64" PARENT_SCOPE)
+    elseif(ARCH IN_LIST ppc32)
+        set(${OUTVAR} "ppc32" PARENT_SCOPE)
+    elseif(ARCH IN_LIST ppc64)
+        set(${OUTVAR} "ppc64" PARENT_SCOPE)
+    elseif(ARCH MATCHES "86")
         # Catches x86, i386, i486, i586, i686, etc.
-        set(${OUTVAR} "x86_32" PARENT_SCOPE )
-
+        set(${OUTVAR} "x86_32" PARENT_SCOPE)
     else()
         # Default value is whatever the processor is.
-        set(${OUTVAR} ${CMAKE_SYSTEM_PROCESSOR} PARENT_SCOPE )
-    endif ()
+        set(${OUTVAR} ${CMAKE_SYSTEM_PROCESSOR} PARENT_SCOPE)
+    endif()
 endfunction()
 
 # Function to define all the options.
-function( godotcpp_options )
+function(godotcpp_options)
     #NOTE: platform is managed using toolchain files.
     #NOTE: arch is managed by using toolchain files.
     # Except for macos universal, which can be set by GODOTCPP_MACOS_UNIVERSAL=YES
 
     # Input from user for GDExtension interface header and the API JSON file
-    set( GODOTCPP_GDEXTENSION_DIR "gdextension" CACHE PATH
-            "Path to a custom directory containing GDExtension interface header and API JSON file ( /path/to/gdextension_dir )" )
-    set( GODOTCPP_CUSTOM_API_FILE "" CACHE FILEPATH
-            "Path to a custom GDExtension API JSON file (takes precedence over `GODOTCPP_GDEXTENSION_DIR`) ( /path/to/custom_api_file )")
+    set(GODOTCPP_GDEXTENSION_DIR
+        "gdextension"
+        CACHE PATH
+        "Path to a custom directory containing GDExtension interface header and API JSON file ( /path/to/gdextension_dir )"
+    )
+    set(GODOTCPP_CUSTOM_API_FILE
+        ""
+        CACHE FILEPATH
+        "Path to a custom GDExtension API JSON file (takes precedence over `GODOTCPP_GDEXTENSION_DIR`) ( /path/to/custom_api_file )"
+    )
 
     #TODO generate_bindings
 
-    option( GODOTCPP_GENERATE_TEMPLATE_GET_NODE
-            "Generate a template version of the Node class's get_node. (ON|OFF)" ON)
+    option(GODOTCPP_GENERATE_TEMPLATE_GET_NODE "Generate a template version of the Node class's get_node. (ON|OFF)" ON)
 
     #TODO build_library
 
-    set( GODOTCPP_PRECISION "single" CACHE STRING
-            "Set the floating-point precision level (single|double)")
+    set(GODOTCPP_PRECISION "single" CACHE STRING "Set the floating-point precision level (single|double)")
 
-    set( GODOTCPP_THREADS ON CACHE BOOL "Enable threading support" )
+    set(GODOTCPP_THREADS ON CACHE BOOL "Enable threading support")
 
     #TODO compiledb
     #TODO compiledb_file
 
-    set( GODOTCPP_BUILD_PROFILE "" CACHE PATH
-            "Path to a file containing a feature build profile" )
+    set(GODOTCPP_BUILD_PROFILE "" CACHE PATH "Path to a file containing a feature build profile")
 
-    set( GODOTCPP_USE_HOT_RELOAD "" CACHE BOOL
-            "Enable the extra accounting required to support hot reload. (ON|OFF)")
+    set(GODOTCPP_USE_HOT_RELOAD "" CACHE BOOL "Enable the extra accounting required to support hot reload. (ON|OFF)")
 
     # Disable exception handling. Godot doesn't use exceptions anywhere, and this
     # saves around 20% of binary size and very significant build time (GH-80513).
-    option( GODOTCPP_DISABLE_EXCEPTIONS "Force disabling exception handling code (ON|OFF)" ON )
+    option(GODOTCPP_DISABLE_EXCEPTIONS "Force disabling exception handling code (ON|OFF)" ON)
 
-    set( GODOTCPP_SYMBOL_VISIBILITY "hidden" CACHE STRING
-            "Symbols visibility on GNU platforms. Use 'auto' to apply the default value. (auto|visible|hidden)")
-    set_property( CACHE GODOTCPP_SYMBOL_VISIBILITY PROPERTY STRINGS "auto;visible;hidden" )
+    set(GODOTCPP_SYMBOL_VISIBILITY
+        "hidden"
+        CACHE STRING
+        "Symbols visibility on GNU platforms. Use 'auto' to apply the default value. (auto|visible|hidden)"
+    )
+    set_property(CACHE GODOTCPP_SYMBOL_VISIBILITY PROPERTY STRINGS "auto;visible;hidden")
 
     #TODO optimize
 
-    option( GODOTCPP_DEV_BUILD "Developer build with dev-only debugging code (DEV_ENABLED)" OFF )
+    option(GODOTCPP_DEV_BUILD "Developer build with dev-only debugging code (DEV_ENABLED)" OFF)
 
     #[[ debug_symbols
     Debug symbols are enabled by using the Debug or RelWithDebInfo build configurations.
@@ -156,11 +168,11 @@ function( godotcpp_options )
     ]]
 
     # FIXME These options are not present in SCons, and perhaps should be added there.
-    option( GODOTCPP_SYSTEM_HEADERS "Expose headers as SYSTEM." OFF )
-    option( GODOTCPP_WARNING_AS_ERROR "Treat warnings as errors" OFF )
+    option(GODOTCPP_SYSTEM_HEADERS "Expose headers as SYSTEM." OFF)
+    option(GODOTCPP_WARNING_AS_ERROR "Treat warnings as errors" OFF)
 
     # Enable Testing
-    option( GODOTCPP_ENABLE_TESTING "Enable the godot-cpp.test.<target> integration testing targets" OFF )
+    option(GODOTCPP_ENABLE_TESTING "Enable the godot-cpp.test.<target> integration testing targets" OFF)
 
     #[[ Target Platform Options ]]
     android_options()
@@ -172,7 +184,7 @@ function( godotcpp_options )
 endfunction()
 
 # Function to configure and generate the targets
-function( godotcpp_generate )
+function(godotcpp_generate)
     #[[ Multi-Threaded MSVC Compilation
     When using the MSVC compiler the build command -j <n> only specifies
     parallel jobs or targets, and not multi-threaded compilation To speed up
@@ -181,16 +193,18 @@ function( godotcpp_generate )
 
     MSVC is true when the compiler is some version of Microsoft Visual C++ or
     another compiler simulating the Visual C++ cl command-line syntax. ]]
-    if( MSVC )
-        math( EXPR PROC_N "(${PROC_MAX}-1) | (${X}-2)>>31 & 1" )
-        message( "Using ${PROC_N} cores for multi-threaded compilation.")
+    if(MSVC)
+        math(EXPR PROC_N "(${PROC_MAX}-1) | (${X}-2)>>31 & 1")
+        message("Using ${PROC_N} cores for multi-threaded compilation.")
         # TODO You can override it at configure time with ...." )
-    else ()
-        message( "Using ${CMAKE_BUILD_PARALLEL_LEVEL} cores, You can override"
-        " it at configure time by using -j <n> or --parallel <n> on the build"
-        " command.")
-        message( "  eg. cmake --build . -j 7  ...")
-    endif ()
+    else()
+        message(
+            "Using ${CMAKE_BUILD_PARALLEL_LEVEL} cores, You can override"
+            " it at configure time by using -j <n> or --parallel <n> on the build"
+            " command."
+        )
+        message("  eg. cmake --build . -j 7  ...")
+    endif()
 
     #[[ GODOTCPP_SYMBOL_VISIBLITY
     To match the SCons options, the allowed values are "auto", "visible", and "hidden"
@@ -200,132 +214,140 @@ function( godotcpp_generate )
     TODO: It is probably worth a pull request which changes both to use the compiler values
     .. _flag:https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#index-fvisibility
     ]]
-    if( ${GODOTCPP_SYMBOL_VISIBILITY} STREQUAL "auto" OR ${GODOTCPP_SYMBOL_VISIBILITY} STREQUAL "visible" )
-        set( GODOTCPP_SYMBOL_VISIBILITY "default" )
-    endif ()
+    if(${GODOTCPP_SYMBOL_VISIBILITY} STREQUAL "auto" OR ${GODOTCPP_SYMBOL_VISIBILITY} STREQUAL "visible")
+        set(GODOTCPP_SYMBOL_VISIBILITY "default")
+    endif()
 
     # Setup variable to optionally mark headers as SYSTEM
-    set( GODOTCPP_SYSTEM_HEADERS_ATTRIBUTE "")
-    if( GODOTCPP_SYSTEM_HEADERS)
-        set( GODOTCPP_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
-    endif ()
+    set(GODOTCPP_SYSTEM_HEADERS_ATTRIBUTE "")
+    if(GODOTCPP_SYSTEM_HEADERS)
+        set(GODOTCPP_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
+    endif()
 
     #[[ Configure Binding Variables ]]
     # Generate Binding Parameters (True|False)
-    set( USE_TEMPLATE_GET_NODE "False" )
-    if( GODOTCPP_GENERATE_TEMPLATE_GET_NODE )
-        set( USE_TEMPLATE_GET_NODE "True" )
+    set(USE_TEMPLATE_GET_NODE "False")
+    if(GODOTCPP_GENERATE_TEMPLATE_GET_NODE)
+        set(USE_TEMPLATE_GET_NODE "True")
     endif()
 
     # Bits (32|64)
-    math( EXPR BITS "${CMAKE_SIZEOF_VOID_P} * 8" ) # CMAKE_SIZEOF_VOID_P refers to target architecture.
+    math(EXPR BITS "${CMAKE_SIZEOF_VOID_P} * 8") # CMAKE_SIZEOF_VOID_P refers to target architecture.
 
     # API json File
-    set( GODOTCPP_GDEXTENSION_API_FILE "${GODOTCPP_GDEXTENSION_DIR}/extension_api.json")
-    if( GODOTCPP_CUSTOM_API_FILE )  # User-defined override.
-        set( GODOTCPP_GDEXTENSION_API_FILE "${GODOTCPP_CUSTOM_API_FILE}")
+    set(GODOTCPP_GDEXTENSION_API_FILE "${GODOTCPP_GDEXTENSION_DIR}/extension_api.json")
+    if(GODOTCPP_CUSTOM_API_FILE) # User-defined override.
+        set(GODOTCPP_GDEXTENSION_API_FILE "${GODOTCPP_CUSTOM_API_FILE}")
     endif()
 
     # Build Profile
-    if( GODOTCPP_BUILD_PROFILE )
-        message( STATUS "Using build profile to trim api file")
-        message(  "\tBUILD_PROFILE = '${GODOTCPP_BUILD_PROFILE}'")
-        message(  "\tAPI_SOURCE = '${GODOTCPP_GDEXTENSION_API_FILE}'")
+    if(GODOTCPP_BUILD_PROFILE)
+        message(STATUS "Using build profile to trim api file")
+        message("\tBUILD_PROFILE = '${GODOTCPP_BUILD_PROFILE}'")
+        message("\tAPI_SOURCE = '${GODOTCPP_GDEXTENSION_API_FILE}'")
         build_profile_generate_trimmed_api(
                 "${GODOTCPP_BUILD_PROFILE}"
                 "${GODOTCPP_GDEXTENSION_API_FILE}"
-                "${CMAKE_CURRENT_BINARY_DIR}/extension_api.json" )
-        set( GODOTCPP_GDEXTENSION_API_FILE "${CMAKE_CURRENT_BINARY_DIR}/extension_api.json" )
+                "${CMAKE_CURRENT_BINARY_DIR}/extension_api.json"
+        )
+        set(GODOTCPP_GDEXTENSION_API_FILE "${CMAKE_CURRENT_BINARY_DIR}/extension_api.json")
     endif()
 
-    message( STATUS "GODOTCPP_GDEXTENSION_API_FILE = '${GODOTCPP_GDEXTENSION_API_FILE}'")
+    message(STATUS "GODOTCPP_GDEXTENSION_API_FILE = '${GODOTCPP_GDEXTENSION_API_FILE}'")
 
     # generate the file list to use
     binding_generator_get_file_list( GENERATED_FILES_LIST
             "${GODOTCPP_GDEXTENSION_API_FILE}"
-            "${CMAKE_CURRENT_BINARY_DIR}" )
+            "${CMAKE_CURRENT_BINARY_DIR}"
+    )
 
     binding_generator_generate_bindings(
             "${GODOTCPP_GDEXTENSION_API_FILE}"
             "${USE_TEMPLATE_GET_NODE}"
             "${BITS}"
             "${GODOTCPP_PRECISION}"
-            "${CMAKE_CURRENT_BINARY_DIR}" )
+            "${CMAKE_CURRENT_BINARY_DIR}"
+    )
 
-    add_custom_target( godot-cpp.generate_bindings DEPENDS ${GENERATED_FILES_LIST} )
-    set_target_properties( godot-cpp.generate_bindings PROPERTIES FOLDER "godot-cpp" )
+    add_custom_target(godot-cpp.generate_bindings DEPENDS ${GENERATED_FILES_LIST})
+    set_target_properties(godot-cpp.generate_bindings PROPERTIES FOLDER "godot-cpp")
 
     ### Platform is derived from the toolchain target
     # See GeneratorExpressions PLATFORM_ID and CMAKE_SYSTEM_NAME
-    string( CONCAT SYSTEM_NAME
-            "$<$<PLATFORM_ID:Android>:android.${ANDROID_ABI}>"
-            "$<$<PLATFORM_ID:iOS>:ios>"
-            "$<$<PLATFORM_ID:Linux>:linux>"
-            "$<$<PLATFORM_ID:Darwin>:macos>"
-            "$<$<PLATFORM_ID:Emscripten>:web>"
-            "$<$<PLATFORM_ID:Windows>:windows>"
-            "$<$<PLATFORM_ID:Msys>:windows>"
+    string(
+        CONCAT
+        SYSTEM_NAME
+        "$<$<PLATFORM_ID:Android>:android.${ANDROID_ABI}>"
+        "$<$<PLATFORM_ID:iOS>:ios>"
+        "$<$<PLATFORM_ID:Linux>:linux>"
+        "$<$<PLATFORM_ID:Darwin>:macos>"
+        "$<$<PLATFORM_ID:Emscripten>:web>"
+        "$<$<PLATFORM_ID:Windows>:windows>"
+        "$<$<PLATFORM_ID:Msys>:windows>"
     )
 
     # Process CPU architecture argument.
     godot_arch_name( ARCH_NAME )
 
     # Transform options into generator expressions
-    set( HOT_RELOAD-UNSET "$<STREQUAL:${GODOTCPP_USE_HOT_RELOAD},>")
+    set(HOT_RELOAD-UNSET "$<STREQUAL:${GODOTCPP_USE_HOT_RELOAD},>")
 
-    set( DISABLE_EXCEPTIONS "$<BOOL:${GODOTCPP_DISABLE_EXCEPTIONS}>")
+    set(DISABLE_EXCEPTIONS "$<BOOL:${GODOTCPP_DISABLE_EXCEPTIONS}>")
 
-    set( THREADS_ENABLED "$<BOOL:${GODOTCPP_THREADS}>" )
+    set(THREADS_ENABLED "$<BOOL:${GODOTCPP_THREADS}>")
 
     # GODOTCPP_DEV_BUILD
-    set( RELEASE_TYPES "Release;MinSizeRel")
-    get_property( IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG )
-    if( IS_MULTI_CONFIG )
-        message( NOTICE "=> Default build type is Debug. For other build types add --config <type> to build command")
-    elseif( GODOTCPP_DEV_BUILD AND CMAKE_BUILD_TYPE IN_LIST RELEASE_TYPES )
-        message( WARNING "=> GODOTCPP_DEV_BUILD implies a Debug-like build but CMAKE_BUILD_TYPE is '${CMAKE_BUILD_TYPE}'")
-    endif ()
-    set( IS_DEV_BUILD "$<BOOL:${GODOTCPP_DEV_BUILD}>")
+    set(RELEASE_TYPES "Release;MinSizeRel")
+    get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+    if(IS_MULTI_CONFIG)
+        message(NOTICE "=> Default build type is Debug. For other build types add --config <type> to build command")
+    elseif(GODOTCPP_DEV_BUILD AND CMAKE_BUILD_TYPE IN_LIST RELEASE_TYPES)
+        message(
+            WARNING
+            "=> GODOTCPP_DEV_BUILD implies a Debug-like build but CMAKE_BUILD_TYPE is '${CMAKE_BUILD_TYPE}'"
+        )
+    endif()
+    set(IS_DEV_BUILD "$<BOOL:${GODOTCPP_DEV_BUILD}>")
 
     ### Define our godot-cpp library targets
-    foreach ( TARGET_ALIAS template_debug template_release editor )
-        set( TARGET_NAME "godot-cpp.${TARGET_ALIAS}" )
+    foreach(TARGET_ALIAS template_debug template_release editor)
+        set(TARGET_NAME "godot-cpp.${TARGET_ALIAS}")
 
         # Generator Expressions that rely on the target
-        set( DEBUG_FEATURES "$<NOT:$<STREQUAL:${TARGET_ALIAS},template_release>>" )
-        set( HOT_RELOAD "$<IF:${HOT_RELOAD-UNSET},${DEBUG_FEATURES},$<BOOL:${GODOTCPP_USE_HOT_RELOAD}>>" )
+        set(DEBUG_FEATURES "$<NOT:$<STREQUAL:${TARGET_ALIAS},template_release>>")
+        set(HOT_RELOAD "$<IF:${HOT_RELOAD-UNSET},${DEBUG_FEATURES},$<BOOL:${GODOTCPP_USE_HOT_RELOAD}>>")
 
         # Suffix
-        string( CONCAT GODOTCPP_SUFFIX
-                "$<1:.${SYSTEM_NAME}>"
-                "$<1:.${TARGET_ALIAS}>"
-                "$<${IS_DEV_BUILD}:.dev>"
-                "$<$<STREQUAL:${GODOTCPP_PRECISION},double>:.double>"
-                "$<1:.${ARCH_NAME}>"
-                # TODO IOS_SIMULATOR
-                "$<$<NOT:${THREADS_ENABLED}>:.nothreads>"
+        string(
+            CONCAT
+            GODOTCPP_SUFFIX
+            "$<1:.${SYSTEM_NAME}>"
+            "$<1:.${TARGET_ALIAS}>"
+            "$<${IS_DEV_BUILD}:.dev>"
+            "$<$<STREQUAL:${GODOTCPP_PRECISION},double>:.double>"
+            "$<1:.${ARCH_NAME}>"
+            # TODO IOS_SIMULATOR
+            "$<$<NOT:${THREADS_ENABLED}>:.nothreads>"
         )
 
         # the godot-cpp.* library targets
-        add_library( ${TARGET_NAME} STATIC EXCLUDE_FROM_ALL )
-        add_library( godot-cpp::${TARGET_ALIAS} ALIAS ${TARGET_NAME} )
+        add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL)
+        add_library(godot-cpp::${TARGET_ALIAS} ALIAS ${TARGET_NAME})
 
-        file( GLOB_RECURSE GODOTCPP_SOURCES LIST_DIRECTORIES NO CONFIGURE_DEPENDS src/*.cpp )
+        file(GLOB_RECURSE GODOTCPP_SOURCES LIST_DIRECTORIES NO CONFIGURE_DEPENDS src/*.cpp)
 
-        target_sources( ${TARGET_NAME}
-                PRIVATE
-                ${GODOTCPP_SOURCES}
-                ${GENERATED_FILES_LIST}
-        )
+        target_sources(${TARGET_NAME} PRIVATE ${GODOTCPP_SOURCES} ${GENERATED_FILES_LIST})
 
-        target_include_directories( ${TARGET_NAME} ${GODOTCPP_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
-                include
-                ${CMAKE_CURRENT_BINARY_DIR}/gen/include
-                ${GODOTCPP_GDEXTENSION_DIR}
+        target_include_directories(
+            ${TARGET_NAME}
+            ${GODOTCPP_SYSTEM_HEADERS_ATTRIBUTE}
+            PUBLIC include ${CMAKE_CURRENT_BINARY_DIR}/gen/include ${GODOTCPP_GDEXTENSION_DIR}
         )
 
-        set_target_properties( ${TARGET_NAME}
-                PROPERTIES
+        # gersemi: off
+        set_target_properties(
+            ${TARGET_NAME}
+            PROPERTIES
                 CXX_STANDARD 17
                 CXX_EXTENSIONS OFF
                 CXX_VISIBILITY_PRESET ${GODOTCPP_SYMBOL_VISIBILITY}
@@ -349,25 +371,24 @@ function( godotcpp_generate )
                 # Some IDE's respect this property to logically group targets
                 FOLDER "godot-cpp"
         )
+        # gersemi: on
 
-        if( CMAKE_SYSTEM_NAME STREQUAL Android )
+        if(CMAKE_SYSTEM_NAME STREQUAL Android)
             android_generate()
-        elseif ( CMAKE_SYSTEM_NAME STREQUAL iOS )
+        elseif(CMAKE_SYSTEM_NAME STREQUAL iOS)
             ios_generate()
-        elseif ( CMAKE_SYSTEM_NAME STREQUAL Linux )
+        elseif(CMAKE_SYSTEM_NAME STREQUAL Linux)
             linux_generate()
-        elseif ( CMAKE_SYSTEM_NAME STREQUAL Darwin )
+        elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
             macos_generate()
-        elseif ( CMAKE_SYSTEM_NAME STREQUAL Emscripten )
+        elseif(CMAKE_SYSTEM_NAME STREQUAL Emscripten)
             web_generate()
-        elseif ( CMAKE_SYSTEM_NAME STREQUAL Windows )
+        elseif(CMAKE_SYSTEM_NAME STREQUAL Windows)
             windows_generate()
-        endif ()
-
-    endforeach ()
+        endif()
+    endforeach()
 
     # Added for backwards compatibility with prior cmake solution so that builds dont immediately break
     # from a missing target.
-    add_library( godot::cpp ALIAS godot-cpp.template_debug )
-
+    add_library(godot::cpp ALIAS godot-cpp.template_debug)
 endfunction()

cmake/ios.cmake

@@ -11,11 +11,7 @@ function(ios_options)
 endfunction()
 
 function(ios_generate)
-    target_compile_definitions(${TARGET_NAME}
-            PUBLIC
-            IOS_ENABLED
-            UNIX_ENABLED
-    )
+    target_compile_definitions(${TARGET_NAME} PUBLIC IOS_ENABLED UNIX_ENABLED)
 
     common_compiler_flags()
 endfunction()

cmake/linux.cmake

@@ -6,16 +6,12 @@ This file contains functions for options and configuration for targeting the
 Linux platform
 
 ]=======================================================================]
-function( linux_options )
+function(linux_options)
     # Linux Options
 endfunction()
 
-function( linux_generate )
-    target_compile_definitions( ${TARGET_NAME}
-            PUBLIC
-            LINUX_ENABLED
-            UNIX_ENABLED
-    )
+function(linux_generate)
+    target_compile_definitions(${TARGET_NAME} PUBLIC LINUX_ENABLED UNIX_ENABLED)
 
     common_compiler_flags()
 endfunction()

cmake/macos.cmake

@@ -12,35 +12,27 @@ MacOS platform
 ]=======================================================================]
 
 # Find Requirements
-IF(APPLE)
-    set( CMAKE_OSX_SYSROOT $ENV{SDKROOT} )
-    find_library( COCOA_LIBRARY REQUIRED
+if(APPLE)
+    set(CMAKE_OSX_SYSROOT $ENV{SDKROOT})
+    find_library(
+        COCOA_LIBRARY
+        REQUIRED
         NAMES Cocoa
         PATHS ${CMAKE_OSX_SYSROOT}/System/Library
         PATH_SUFFIXES Frameworks
-        NO_DEFAULT_PATH)
-ENDIF (APPLE)
+        NO_DEFAULT_PATH
+    )
+endif(APPLE)
 
-function( macos_options )
+function(macos_options)
 endfunction()
 
-function( macos_generate )
+function(macos_generate)
+    target_compile_definitions(${TARGET_NAME} PUBLIC MACOS_ENABLED UNIX_ENABLED)
 
-    target_compile_definitions(${TARGET_NAME}
-            PUBLIC
-            MACOS_ENABLED
-            UNIX_ENABLED
-    )
+    target_link_options(${TARGET_NAME} PUBLIC -Wl,-undefined,dynamic_lookup)
 
-    target_link_options( ${TARGET_NAME}
-            PUBLIC
-            -Wl,-undefined,dynamic_lookup
-    )
-
-    target_link_libraries( ${TARGET_NAME}
-            INTERFACE
-            ${COCOA_LIBRARY}
-    )
+    target_link_libraries(${TARGET_NAME} INTERFACE ${COCOA_LIBRARY})
 
     common_compiler_flags()
 endfunction()

cmake/web.cmake

@@ -8,30 +8,32 @@ Web platform
 ]=======================================================================]
 
 # Emscripten requires this hack for use of the SHARED option
-set( CMAKE_PROJECT_godot-cpp_INCLUDE cmake/emsdkHack.cmake )
+set(CMAKE_PROJECT_godot-cpp_INCLUDE cmake/emsdkHack.cmake)
 
-function( web_options )
+function(web_options)
     # web options
 endfunction()
 
-
-function( web_generate )
-    target_compile_definitions(${TARGET_NAME}
-            PUBLIC
+function(web_generate)
+    target_compile_definitions(
+        ${TARGET_NAME}
+        PUBLIC #
             WEB_ENABLED
             UNIX_ENABLED
     )
 
-    target_compile_options( ${TARGET_NAME}
-            PUBLIC
+    target_compile_options(
+        ${TARGET_NAME}
+        PUBLIC #
             -sSIDE_MODULE
             -sSUPPORT_LONGJMP=wasm
             -fno-exceptions
             $<${THREADS_ENABLED}:-sUSE_PTHREADS=1>
     )
 
-    target_link_options( ${TARGET_NAME}
-            INTERFACE
+    target_link_options(
+        ${TARGET_NAME}
+        INTERFACE #
             -sWASM_BIGINT
             -sSUPPORT_LONGJMP=wasm
             -fvisibility=hidden

cmake/windows.cmake

@@ -53,40 +53,38 @@ documentation.
 .. _issues: https://github.com/godotengine/godot-cpp/issues/1699
 
 ]=======================================================================]
-function( windows_options )
-    option( GODOTCPP_USE_STATIC_CPP "Link MinGW/MSVC C++ runtime libraries statically" ON )
-    option( GODOTCPP_DEBUG_CRT "Compile with MSVC's debug CRT (/MDd)" OFF )
-
-    message( STATUS "If not already cached, setting CMAKE_MSVC_RUNTIME_LIBRARY.\n"
-            "\tFor more information please read godot-cpp/cmake/windows.cmake")
+function(windows_options)
+    option(GODOTCPP_USE_STATIC_CPP "Link MinGW/MSVC C++ runtime libraries statically" ON)
+    option(GODOTCPP_DEBUG_CRT "Compile with MSVC's debug CRT (/MDd)" OFF)
+
+    message(
+        STATUS
+        "If not already cached, setting CMAKE_MSVC_RUNTIME_LIBRARY.\n"
+        "\tFor more information please read godot-cpp/cmake/windows.cmake"
+    )
 
-    set( CMAKE_MSVC_RUNTIME_LIBRARY
-            "MultiThreaded$<IF:$<BOOL:${GODOTCPP_DEBUG_CRT}>,DebugDLL,$<$<NOT:$<BOOL:${GODOTCPP_USE_STATIC_CPP}>>:DLL>>"
-            CACHE STRING "Select the MSVC runtime library for use by compilers targeting the MSVC ABI.")
+    set(CMAKE_MSVC_RUNTIME_LIBRARY
+        "MultiThreaded$<IF:$<BOOL:${GODOTCPP_DEBUG_CRT}>,DebugDLL,$<$<NOT:$<BOOL:${GODOTCPP_USE_STATIC_CPP}>>:DLL>>"
+        CACHE STRING
+        "Select the MSVC runtime library for use by compilers targeting the MSVC ABI."
+    )
 endfunction()
 
-
 #[===========================[ Target Generation ]===========================]
-function( windows_generate )
-    set( STATIC_CPP "$<BOOL:${GODOTCPP_USE_STATIC_CPP}>")
+function(windows_generate)
+    set(STATIC_CPP "$<BOOL:${GODOTCPP_USE_STATIC_CPP}>")
 
-    set_target_properties( ${TARGET_NAME}
-            PROPERTIES
-            PDB_OUTPUT_DIRECTORY "$<1:${CMAKE_SOURCE_DIR}/bin>"
-    )
+    set_target_properties(${TARGET_NAME} PROPERTIES PDB_OUTPUT_DIRECTORY "$<1:${CMAKE_SOURCE_DIR}/bin>")
 
-    target_compile_definitions( ${TARGET_NAME}
-        PUBLIC
-            WINDOWS_ENABLED
-            $<${IS_MSVC}:
-                TYPED_METHOD_BIND
-                NOMINMAX
-            >
+    target_compile_definitions(
+        ${TARGET_NAME}
+        PUBLIC WINDOWS_ENABLED $<${IS_MSVC}: TYPED_METHOD_BIND NOMINMAX >
     )
 
-    target_link_options( ${TARGET_NAME}
-            PUBLIC
-
+    # gersemi: off
+    target_link_options(
+        ${TARGET_NAME}
+        PUBLIC
             $<${NOT_MSVC}:
                 -Wl,--no-undefined
                 $<${STATIC_CPP}:
@@ -98,6 +96,7 @@ function( windows_generate )
 
             $<${IS_CLANG}:-lstdc++>
     )
+    # gersemi: on
 
     common_compiler_flags()
 endfunction()

test/CMakeLists.txt

@@ -5,45 +5,40 @@ Integration Testing
 The Test target used to validate changes in the GitHub CI.
 ]=======================================================================]
 
-message( STATUS "Testing Integration targets are enabled.")
+message(STATUS "Testing Integration targets are enabled.")
 
 # Generate Doc Data
-file( GLOB_RECURSE DOC_XML
-    LIST_DIRECTORIES NO
-    CONFIGURE_DEPENDS
-    "${CMAKE_CURRENT_SOURCE_DIR}/doc_classes/*.xml" )
-
-foreach( TARGET_ALIAS template_debug template_release editor )
-    set( TARGET_NAME "godot-cpp.test.${TARGET_ALIAS}" )
-
-    add_library( ${TARGET_NAME} SHARED EXCLUDE_FROM_ALL )
-
-    target_sources( ${TARGET_NAME}
-            PRIVATE
-            src/example.cpp
-            src/example.h
-            src/register_types.cpp
-            src/register_types.h
-            src/tests.h
+file(GLOB_RECURSE DOC_XML LIST_DIRECTORIES NO CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/doc_classes/*.xml")
+
+foreach(TARGET_ALIAS template_debug template_release editor)
+    set(TARGET_NAME "godot-cpp.test.${TARGET_ALIAS}")
+
+    add_library(${TARGET_NAME} SHARED EXCLUDE_FROM_ALL)
+
+    target_sources(
+        ${TARGET_NAME}
+        PRIVATE src/example.cpp src/example.h src/register_types.cpp src/register_types.h src/tests.h
     )
 
     # conditionally add doc data to compile output
-    if( TARGET_ALIAS MATCHES "editor|template_debug" )
+    if(TARGET_ALIAS MATCHES "editor|template_debug")
         target_doc_sources( ${TARGET_NAME} ${DOC_XML} )
     endif()
 
-    set( OUTPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/project/bin/" )
+    set(OUTPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/project/bin/")
 
     # Link to godot-cpp target
-    set( LINK_TARGET "godot-cpp::${TARGET_ALIAS}" )
-    target_link_libraries( ${TARGET_NAME} PRIVATE ${LINK_TARGET} )
+    set(LINK_TARGET "godot-cpp::${TARGET_ALIAS}")
+    target_link_libraries(${TARGET_NAME} PRIVATE ${LINK_TARGET})
 
     ### Get useful properties from godot-cpp target
-    get_target_property( GODOTCPP_SUFFIX   ${LINK_TARGET} GODOTCPP_SUFFIX      )
-    get_target_property( OSX_ARCH       ${LINK_TARGET} OSX_ARCHITECTURES )
+    get_target_property(GODOTCPP_SUFFIX ${LINK_TARGET} GODOTCPP_SUFFIX)
+    get_target_property(OSX_ARCH ${LINK_TARGET} OSX_ARCHITECTURES)
 
-    set_target_properties( ${TARGET_NAME}
-            PROPERTIES
+    # gersemi: off
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES
             CXX_STANDARD 17
             CXX_EXTENSIONS OFF
             CXX_VISIBILITY_PRESET ${GODOTCPP_SYMBOL_VISIBILITY}
@@ -67,15 +62,16 @@ foreach( TARGET_ALIAS template_debug template_release editor )
             # Some IDE's respect this property to logically group targets
             FOLDER "godot-cpp"
     )
+    # gersemi: on
 
     # CMAKE_SYSTEM_NAME refers to the target system
-    if( CMAKE_SYSTEM_NAME STREQUAL Darwin )
-        set_target_properties( ${TARGET_NAME}
-                PROPERTIES
+    if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
+        set_target_properties(
+            ${TARGET_NAME}
+            PROPERTIES
                 SUFFIX ""
                 OUTPUT_DIR "${OUTPUT_DIR}/libgdexample.macos.${TARGET_ALIAS}.framework"
                 OSX_ARCHITECTURES "${OSX_ARCH}"
         )
     endif()
-
 endforeach()