Add clang-tidy checks on CI

.clang-tidy

@@ -0,0 +1 @@
+Checks: "clang-diagnostic-*,clang-analyzer-*"

.github/workflows/clang-tidy.yml

@@ -0,0 +1,49 @@
+name: Clang Tidy
+
+on:
+  schedule:
+    - cron: "0 1 * * *"
+  push:
+    branches: [main]
+    paths-ignore:
+      - CODEOWNERS
+      - requirements.txt
+      - LICENSE.txt
+      - .pre-commit-config.yaml
+      - '**/*.md'
+  pull_request:
+    branches: [main]
+    paths-ignore:
+      - CODEOWNERS
+      - requirements.txt
+      - LICENSE.txt
+      - .pre-commit-config.yaml
+      - '**/*.md'
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Debug
+
+jobs:
+  clang-tidy:
+    # The CMake configure and build commands are platform agnostic and should work equally
+    # well on Windows or Mac.  You can convert this to a matrix build if you need
+    # cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: seanmiddleditch/gha-setup-ninja@master
+
+      - name: Configure CMake # We need `compile_commands.json` to be generated.
+        run: cmake --preset Release
+
+      - name: clang-tidy
+        run: |
+            python scripts/reduce_compile_commands.py build/compile_commands.json > compile_commands.json
+            PROJECT_SOURCE_FILES="$(python scripts/reduce_compile_commands.py build/compile_commands.json \
+                --names-only \
+                --exclude_dirs build exploration compile_checks benchmarks)"
+            echo $PROJECT_SOURCE_FILES \
+              | xargs clang-tidy -warnings-as-errors="*" -p compile_commands.json

CMakeLists.txt

