ci: Add clang-tidy to CI

.clang-tidy

@@ -0,0 +1,18 @@
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+Checks: "-*,\
+google*,\
+readability-identifier-naming,\
+-google-readability-todo,\
+-google-readability-avoid-underscore-in-googletest-name,\
+-google-runtime-references,\
+"
+WarningsAsErrors: "*"
+HeaderFilterRegex: ".*"
+CheckOptions:
+  - { key: readability-identifier-naming.VariableCase,  value: lower_case }
+  - { key: readability-identifier-naming.GlobalConstantCase,  value: CamelCase }
+  - { key: readability-identifier-naming.GlobalConstantPrefix,  value: k }

.github/workflows/ci.yml

@@ -13,6 +13,23 @@ on:
             - main
 
 jobs:
+  clang_tidy:
+    runs-on:  ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [ ubuntu-22.04, windows-2022 ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - uses: ilammy/msvc-dev-cmd@v1
+      - uses: lukka/get-cmake@latest
+      - name: Configure
+        run: cmake -S. -B build -D VUL_CLANG_TIDY=ON -D VUL_WERROR=ON -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Release -D UPDATE_DEPS=ON -G "Ninja"
+      - name: Build
+        run: cmake --build build --verbose
+
   build_and_test:
     runs-on: ${{matrix.os}}
     strategy:

BUILD.md

@@ -42,8 +42,6 @@ cd build/
 ctest -C Debug --parallel 8 --output-on-failure
 ```
 
-## CMake
-
 ### Warnings as errors off by default!
 
 By default `VUL_WERROR` is `OFF`
@@ -55,3 +53,9 @@ System package managers, and language package managers have to build on multiple
 By defaulting to `ON` we cause issues for package managers since there is no standard way to disable warnings until CMake 3.24
 
 Add `-D VUL_WERROR=ON` to your workflow. Or use the `dev` preset shown below which will also enabling warnings as errors.
+
+### clang-tidy
+
+By default clang-tidy checking is disabled by default.
+
+To enable it set `VUL_CLANG_TIDY` to `ON`. clang-tidy is required to pass CI.

CMakeLists.txt

@@ -31,6 +31,15 @@ if (VUL_WERROR)
     endif()
 endif()
 
+option(VVL_CLANG_TIDY "Use clang-tidy")
+if (VUL_CLANG_TIDY)
+    find_program(CLANG_TIDY NAMES clang-tidy)
+    if(NOT CLANG_TIDY)
+        message(FATAL_ERROR "clang-tidy not found!")
+    endif()
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY}")
+endif()
+
 if(${CMAKE_CXX_COMPILER_ID} MATCHES "(GNU|Clang)")
     add_compile_options(
         -Wall

include/vulkan/utility/vul_dispatch_table.h

@@ -12,6 +12,8 @@
 
 #include <string.h>
 
+// NOLINTBEGIN(google-readability-casting)
+
 typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
 
 // Instance function pointer dispatch table
@@ -1573,3 +1575,4 @@ static inline void vulInitInstanceDispatchTable(VkInstance instance, VulInstance
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
 }
+// NOLINTEND(google-readability-casting)

scripts/generators/dispatch_table_generator.py

@@ -31,6 +31,8 @@ def generate(self):
 
 #include <string.h>
 
+// NOLINTBEGIN(google-readability-casting)
+
 typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
 ''')
         out.append('''
@@ -88,6 +90,8 @@ def generate(self):
             out.extend([f'#ifdef {command.protect}\n'] if command.protect else [])
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gipa(instance, "{command.name}");\n')
             out.extend([f'#endif  // {command.protect}\n'] if command.protect else [])
-        out.append('}')
+        out.append('}\n')
+
+        out.append("// NOLINTEND(google-readability-casting)")
 
         self.write("".join(out))

src/layer/layer_settings_manager.cpp

@@ -79,7 +79,7 @@ static inline bool IsHighIntegrity() {
         DWORD buffer_size;
         if (GetTokenInformation(process_token, TokenIntegrityLevel, mandatory_label_buffer, sizeof(mandatory_label_buffer),
                                 &buffer_size) != 0) {
-            const TOKEN_MANDATORY_LABEL *mandatory_label = (const TOKEN_MANDATORY_LABEL *)mandatory_label_buffer;
+            const TOKEN_MANDATORY_LABEL *mandatory_label = reinterpret_cast<const TOKEN_MANDATORY_LABEL *>(mandatory_label_buffer);
             const DWORD sub_authority_count = *GetSidSubAuthorityCount(mandatory_label->Label.Sid);
             const DWORD integrity_level = *GetSidSubAuthority(mandatory_label->Label.Sid, sub_authority_count - 1);
 
@@ -150,17 +150,17 @@ std::filesystem::path LayerSettings::FindSettingsFile() {
         LSTATUS err = RegOpenKeyEx(hives[hive_index], TEXT("Software\\Khronos\\Vulkan\\Settings"), 0, KEY_READ, &key);
         if (err == ERROR_SUCCESS) {
             TCHAR name[2048];
-            DWORD i = 0, name_size, type, pValues, value_size;
+            DWORD i = 0, name_size, type, p_values, value_size;
             while (ERROR_SUCCESS == RegEnumValue(key, i++, name, &(name_size = sizeof(name)), nullptr, &type,
-                                                 reinterpret_cast<LPBYTE>(&pValues), &(value_size = sizeof(pValues)))) {
+                                                 reinterpret_cast<LPBYTE>(&p_values), &(value_size = sizeof(p_values)))) {
                 // Check if the registry entry is a dword with a value of zero
-                if (type != REG_DWORD || pValues != 0) {
+                if (type != REG_DWORD || p_values != 0) {
                     continue;
                 }
 
                 // Check if this actually points to a file
-                DWORD fileAttrib = GetFileAttributes(name);
-                if ((fileAttrib == INVALID_FILE_ATTRIBUTES) || (fileAttrib & FILE_ATTRIBUTE_DIRECTORY)) {
+                DWORD file_attrib = GetFileAttributes(name);
+                if ((file_attrib == INVALID_FILE_ATTRIBUTES) || (file_attrib & FILE_ATTRIBUTE_DIRECTORY)) {
                     continue;
                 }
 

src/layer/layer_settings_util.cpp

@@ -41,10 +41,10 @@ std::string GetFileSettingName(const char *pLayerName, const char *pSettingName)
     assert(pLayerName != nullptr);
     assert(pSettingName != nullptr);
 
-    std::stringstream settingName;
-    settingName << vl::ToLower(TrimPrefix(pLayerName)) << "." << pSettingName;
+    std::stringstream setting_name;
+    setting_name << vl::ToLower(TrimPrefix(pLayerName)) << "." << pSettingName;
 
-    return settingName.str();
+    return setting_name.str();
 }
 
 std::string GetEnvSettingName(const char *layer_key, const char *setting_key, TrimMode trim_mode) {
@@ -145,15 +145,15 @@ std::string TrimVendor(const std::string &layer_key) {
 std::string ToLower(const std::string &s) {
     std::string result = s;
     for (auto &c : result) {
-        c = (char)std::tolower(c);
+        c = static_cast<char>(std::tolower(c));
     }
     return result;
 }
 
 std::string ToUpper(const std::string &s) {
     std::string result = s;
     for (auto &c : result) {
-        c = (char)std::toupper(c);
+        c = static_cast<char>(std::toupper(c));
     }
     return result;
 }
@@ -230,34 +230,34 @@ std::vector<VlFrameset> ToFrameSets(const std::string &s) {
 }
 
 bool IsFrameSets(const std::string &s) {
-    static const std::regex FRAME_REGEX("^([0-9]+([-][0-9]+){0,2})(,([0-9]+([-][0-9]+){0,2}))*$");
+    static const std::regex frame_regex("^([0-9]+([-][0-9]+){0,2})(,([0-9]+([-][0-9]+){0,2}))*$");
 
-    return std::regex_search(s, FRAME_REGEX);
+    return std::regex_search(s, frame_regex);
 }
 
 bool IsInteger(const std::string &s) {
-    static const std::regex FRAME_REGEX("^-?([0-9]*|0x[0-9|a-z|A-Z]*)$");
+    static const std::regex frame_regex("^-?([0-9]*|0x[0-9|a-z|A-Z]*)$");
 
-    return std::regex_search(s, FRAME_REGEX);
+    return std::regex_search(s, frame_regex);
 }
 
 bool IsFloat(const std::string &s) {
-    static const std::regex FRAME_REGEX("^-?[0-9]*([.][0-9]*f?)?$");
+    static const std::regex frame_regex("^-?[0-9]*([.][0-9]*f?)?$");
 
-    return std::regex_search(s, FRAME_REGEX);
+    return std::regex_search(s, frame_regex);
 }
 
 std::string FormatString(const char *message, ...) {
-    std::size_t const STRING_BUFFER(4096);
+    std::size_t const string_buffer(4096);
 
     assert(message != nullptr);
-    assert(strlen(message) >= 1 && strlen(message) < STRING_BUFFER);
+    assert(strlen(message) >= 1 && strlen(message) < string_buffer);
 
-    char buffer[STRING_BUFFER];
+    char buffer[string_buffer];
     va_list list;
 
     va_start(list, message);
-    vsnprintf(buffer, STRING_BUFFER, message, list);
+    vsnprintf(buffer, string_buffer, message, list);
     va_end(list);
 
     return buffer;

src/layer/vk_layer_settings.cpp

@@ -25,7 +25,7 @@ void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *
     assert(pSettingName != nullptr);
     assert(pValue != nullptr);
 
-    vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
+    vl::LayerSettings *layer_setting_set = reinterpret_cast<vl::LayerSettings *>(layerSettingSet);
 
     layer_setting_set->SetFileSetting(pSettingName, pValue);
 }
@@ -36,15 +36,15 @@ VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCr
     (void)pAllocator;
 
     vl::LayerSettings* layer_setting_set = new vl::LayerSettings(pLayerName, pCreateInfo, pAllocator, pCallback);
-    *pLayerSettingSet = (VlLayerSettingSet)layer_setting_set;
+    *pLayerSettingSet = reinterpret_cast<VlLayerSettingSet>(layer_setting_set);
 
     return VK_SUCCESS;
 }
 
 void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) {
     (void)pAllocator;
 
-    vl::LayerSettings *layer_setting_set = (vl::LayerSettings*)layerSettingSet;
+    vl::LayerSettings *layer_setting_set = reinterpret_cast<vl::LayerSettings *>(layerSettingSet);
     delete layer_setting_set;
 }
 
@@ -53,7 +53,7 @@ VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSetti
     assert(pSettingName);
     assert(!std::string(pSettingName).empty());
 
-    vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
+    vl::LayerSettings *layer_setting_set = reinterpret_cast<vl::LayerSettings *>(layerSettingSet);
 
     const bool has_env_setting = layer_setting_set->HasEnvSetting(pSettingName);
     const bool has_file_setting = layer_setting_set->HasFileSetting(pSettingName);
@@ -79,7 +79,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
         return VK_ERROR_UNKNOWN;
     }
 
-    vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
+    vl::LayerSettings *layer_setting_set = reinterpret_cast<vl::LayerSettings *>(layerSettingSet);
 
     // First: search in the environment variables
     const std::string &env_setting_list = layer_setting_set->GetEnvSetting(pSettingName);
@@ -589,9 +589,9 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                             break;
                         case VK_LAYER_SETTING_TYPE_UINT32_EXT:
                             for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
-                                const VlFrameset *asFramesets = static_cast<const VlFrameset *>(api_setting->pValues);
-                                settings_cache[i] = vl::FormatString("%d-%d-%d",
-                                    asFramesets[i].first, asFramesets[i].count, asFramesets[i].step);
+                                const VlFrameset *as_framesets = static_cast<const VlFrameset *>(api_setting->pValues);
+                                settings_cache[i] = vl::FormatString("%d-%d-%d", as_framesets[i].first, as_framesets[i].count,
+                                                                     as_framesets[i].step);
                             }
                             break;
                         default:

src/layer/vk_layer_settings_helper.cpp

@@ -23,9 +23,9 @@ static std::string Merge(const std::vector<std::string> &strings) {
 
 void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
     uint32_t value_count = 1;
-    VkBool32 pValues;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
-    settingValue = pValues == VK_TRUE;
+    VkBool32 p_values;
+    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &p_values);
+    settingValue = p_values == VK_TRUE;
 }
 
 void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {