clang-tidy

clang-tidy src/main.cpp -- -std=c++20 -I include/
# With compile_commands.json (preferred):
clang-tidy src/main.cpp

cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
# build/compile_commands.json is now available
# Symlink to project root for editors:
ln -s build/compile_commands.json compile_commands.json

# .clang-tidy
Checks: >
  clang-diagnostic-*,
  clang-analyzer-*,
  cppcoreguidelines-*,
  modernize-*,
  performance-*,
  readability-*,
  bugprone-*,
  -modernize-use-trailing-return-type,
  -readability-magic-numbers,
  -cppcoreguidelines-avoid-magic-numbers

WarningsAsErrors: ''
HeaderFilterRegex: '(src|include)/.*'
FormatStyle: file

# Single file
clang-tidy src/main.cpp

# Entire project (parallel)
run-clang-tidy -p build/ -j$(nproc)

# Apply automatic fixes
clang-tidy -fix src/main.cpp

# Apply fixes for entire project
run-clang-tidy -p build/ -fix -j$(nproc)

// bugprone-use-after-move
auto v = make_vector();
use(std::move(v));
use(v);  // WARNING: v was moved from

// bugprone-integer-division
double result = 1 / 2;  // WARNING: integer division (result = 0.0)

// bugprone-narrowing-conversions  
long long big = 1LL << 40;
int small = big;  // WARNING: narrowing conversion

// bugprone-branch-clone
if (a) { return 1; }
else   { return 1; }  // WARNING: both branches identical

// modernize-use-nullptr
int* p = NULL;     // WARNING: use nullptr
int* p = nullptr;  // FIXED

// modernize-use-override
struct Derived : Base {
    void foo();    // WARNING: missing override
    void foo() override; // FIXED
};

// modernize-use-emplace
v.push_back(MyType(arg1, arg2));  // WARNING
v.emplace_back(arg1, arg2);       // FIXED (avoids temporary)

// modernize-loop-convert
for (int i = 0; i < v.size(); ++i) {
    use(v[i]);  // WARNING: can be range-for
}
for (const auto& x : v) { use(x); }  // FIXED

// performance-unnecessary-copy-initialization
std::string s = getString();  // WARNING: unnecessary copy if func returns string
const auto& s = getString();  // or: auto s = getString(); (move)

// performance-for-range-copy
for (auto x : container) { use(x); }  // WARNING: copies each element
for (const auto& x : container) { ... }  // FIXED

// performance-move-const-arg
void f(std::string&& s);
std::string str = "hello";
f(std::move(str));  // OK
const std::string cstr = "hi";
f(std::move(cstr)); // WARNING: move on const has no effect

// cppcoreguidelines-owning-memory
void bad() {
    int* p = new int(42);  // WARNING: use smart pointer
    delete p;
}

// cppcoreguidelines-pro-bounds-array-to-pointer-decay
void bad(int arr[10]) { ... }  // WARNING: use std::span
void good(std::span<int, 10> arr) { ... }

// cppcoreguidelines-special-member-functions
struct MyClass {
    ~MyClass();          // WARNING: if you define destructor,
                         // define copy/move too (Rule of 5)
};

find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-17 clang-tidy-18)

if(CLANG_TIDY)
    set_target_properties(myapp PROPERTIES
        CXX_CLANG_TIDY "${CLANG_TIDY};--warnings-as-errors=*"
    )
endif()

add_custom_target(tidy
    COMMAND run-clang-tidy -p ${CMAKE_BINARY_DIR} -j$(nproc)
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    COMMENT "Running clang-tidy"
)

- name: Install clang-tidy
  run: sudo apt-get install -y clang-tidy

- name: Configure (with compile_commands)
  run: cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

- name: Run clang-tidy
  run: |
    run-clang-tidy -p build/ \
      -header-filter="$(pwd)/include/.*" \
      -warnings-as-errors="*"

// NOLINT — suppress for this line
int x = NULL;  // NOLINT(modernize-use-nullptr)

// NOLINTBEGIN / NOLINTEND — suppress for a block
// NOLINTBEGIN(cppcoreguidelines-owning-memory)
int* raw = new int(42);
delete raw;
// NOLINTEND(cppcoreguidelines-owning-memory)

Checks: >
  bugprone-*,
  modernize-use-nullptr,
  modernize-use-override,
  modernize-use-default-member-init,
  performance-unnecessary-copy-initialization,
  performance-for-range-copy,
  readability-const-return-type,
  readability-container-size-empty,
  -bugprone-easily-swappable-parameters

WarningsAsErrors: 'bugprone-*'

// BEFORE: pre-C++11 patterns flagged by modernize-*
class Widget {
    int value_;
public:
    Widget() : value_(0) {}          // modernize-use-default-member-init
    virtual void draw();             // modernize-use-override (in subclass)
};

std::vector<Widget*> widgets;
for (int i = 0; i < widgets.size(); ++i) {  // modernize-loop-convert
    widgets[i]->draw();
}

std::unique_ptr<Widget> w(new Widget());  // modernize-make-unique