@@ -43,7 +43,16 @@ xyz_add_library(
 target_sources(indirect
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/indirect.h>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/indirect.cc>
+)
+
+add_library(indirect_cc OBJECT)
+target_sources(indirect_cc
+    PRIVATE
+        indirect.cc
+)
+target_link_libraries(indirect_cc
+    PRIVATE
+        indirect
 )
 
 xyz_add_library(
@@ -55,7 +64,6 @@ xyz_add_library(
 target_sources(indirect_cxx14
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/indirect_cxx14.h>
-    PRIVATE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/indirect_cxx14.cc>
 )
 
@@ -68,7 +76,6 @@ xyz_add_library(
 target_sources(indirect_cxx17
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/indirect_cxx14.h>
-    PRIVATE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/indirect_cxx14.cc>
 )
 
@@ -79,8 +86,16 @@ xyz_add_library(
 target_sources(polymorphic
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/polymorphic.h>
+)
+
+add_library(polymorphic_cc OBJECT)
+target_sources(polymorphic_cc
+    PRIVATE
+        polymorphic.cc
+)
+target_link_libraries(polymorphic_cc
     PRIVATE
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/polymorphic.cc>
+        polymorphic
 )
 
 xyz_add_library(
@@ -92,7 +107,6 @@ xyz_add_library(
 target_sources(polymorphic_cxx14
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/polymorphic_cxx14.h>
-    PRIVATE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/polymorphic_cxx14.cc>
 )
 
@@ -105,7 +119,6 @@ xyz_add_library(
 target_sources(polymorphic_cxx17
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/polymorphic_cxx14.h>
-    PRIVATE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/polymorphic_cxx14.cc>
 )
 

CMakePresets.json

@@ -17,7 +17,7 @@
       },
       {
         "name": "default",
-        "binaryDir": "${sourceDir}/build/${presetName}",
+        "binaryDir": "${sourceDir}/build",
         "cacheVariables": {
           "CMAKE_INSTALL_PREFIX": "${sourceDir}/install/${presetName}",
           "CMAKE_INTERPROCEDURAL_OPTIMIZATION": true

indirect_test.cc

@@ -188,7 +188,8 @@ TEST(IndirectTest, MovePreservesIndirectObjectAddress) {
   auto address = &*a;
   auto aa = std::move(a);
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   EXPECT_EQ(address, &*aa);
 }
 
@@ -204,7 +205,8 @@ TEST(IndirectTest, AllocatorExtendedMove) {
   auto address = &*a;
   xyz::indirect<int> aa(std::allocator_arg, a.get_allocator(), std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   EXPECT_EQ(address, &*aa);
 }
 
@@ -231,7 +233,8 @@ TEST(IndirectTest, MoveAssignment) {
   EXPECT_EQ(*a, 42);
   a = std::move(b);
 
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   EXPECT_EQ(*a, 101);
 }
 
@@ -252,7 +255,8 @@ TEST(IndirectTest, ConvertingAssignmentValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   a = 42;
   EXPECT_EQ(*a, 42);
 }
@@ -286,70 +290,86 @@ TEST(IndirectTest, CopyFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b(a);
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, MoveFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b(std::move(a));
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, AllocatorExtendedCopyFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b(std::allocator_arg, a.get_allocator(), a);
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, AllocatorExtendedMoveFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b(std::allocator_arg, a.get_allocator(), std::move(a));
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, AssignFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b;
   b = a;
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, MoveAssignFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b;
   b = std::move(a);
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, SwapFromValueless) {
   xyz::indirect<int> a;
   xyz::indirect<int> aa(std::move(a));
 
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   xyz::indirect<int> b;
-  EXPECT_TRUE(!b.valueless_after_move());
+  EXPECT_TRUE(
+      !b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 
   using std::swap;
   swap(a, b);
-  EXPECT_TRUE(!a.valueless_after_move());
-  EXPECT_TRUE(b.valueless_after_move());
+  EXPECT_TRUE(
+      !a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
+  EXPECT_TRUE(
+      b.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, ConstPropagation) {
@@ -390,7 +410,7 @@ TEST(IndirectTest, Hash) {
 auto make_valueless_indirect() {
   xyz::indirect<int> a;
   auto aa = std::move(a);
-  return a;
+  return a;  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, HashValueless) {
@@ -732,7 +752,8 @@ TEST(IndirectTest, CountAllocationsForAssignmentToMovedFromObject) {
         std::allocator_arg,
         xyz::TrackingAllocator<int>(&alloc_counter, &dealloc_counter),
         xyz::in_place_t{}, 404);
-    EXPECT_TRUE(a.valueless_after_move());
+    EXPECT_TRUE(
+        a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
     a = c;  // This will cause an allocation as a is valueless.
     EXPECT_EQ(alloc_counter, 4);
     EXPECT_EQ(dealloc_counter, 1);
@@ -961,7 +982,8 @@ TEST(IndirectTest, TaggedAllocatorsEqualMoveConstruct) {
   xyz::indirect<int, xyz::TaggedAllocator<int>> ii(std::allocator_arg, aa,
                                                    std::move(i));
 
-  EXPECT_TRUE(i.valueless_after_move());
+  EXPECT_TRUE(
+      i.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   EXPECT_EQ(*ii, -1);
 }
 
@@ -985,7 +1007,8 @@ TEST(IndirectTest, TaggedAllocatorsNotEqualMoveConstruct) {
   xyz::indirect<int, xyz::TaggedAllocator<int>> ii(std::allocator_arg, aa,
                                                    std::move(i));
 
-  EXPECT_FALSE(i.valueless_after_move());
+  EXPECT_FALSE(
+      i.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
   EXPECT_EQ(*ii, -1);
 }
 
@@ -1001,18 +1024,21 @@ TEST(IndirectTest, TaggedAllocatorsNotEqualMoveConstructFromValueless) {
                                                   xyz::in_place_t{}, -1);
 
   xyz::indirect<int, xyz::TaggedAllocator<int>> ii(std::move(i));
-  EXPECT_TRUE(i.valueless_after_move());
+  EXPECT_TRUE(
+      i.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 
   // Move construct from the now valueless i.
   xyz::indirect<int, xyz::TaggedAllocator<int>> iii(std::allocator_arg, aa,
                                                     std::move(i));
-  EXPECT_TRUE(iii.valueless_after_move());
+  EXPECT_TRUE(
+      iii.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 TEST(IndirectTest, SupportNonCopyableType) {
   xyz::indirect<xyz::NonCopyable> a;
   auto aa = std::move(a);
-  EXPECT_TRUE(a.valueless_after_move());
+  EXPECT_TRUE(
+      a.valueless_after_move());  // NOLINT(clang-analyzer-cplusplus.Move)
 }
 
 }  // namespace