// AFTER: what clang-tidy --fix produces
class Widget {
    int value_ = 0;                  // default member init
public:
    virtual void draw();
};

for (auto* w : widgets) {            // range-for
    w->draw();
}

auto w = std::make_unique<Widget>(); // make_unique

// bugprone-dangling-handle: common string_view trap
std::string_view sv = std::string("hello");  // temporary destroyed immediately
// sv is now dangling — clang-tidy warns here

// bugprone-suspicious-memset-usage
char buf[64];
memset(buf, 64, 0);   // WARNING: probably meant memset(buf, 0, 64)

// bugprone-unchecked-optional-access
std::optional<int> opt = getValue();
int x = *opt;         // WARNING: check has_value() first

// cppcoreguidelines-pro-type-cstyle-cast
int x = (int)someDouble;         // WARNING: use static_cast / narrow_cast
int x = static_cast<int>(someDouble); // OK

// cppcoreguidelines-pro-bounds-pointer-arithmetic
int arr[10];
int* p = arr + 5;     // WARNING: use std::span or at least std::array
*(p + 1) = 0;         // WARNING: prefer arr[6] or span indexing

// cppcoreguidelines-avoid-goto
again:
    if (!ready) goto again;  // WARNING: use loops

// cppcoreguidelines-no-malloc
int* p = (int*)malloc(sizeof(int) * 10);  // WARNING: use new or containers
free(p);                                   // WARNING: use delete

// cppcoreguidelines-pro-type-union-access
union { int i; float f; } u;
u.i = 1;
float bad = u.f;  // WARNING: undefined behaviour via type-punning

// readability-identifier-naming — enforce casing conventions (configured in .clang-tidy)
int MyVariable = 0;    // WARNING if snake_case is required

// readability-const-return-type — const on return type is useless for scalars
const int getValue() { return 42; }  // WARNING: const on value return is misleading

// readability-container-size-empty
if (v.size() == 0) { ... }  // WARNING: use v.empty()
if (v.size() != 0) { ... }  // WARNING: use !v.empty()

// readability-else-after-return
if (cond) {
    return x;
} else {           // WARNING: else is redundant after return
    return y;
}

// readability-simplify-boolean-expr
if (cond == true) { ... }   // WARNING: just use cond
return (x > 0) ? true : false;  // WARNING: just return x > 0

# Fix a single file in place
clang-tidy --fix src/main.cpp

# Fix the entire project in parallel
run-clang-tidy -p build/ -fix -j$(nproc)

# Fix even when there are compilation errors in the TU
clang-tidy --fix --fix-errors src/main.cpp

# Safe workflow: stage current state, apply fixes, review diff
git stash
clang-tidy --fix src/widget.cpp
git diff src/widget.cpp   # review what changed
git add src/widget.cpp
git stash drop

project/
├── .clang-tidy          ← project-wide defaults
├── src/
│   ├── .clang-tidy      ← overrides for src/ only
│   └── legacy/
│       └── .clang-tidy  ← legacy code gets lighter checks
└── tests/
    └── .clang-tidy      ← tests can disable some pedantic checks

# project/src/legacy/.clang-tidy
# Inherits project-root config, then disables checks that legacy code fails
InheritParentConfig: true
Checks: >
  -cppcoreguidelines-owning-memory,
  -modernize-*,
  -readability-identifier-naming

# project/tests/.clang-tidy
# Tests can use raw pointers and magic numbers freely
InheritParentConfig: true
Checks: >
  -cppcoreguidelines-owning-memory,
  -readability-magic-numbers,
  -cppcoreguidelines-avoid-magic-numbers

# .clang-tidy
HeaderFilterRegex: '(src|include)/.*'
# Ensures clang-tidy ignores headers from build/ and third-party/

// NOLINT — suppress ALL checks on this line
void* raw = malloc(1024);  // NOLINT

// NOLINT(check-name) — suppress only the named check
void* raw = malloc(1024);  // NOLINT(cppcoreguidelines-no-malloc)

// Multiple checks on one line
int x = (int)d;  // NOLINT(cppcoreguidelines-pro-type-cstyle-cast, bugprone-narrowing-conversions)

// NOLINTNEXTLINE — suppress on the FOLLOWING line (keeps the flagged line clean)
// NOLINTNEXTLINE(modernize-use-nullptr)
int* p = NULL;

// NOLINTBEGIN / NOLINTEND — suppress for an entire block
// NOLINTBEGIN(cppcoreguidelines-owning-memory, cppcoreguidelines-no-malloc)
void* arena = malloc(ARENA_SIZE);
// ... arena allocator internals ...
free(arena);
// NOLINTEND(cppcoreguidelines-owning-memory, cppcoreguidelines-no-malloc)

# .clang-tidy — exclude generated files by path pattern
HeaderFilterRegex: '^(?!.*(generated|proto|moc_)).*\.(h|hpp)$'

# generated/.clang-tidy
Checks: '-*'
InheritParentConfig: false

const std::string label = "status";

// WARNING: move has no effect — copies instead
process(std::move(label));

// Fix: either drop const so the move works, or pass by value/const-ref
process(label);                    // clear: passes by const-ref via overload
// or
std::string mutable_label = "status";
process(std::move(mutable_label)); // genuine move

// WARNING: getName() returns std::string by value;
// this copy-initialises 'name' unnecessarily
std::string name = obj.getName();

// OK options:
auto name = obj.getName();          // move-constructs (NRVO/move)
const auto& name = obj.getName();   // extends lifetime, no copy

// WARNING: flushes on every line — expensive in loops
for (auto& line : lines) {
    std::cout << line << std::endl;
}

// Fix: use '\n'; flush explicitly only when needed
for (auto& line : lines) {
    std::cout << line << '\n';
}
std::cout.flush(); // once, at the end if necessary

std::vector<BigObject> objects = loadObjects();

// WARNING: copies each BigObject on every iteration
for (auto obj : objects) {
    obj.process();
}

// Fix: const reference for read-only, reference for mutation
for (const auto& obj : objects) { obj.process(); }  // read-only
for (auto& obj : objects)        { obj.mutate(); }   // mutating

// WARNING: std::string copied into parameter, never moved from
void setName(std::string name) {
    name_ = name;  // another copy here
}

// Fix: take by value and move into storage (one move total)
void setName(std::string name) {
    name_ = std::move(name);
}
// Or if the function only reads: take by const reference
void printName(const std::string& name) { std::cout << name; }

# Analyse all files, 8 parallel workers
run-clang-tidy -p build/ -j8

# Restrict to project source (exclude third-party and generated)
run-clang-tidy -p build/ \
  -header-filter="$(pwd)/include/.*" \
  -j$(nproc)

# Treat all warnings as errors (exit non-zero if any finding)
run-clang-tidy -p build/ \
  -warnings-as-errors="*" \
  -j$(nproc)

# .github/workflows/static-analysis.yml
name: Static Analysis

on: [pull_request]

jobs:
  clang-tidy:
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y clang-tidy cmake ninja-build

      - name: Configure (export compile_commands)
        run: |
          cmake -B build -G Ninja \
            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
            -DCMAKE_BUILD_TYPE=Debug

      - name: Run clang-tidy
        run: |
          run-clang-tidy -p build/ \
            -header-filter="$(pwd)/include/.*" \
            -warnings-as-errors="bugprone-*,performance-*" \
            -j$(nproc)
        # Non-zero exit fails the job and blocks merge

# Report findings in your own headers but not system or third-party headers
clang-tidy src/widget.cpp \
  --header-filter="$(pwd)/(src|include)/.*"

# Exclude a vendored directory
clang-tidy src/widget.cpp \
  --header-filter="^(?!.*/vendor/).*"

# CMakeLists.txt — enable for all targets in this directory and below
find_program(CLANG_TIDY_EXE
    NAMES clang-tidy clang-tidy-18 clang-tidy-17
    DOC "Path to clang-tidy executable"
)

if(CLANG_TIDY_EXE)
    set(CMAKE_CXX_CLANG_TIDY
        "${CLANG_TIDY_EXE}"
        "--warnings-as-errors=bugprone-*"
        "--header-filter=${CMAKE_SOURCE_DIR}/(src|include)/.*"
    )
    message(STATUS "clang-tidy enabled: ${CLANG_TIDY_EXE}")
endif()

# Enable clang-tidy only for the main library, not for vendored code
find_program(CLANG_TIDY_EXE NAMES clang-tidy clang-tidy-18 clang-tidy-17)

if(CLANG_TIDY_EXE)
    set_target_properties(mylib PROPERTIES
        CXX_CLANG_TIDY
        "${CLANG_TIDY_EXE};-checks=bugprone-*,modernize-*,performance-*;--warnings-as-errors=*"
    )
endif()

# Legacy target: no clang-tidy
add_library(legacy_vendor STATIC vendor/old_lib.cpp)
# CXX_CLANG_TIDY not set — clang-tidy skipped for this target

option(ENABLE_CLANG_TIDY "Run clang-tidy during build" OFF)

if(ENABLE_CLANG_TIDY)
    find_program(CLANG_TIDY_EXE NAMES clang-tidy clang-tidy-18)
    if(NOT CLANG_TIDY_EXE)
        message(FATAL_ERROR "ENABLE_CLANG_TIDY=ON but clang-tidy not found")
    endif()
    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE}")
endif()

# Developer build (fast, no analysis)
cmake -B build -DENABLE_CLANG_TIDY=OFF

# CI build (full analysis)
cmake -B build -DENABLE_CLANG_TIDY=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

# Add a custom target instead of hooking into the build
add_custom_target(tidy
    COMMAND run-clang-tidy
        -p ${CMAKE_BINARY_DIR}
        -header-filter="${CMAKE_SOURCE_DIR}/(src|include)/.*"
        -j$$(nproc)
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    COMMENT "Running clang-tidy static analysis"
    VERBATIM
)

cmake --build build          # fast build, no analysis
cmake --build build -t tidy  # run analysis on demand