Jorijn van der Graaf
d55657b7ce
The rule was 125 lines: four std::regex, a hand-rolled {/} scope stack, a
cumulative paren-depth counter so a wrapped parameter list would not look like
a declaration, a 40-entry keyword denylist, and a "function-shaped line" guess
whose own comment conceded it was heuristic. Storage class came from
lineStr.contains("static "). It is now ~55 lines that ask clang what kind of
declaration each thing is and what encloses it.
The three regressions the old version carried special cases for — a call with
an inline lambda argument, a bare statement call, a one-liner method — need no
handling at all, because a call is not a declaration. Their tests pass
unchanged.
On this repository the exact version found 42 violations the heuristic had
never been able to see, all real:
- 37 members of the libclang function-pointer table added two commits ago
were PascalCase. The old varDecl regex could not match a declaration whose
type is decltype(&f), so they were silently skipped. Renamed to camelCase,
which mirrors clang_createIndex -> createIndex more closely anyway.
- Crafter.Build-Shader.cpp had a snake_case local, file_name_list, invisible
to the heuristic for the same reason (it declares a const char* array).
- Four extern "C" declarations of libc functions in tests were reported as
badly-named functions. Those are named by the C library, so C language
linkage is now an exemption — the same principled test no-char-pointer
uses, rather than another denylist entry.
New tests cover what the line-based version structurally could not reach: a
signature wrapped over several lines, `static` on its own line above the
declaration it applies to, and a member versus a local inside a method.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
828 lines
42 KiB
C++
828 lines
42 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
#pragma once
|
|
|
|
// This repo's house-style lint rules. Deliberately project-local — the rule
|
|
// set is NOT part of the crafter-build library, so downstream consumers are
|
|
// never nudged toward one team's style. Include from project.cpp AFTER
|
|
// `import std;` and `import Crafter.Build;` (the header uses both and has no
|
|
// includes of its own), then call AddProjectLintRules(cfg).
|
|
//
|
|
// Report-only rules are registered first so their file:line numbers always
|
|
// match the on-disk file; transforms run last because each one sees the
|
|
// previous transform's output, which can shift line numbers.
|
|
//
|
|
// All detection runs on ctx.CommentStripped() — comments and string/char
|
|
// literal bodies are blanked to spaces with newlines preserved, so byte
|
|
// offsets and line numbers in the stripped text are valid in ctx.content.
|
|
// Transforms use that property directly: find in stripped, edit in content.
|
|
|
|
namespace ProjectLint {
|
|
|
|
inline bool IsCppFile(const Crafter::LintContext& ctx) {
|
|
std::string ext = ctx.file.extension().string();
|
|
return ext == ".cpp" || ext == ".cppm" || ext == ".h";
|
|
}
|
|
|
|
inline std::vector<std::string_view> Lines(std::string_view text) {
|
|
std::vector<std::string_view> lines;
|
|
std::size_t start = 0;
|
|
while (start <= text.size()) {
|
|
std::size_t end = text.find('\n', start);
|
|
if (end == std::string_view::npos) {
|
|
if (start < text.size()) lines.push_back(text.substr(start));
|
|
break;
|
|
}
|
|
lines.push_back(text.substr(start, end - start));
|
|
start = end + 1;
|
|
}
|
|
return lines;
|
|
}
|
|
|
|
inline std::string_view Trim(std::string_view s) {
|
|
while (!s.empty() && (s.front() == ' ' || s.front() == '\t' || s.front() == '\r')) s.remove_prefix(1);
|
|
while (!s.empty() && (s.back() == ' ' || s.back() == '\t' || s.back() == '\r')) s.remove_suffix(1);
|
|
return s;
|
|
}
|
|
|
|
inline bool IsWordChar(char c) {
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
|
|
}
|
|
|
|
// Net '(' minus ')' on one stripped line.
|
|
inline std::int64_t ParenDelta(std::string_view s) {
|
|
std::int64_t d = 0;
|
|
for (char c : s) {
|
|
if (c == '(') ++d;
|
|
if (c == ')') --d;
|
|
}
|
|
return d;
|
|
}
|
|
|
|
inline bool IsPascalCase(std::string_view name) {
|
|
return !name.empty() && name[0] >= 'A' && name[0] <= 'Z' && !name.contains('_');
|
|
}
|
|
|
|
inline bool IsCamelCase(std::string_view name) {
|
|
// One trailing underscore is the member-shadowing-a-keyword convention
|
|
// (requires_, label_) — allowed.
|
|
if (name.ends_with('_')) name.remove_suffix(1);
|
|
return !name.empty() && ((name[0] >= 'a' && name[0] <= 'z') || name[0] == '_') && name.find('_', 1) == std::string_view::npos;
|
|
}
|
|
|
|
// True for a pointer to char, as clang spells a type: "char *",
|
|
// "const char *", "char **". Deliberately not signed/unsigned char, which are
|
|
// byte buffers rather than text and were never the target.
|
|
inline bool IsCharPointer(std::string_view type) {
|
|
std::size_t star = type.find('*');
|
|
if (star == std::string_view::npos) return false;
|
|
std::string_view base = Trim(type.substr(0, star));
|
|
if (base.starts_with("const ")) base.remove_prefix(6);
|
|
if (base.starts_with("volatile ")) base.remove_prefix(9);
|
|
return base == "char";
|
|
}
|
|
|
|
inline void AddProjectLintRules(Crafter::Configuration& cfg) {
|
|
using Crafter::LintContext;
|
|
|
|
// ---------------- report-only rules ----------------
|
|
|
|
// License header: SPDX identifier on line 1, copyright on line 2, blank
|
|
// line 3.
|
|
cfg.AddLintRule("spdx-header", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
if (!ctx.Line(1).starts_with("// SPDX-License-Identifier:")) {
|
|
ctx.Report(1, "first line must be // SPDX-License-Identifier: ...");
|
|
}
|
|
if (!ctx.Line(2).starts_with("// SPDX-FileCopyrightText:")) {
|
|
ctx.Report(2, "second line must be // SPDX-FileCopyrightText: ...");
|
|
}
|
|
if (ctx.lines.size() >= 3 && !Trim(ctx.Line(3)).empty()) {
|
|
ctx.Report(3, "third line must be blank (separates the license header)");
|
|
}
|
|
});
|
|
|
|
cfg.AddLintRule("no-tabs", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
for (std::size_t n = 1; n <= ctx.lines.size(); ++n) {
|
|
if (ctx.Line(n).contains('\t')) ctx.Report(n, "tab character (use spaces)");
|
|
}
|
|
});
|
|
|
|
// Naming: types and functions PascalCase, variables camelCase, with
|
|
// statics, namespace-scope globals and constexpr constants PascalCase.
|
|
//
|
|
// Reads the AST. The previous version needed four std::regex, a hand-rolled
|
|
// {/} scope stack, a cumulative paren-depth counter to avoid mistaking a
|
|
// wrapped parameter list for a declaration, a keyword denylist, and a
|
|
// "function-shaped line" guess whose own comment conceded it was heuristic.
|
|
// All of it existed to answer two questions clang answers directly: what
|
|
// kind of declaration is this, and what encloses it.
|
|
cfg.AddAstLintRule("naming", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
using Kind = Crafter::LintDeclKind;
|
|
std::span<const Crafter::LintDecl> decls = ctx.Decls();
|
|
for (const Crafter::LintDecl& decl : decls) {
|
|
if (decl.name.empty()) continue; // anonymous namespace, unnamed struct
|
|
// A declaration with C language linkage is named by the C library
|
|
// it mirrors — `extern "C" int setenv(...)` is not ours to rename.
|
|
if (decl.isExternC) continue;
|
|
// Namespace scope is now a lookup rather than a brace count, and it
|
|
// is exact for a local declared inside a function body.
|
|
bool atNamespaceScope = decl.parent == Crafter::LintNoParent
|
|
|| decls[decl.parent].kind == Kind::Namespace;
|
|
switch (decl.kind) {
|
|
case Kind::Class:
|
|
case Kind::Struct:
|
|
case Kind::Union:
|
|
case Kind::Enum:
|
|
if (!IsPascalCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("type '{}' should be PascalCase", decl.name));
|
|
}
|
|
break;
|
|
case Kind::TypeAlias:
|
|
if (!IsPascalCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("type alias '{}' should be PascalCase", decl.name));
|
|
}
|
|
break;
|
|
case Kind::Function:
|
|
case Kind::Method:
|
|
// main is spelled by the language; operators by their
|
|
// symbol. Constructors and destructors take their type's
|
|
// name and are separate kinds, so they never arrive here.
|
|
if (decl.name == "main" || decl.name.starts_with("operator")) break;
|
|
if (!IsPascalCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("function '{}' should be PascalCase", decl.name));
|
|
}
|
|
break;
|
|
case Kind::Variable:
|
|
// constexpr variables are compile-time constants and take
|
|
// constant naming, like statics and globals.
|
|
if (decl.isStatic || decl.isConstexpr || atNamespaceScope) {
|
|
if (!IsPascalCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("{} '{}' should be PascalCase",
|
|
decl.isStatic ? "static variable"
|
|
: decl.isConstexpr ? "constexpr constant"
|
|
: "global variable", decl.name));
|
|
}
|
|
} else if (!IsCamelCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("variable '{}' should be camelCase", decl.name));
|
|
}
|
|
break;
|
|
case Kind::Field:
|
|
if (decl.isStatic || decl.isConstexpr) {
|
|
if (!IsPascalCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("static member '{}' should be PascalCase", decl.name));
|
|
}
|
|
} else if (!IsCamelCase(decl.name)) {
|
|
ctx.Report(decl.line, std::format("member '{}' should be camelCase", decl.name));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
cfg.AddLintRule("enum-class", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::vector<std::string_view> lines = Lines(ctx.CommentStripped());
|
|
static const std::regex plainEnum(R"(\benum\s+(?!class\b|struct\b)[A-Za-z_])");
|
|
for (std::size_t i = 0; i < lines.size(); ++i) {
|
|
std::string lineStr(lines[i]);
|
|
if (std::regex_search(lineStr, plainEnum)) {
|
|
ctx.Report(i + 1, "use enum class instead of plain enum");
|
|
}
|
|
}
|
|
});
|
|
|
|
cfg.AddLintRule("no-iostream-print", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::vector<std::string_view> lines = Lines(ctx.CommentStripped());
|
|
for (std::size_t i = 0; i < lines.size(); ++i) {
|
|
if (lines[i].contains("std::cout")) {
|
|
ctx.Report(i + 1, "use std::println instead of std::cout");
|
|
} else if (lines[i].contains("std::cerr") && lines[i].contains("<<")) {
|
|
ctx.Report(i + 1, "use std::println(std::cerr, ...) instead of streaming to std::cerr");
|
|
}
|
|
}
|
|
});
|
|
|
|
// Prefer std::string / std::string_view over char* in our own declarations.
|
|
//
|
|
// Reads the AST rather than the text, which retires the substring denylist
|
|
// this rule used to carry (argv, getenv, setenv, dlerror, c_str, .data(,
|
|
// reinterpret_cast, extern "). Every entry was a patch for one interop
|
|
// site, the list could only grow, and it disabled the rule for a whole LINE
|
|
// whenever one appeared. The question is now asked directly: whose header
|
|
// dictates this spelling? A declaration with C language linkage, or one
|
|
// that binds to an entity declared outside the project, is somebody else's
|
|
// API and keeps its spelling.
|
|
//
|
|
// Only declarations are considered. A char* inside a cast or an expression
|
|
// is not an interface, and reinterpret_cast<char*> for binary IO — the case
|
|
// the denylist existed to permit — is no longer a finding to suppress.
|
|
cfg.AddAstLintRule("no-char-pointer", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::span<const Crafter::LintDecl> decls = ctx.Decls();
|
|
for (const Crafter::LintDecl& decl : decls) {
|
|
// main's signature is fixed by the language, so its argv is no more
|
|
// ours to modernise than a C API's is.
|
|
if (decl.parent != Crafter::LintNoParent && decls[decl.parent].name == "main") continue;
|
|
if (decl.kind == Crafter::LintDeclKind::Function && decl.name == "main") continue;
|
|
switch (decl.kind) {
|
|
case Crafter::LintDeclKind::Variable:
|
|
case Crafter::LintDeclKind::Parameter:
|
|
case Crafter::LintDeclKind::Field:
|
|
case Crafter::LintDeclKind::TypeAlias:
|
|
case Crafter::LintDeclKind::Function:
|
|
case Crafter::LintDeclKind::Method:
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
if (decl.isExternC || decl.isForeignApi) continue;
|
|
if (!IsCharPointer(decl.type)) continue;
|
|
ctx.Report(decl.line, std::format("prefer std::string / std::string_view over char* ('{}' is '{}')", decl.name, decl.type));
|
|
}
|
|
});
|
|
|
|
// String building via `+` with a literal operand → std::format. Plain
|
|
// `a += b` accumulation (builder pattern) stays legal. Single-line chains
|
|
// of simple operands (identifier / member / call chains, parenthesized
|
|
// groups, literals) are REWRITTEN automatically; anything the operand
|
|
// scanner can't prove safe — raw-string lines, ternaries, mixed
|
|
// operators, multi-line expressions — is reported for a human instead.
|
|
cfg.AddLintRule("format-concat", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
const std::string& code = ctx.CommentStripped();
|
|
std::vector<std::string_view> stripped = Lines(code);
|
|
|
|
// Walk one operand leftwards from `from` (exclusive). Returns the
|
|
// operand's begin, or npos when the shape isn't a simple postfix
|
|
// chain (then the whole chain bails to a report).
|
|
auto operandLeft = [](std::string_view s, std::size_t from) -> std::size_t {
|
|
std::size_t i = from;
|
|
while (i > 0 && (s[i - 1] == ' ' || s[i - 1] == '\t')) --i;
|
|
bool any = false;
|
|
for (;;) {
|
|
if (i == 0) break;
|
|
char c = s[i - 1];
|
|
if (c == ')' || c == ']') {
|
|
char open = c == ')' ? '(' : '[';
|
|
std::size_t depth = 0;
|
|
do {
|
|
--i;
|
|
if (s[i] == c) ++depth;
|
|
if (s[i] == open) --depth;
|
|
if (depth == 0) break;
|
|
} while (i > 0);
|
|
if (depth != 0) return std::string_view::npos;
|
|
any = true;
|
|
// A group directly preceded by an identifier (or another
|
|
// group) is a call/index postfix — keep consuming the
|
|
// callee: `path.string()` is ONE operand, not `()`.
|
|
if (i > 0 && (IsWordChar(s[i - 1]) || s[i - 1] == ')' || s[i - 1] == ']')) continue;
|
|
} else if (c == '"') {
|
|
--i; // closing quote; interior is blanked, find the opener
|
|
while (i > 0 && s[i - 1] != '"') --i;
|
|
if (i == 0) return std::string_view::npos;
|
|
--i;
|
|
any = true;
|
|
} else if (IsWordChar(c)) {
|
|
while (i > 0 && IsWordChar(s[i - 1])) --i;
|
|
any = true;
|
|
} else if (c == '.' && any) {
|
|
--i;
|
|
continue;
|
|
} else if (c == ':' && i > 1 && s[i - 2] == ':' && any) {
|
|
i -= 2;
|
|
continue;
|
|
} else if (c == '>' && i > 1 && s[i - 2] == '-' && any) {
|
|
i -= 2;
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
// After a primary, only connectors continue the operand.
|
|
if (i > 0 && (s[i - 1] == '.' || (s[i - 1] == ':' && i > 1 && s[i - 2] == ':')
|
|
|| (s[i - 1] == '>' && i > 1 && s[i - 2] == '-'))) continue;
|
|
break;
|
|
}
|
|
if (!any) return std::string_view::npos;
|
|
// A unary operator, ternary, or other-precedence operator in
|
|
// front means expression structure we don't reason about — bail.
|
|
std::size_t b = i;
|
|
while (b > 0 && (s[b - 1] == ' ' || s[b - 1] == '\t')) --b;
|
|
if (b > 0 && std::string_view("!*&~-?:<>/%^|").contains(s[b - 1])) return std::string_view::npos;
|
|
return i;
|
|
};
|
|
|
|
// Walk one operand rightwards from `from` (inclusive). Returns one
|
|
// past the operand's end, or npos on bail.
|
|
auto operandRight = [](std::string_view s, std::size_t from) -> std::size_t {
|
|
std::size_t i = from;
|
|
while (i < s.size() && (s[i] == ' ' || s[i] == '\t')) ++i;
|
|
bool any = false;
|
|
for (;;) {
|
|
if (i >= s.size()) break;
|
|
char c = s[i];
|
|
if (c == '(' || c == '[') {
|
|
char close = c == '(' ? ')' : ']';
|
|
std::size_t depth = 0;
|
|
while (i < s.size()) {
|
|
if (s[i] == c) ++depth;
|
|
if (s[i] == close && --depth == 0) { ++i; break; }
|
|
++i;
|
|
}
|
|
if (depth != 0) return std::string_view::npos;
|
|
any = true;
|
|
} else if (c == '"') {
|
|
++i;
|
|
while (i < s.size() && s[i] != '"') ++i;
|
|
if (i >= s.size()) return std::string_view::npos;
|
|
++i;
|
|
any = true;
|
|
} else if (IsWordChar(c)) {
|
|
while (i < s.size() && IsWordChar(s[i])) ++i;
|
|
any = true;
|
|
} else if (any && c == '.') {
|
|
++i;
|
|
continue;
|
|
} else if (any && c == ':' && i + 1 < s.size() && s[i + 1] == ':') {
|
|
i += 2;
|
|
continue;
|
|
} else if (any && c == '-' && i + 1 < s.size() && s[i + 1] == '>') {
|
|
i += 2;
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
if (i < s.size() && (s[i] == '(' || s[i] == '[' || s[i] == '.'
|
|
|| (s[i] == ':' && i + 1 < s.size() && s[i + 1] == ':')
|
|
|| (s[i] == '-' && i + 1 < s.size() && s[i + 1] == '>'))) continue;
|
|
break;
|
|
}
|
|
return any ? i : std::string_view::npos;
|
|
};
|
|
|
|
struct Edit { std::size_t begin; std::size_t end; std::string replacement; };
|
|
std::vector<Edit> edits; // offsets into ctx.content
|
|
std::size_t lineStart = 0;
|
|
for (std::size_t li = 0; li < stripped.size(); ++li) {
|
|
std::string_view line = stripped[li];
|
|
std::size_t lineOff = lineStart;
|
|
lineStart += line.size() + 1;
|
|
std::string_view trimmed = Trim(line);
|
|
if (trimmed.starts_with('#')) continue;
|
|
// A chain is read within one line, so a literal that spans lines
|
|
// would be sliced in half by chainEnd. Single-line raw strings are
|
|
// fine: they reduce to R"…" in the stripped view, so they fail the
|
|
// "is a plain literal" test below and travel through as an
|
|
// argument, spelling and all.
|
|
bool spansLines = ctx.LineHasMultiLineToken(li + 1);
|
|
|
|
std::size_t searchFrom = 0;
|
|
while (searchFrom < line.size()) {
|
|
// A candidate `+` that isn't ++ / += and touches a literal.
|
|
std::size_t plus = line.find('+', searchFrom);
|
|
if (plus == std::string_view::npos) break;
|
|
searchFrom = plus + 1;
|
|
if (plus + 1 < line.size() && (line[plus + 1] == '+' || line[plus + 1] == '=')) { ++searchFrom; continue; }
|
|
if (plus > 0 && line[plus - 1] == '+') continue;
|
|
std::size_t leftEnd = plus;
|
|
while (leftEnd > 0 && (line[leftEnd - 1] == ' ' || line[leftEnd - 1] == '\t')) --leftEnd;
|
|
std::size_t rightBegin = plus + 1;
|
|
while (rightBegin < line.size() && (line[rightBegin] == ' ' || line[rightBegin] == '\t')) ++rightBegin;
|
|
bool literalAdjacent = (leftEnd > 0 && line[leftEnd - 1] == '"')
|
|
|| (rightBegin < line.size() && line[rightBegin] == '"');
|
|
if (!literalAdjacent) continue;
|
|
if (spansLines) {
|
|
ctx.Report(li + 1, "use std::format instead of string concatenation with + (multi-line literal, fix manually)");
|
|
break;
|
|
}
|
|
|
|
// Expand to the full chain: operands joined by `+`.
|
|
std::size_t chainBegin = operandLeft(line, plus);
|
|
std::size_t chainEnd = operandRight(line, plus + 1);
|
|
bool bail = chainBegin == std::string_view::npos || chainEnd == std::string_view::npos;
|
|
while (!bail) {
|
|
std::size_t b = chainBegin;
|
|
while (b > 0 && (line[b - 1] == ' ' || line[b - 1] == '\t')) --b;
|
|
if (b > 0 && line[b - 1] == '+' && !(b > 1 && line[b - 2] == '+')) {
|
|
std::size_t prev = operandLeft(line, b - 1);
|
|
if (prev == std::string_view::npos) { bail = true; break; }
|
|
chainBegin = prev;
|
|
} else break;
|
|
}
|
|
while (!bail) {
|
|
std::size_t e = chainEnd;
|
|
while (e < line.size() && (line[e] == ' ' || line[e] == '\t')) ++e;
|
|
if (e < line.size() && line[e] == '+' && !(e + 1 < line.size() && (line[e + 1] == '+' || line[e + 1] == '='))) {
|
|
std::size_t next = operandRight(line, e + 1);
|
|
if (next == std::string_view::npos) { bail = true; break; }
|
|
chainEnd = next;
|
|
} else break;
|
|
}
|
|
if (bail) {
|
|
ctx.Report(li + 1, "use std::format instead of string concatenation with + (not auto-fixable)");
|
|
break;
|
|
}
|
|
|
|
// Split the chain at depth-0 '+' into parts; literals feed the
|
|
// format string, everything else becomes an argument.
|
|
std::string_view chain = line.substr(chainBegin, chainEnd - chainBegin);
|
|
std::string_view rawChain = std::string_view(ctx.content).substr(lineOff + chainBegin, chainEnd - chainBegin);
|
|
std::string fmt;
|
|
std::vector<std::string_view> args;
|
|
std::size_t partBegin = 0;
|
|
std::int64_t depth = 0;
|
|
bool inLit = false;
|
|
for (std::size_t p = 0; p <= chain.size(); ++p) {
|
|
if (p < chain.size()) {
|
|
char c = chain[p];
|
|
if (c == '"') inLit = !inLit;
|
|
if (inLit) continue;
|
|
if (c == '(' || c == '[') ++depth;
|
|
if (c == ')' || c == ']') --depth;
|
|
if (!(c == '+' && depth == 0)) continue;
|
|
}
|
|
std::string_view part = Trim(chain.substr(partBegin, p - partBegin));
|
|
std::string_view rawPart = Trim(rawChain.substr(partBegin, p - partBegin));
|
|
if (part.starts_with('"') && part.ends_with('"') && part.size() >= 2
|
|
&& std::count(part.begin(), part.end(), '"') == 2) {
|
|
for (char c : rawPart.substr(1, rawPart.size() - 2)) {
|
|
fmt += c;
|
|
if (c == '{') fmt += '{';
|
|
if (c == '}') fmt += '}';
|
|
}
|
|
} else if (part.contains('"') && part.contains('+')) {
|
|
bail = true; // nested concat inside an operand — human territory
|
|
break;
|
|
} else {
|
|
fmt += "{}";
|
|
args.push_back(rawPart);
|
|
}
|
|
partBegin = p + 1;
|
|
}
|
|
if (bail || args.empty()) {
|
|
ctx.Report(li + 1, "use std::format instead of string concatenation with + (not auto-fixable)");
|
|
break;
|
|
}
|
|
std::string replacement = std::format("std::format(\"{}\"", fmt);
|
|
for (std::string_view a : args) replacement += std::format(", {}", a);
|
|
replacement += ")";
|
|
edits.push_back({lineOff + chainBegin, lineOff + chainEnd, std::move(replacement)});
|
|
searchFrom = chainEnd;
|
|
}
|
|
}
|
|
if (edits.empty()) return;
|
|
std::string out = ctx.content;
|
|
std::sort(edits.begin(), edits.end(), [](const Edit& a, const Edit& b) { return a.begin > b.begin; });
|
|
for (const Edit& e : edits) out.replace(e.begin, e.end - e.begin, e.replacement);
|
|
ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
// ---------------- transforms (auto-fixed by `crafter-build format`) ----------------
|
|
|
|
// short/int/long → fixed-width types. Lines mentioning main/argc/argv or
|
|
// extern "C" keep their C-conventional ints.
|
|
cfg.AddLintRule("fixed-width-types", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
const std::string& code = ctx.CommentStripped();
|
|
struct Rep { std::size_t pos; std::size_t len; std::string to; };
|
|
std::vector<Rep> reps;
|
|
// Builtin integer type specifiers combine in any order (`unsigned
|
|
// long`, `long unsigned int`, ...), so match whole RUNS of these
|
|
// keywords and classify the run, rather than the words one by one.
|
|
static const std::unordered_set<std::string_view> IntWords = {
|
|
"unsigned", "signed", "short", "long", "int", "char",
|
|
};
|
|
std::size_t lineStart = 0;
|
|
while (lineStart <= code.size()) {
|
|
std::size_t lineEnd = code.find('\n', lineStart);
|
|
if (lineEnd == std::string::npos) lineEnd = code.size();
|
|
std::string_view line(code.data() + lineStart, lineEnd - lineStart);
|
|
// `int main` / argc / argv keep their C-conventional type; so do
|
|
// extern "C" prototypes (the literal body is blanked in the
|
|
// stripped text, so match `extern "`).
|
|
bool exempt = line.contains("int main") || line.contains("argc") || line.contains("argv")
|
|
|| line.contains("extern \"");
|
|
std::size_t pos = 0;
|
|
while (!exempt && pos < line.size()) {
|
|
if (!IsWordChar(line[pos])) { ++pos; continue; }
|
|
std::size_t wordEnd = pos;
|
|
while (wordEnd < line.size() && IsWordChar(line[wordEnd])) ++wordEnd;
|
|
if (!IntWords.contains(line.substr(pos, wordEnd - pos))) { pos = wordEnd; continue; }
|
|
|
|
// Extend the run over consecutive specifier keywords.
|
|
std::size_t runBegin = pos;
|
|
std::size_t runEnd = wordEnd;
|
|
bool hasUnsigned = false;
|
|
bool hasSigned = false;
|
|
bool hasShort = false;
|
|
bool hasChar = false;
|
|
bool hasLong = false;
|
|
std::string_view nextWord;
|
|
for (;;) {
|
|
std::string_view word = line.substr(pos, wordEnd - pos);
|
|
if (word == "unsigned") hasUnsigned = true;
|
|
else if (word == "signed") hasSigned = true;
|
|
else if (word == "short") hasShort = true;
|
|
else if (word == "char") hasChar = true;
|
|
else if (word == "long") hasLong = true;
|
|
runEnd = wordEnd;
|
|
pos = wordEnd;
|
|
while (pos < line.size() && (line[pos] == ' ' || line[pos] == '\t')) ++pos;
|
|
wordEnd = pos;
|
|
while (wordEnd < line.size() && IsWordChar(line[wordEnd])) ++wordEnd;
|
|
nextWord = line.substr(pos, wordEnd - pos);
|
|
if (!IntWords.contains(nextWord)) break;
|
|
}
|
|
pos = runEnd;
|
|
|
|
// Bare `char` is text, not an integer — only signed/unsigned
|
|
// char is byte arithmetic. `long double` is a floating type.
|
|
if (hasChar && !hasUnsigned && !hasSigned) continue;
|
|
if (nextWord == "double") continue;
|
|
|
|
std::string_view width = hasChar ? "8" : hasShort ? "16" : hasLong ? "64" : "32";
|
|
reps.push_back({lineStart + runBegin, runEnd - runBegin,
|
|
std::format("std::{}int{}_t", hasUnsigned ? "u" : "", width)});
|
|
}
|
|
lineStart = lineEnd + 1;
|
|
}
|
|
if (reps.empty()) return;
|
|
std::string out = ctx.content;
|
|
std::sort(reps.begin(), reps.end(), [](const Rep& a, const Rep& b) { return a.pos > b.pos; });
|
|
for (const Rep& r : reps) out.replace(r.pos, r.len, r.to);
|
|
ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
// One declaration per statement. Auto-splits the simple initialized form
|
|
// `Type a = x, b = y;`; anything with pointers/references, parens, or
|
|
// templates in the declarators is only reported (splitting `int* a, b;`
|
|
// would change b's type).
|
|
cfg.AddLintRule("single-declaration", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::vector<std::string_view> stripped = Lines(ctx.CommentStripped());
|
|
// The declarator char class excludes quotes: string-literal bodies are
|
|
// blanked in the stripped text, so reconstructing them would corrupt
|
|
// the file — those lines are left alone.
|
|
static const std::regex simpleMulti(
|
|
R"(^(\s*)((?:std::)?[A-Za-z_][\w:]*)\s+([A-Za-z_]\w*\s*=\s*[^,;()<>*&"]+(?:,\s*[A-Za-z_]\w*\s*=\s*[^,;()<>*&"]+)+);\s*$)");
|
|
std::string out;
|
|
bool changed = false;
|
|
for (std::size_t i = 0; i < stripped.size(); ++i) {
|
|
std::string lineStr(stripped[i]);
|
|
std::smatch m;
|
|
std::string_view raw = i + 1 <= ctx.lines.size() ? ctx.Line(i + 1) : std::string_view{};
|
|
if (!ctx.LineHasComment(i + 1) && !ctx.Suppressed("single-declaration", i + 1)
|
|
&& std::regex_match(lineStr, m, simpleMulti)) {
|
|
std::string indent = m[1].str(), type = m[2].str(), decls = m[3].str();
|
|
std::size_t start = 0;
|
|
bool first = true;
|
|
while (start < decls.size()) {
|
|
std::size_t comma = decls.find(',', start);
|
|
std::string_view d = Trim(std::string_view(decls).substr(start, comma == std::string::npos ? std::string::npos : comma - start));
|
|
if (!first) out += '\n';
|
|
out += std::format("{}{} {};", indent, type, d);
|
|
first = false;
|
|
if (comma == std::string::npos) break;
|
|
start = comma + 1;
|
|
}
|
|
changed = true;
|
|
} else {
|
|
out += raw;
|
|
}
|
|
if (i + 1 < stripped.size() || ctx.content.ends_with('\n')) out += '\n';
|
|
}
|
|
if (changed) ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
// K&R braces: `{` on its own line after a `)`/else/do/try header joins
|
|
// onto the header line. Standalone scope blocks (previous line ends with
|
|
// `;`, `{`, a comment, …) are intentional and stay.
|
|
cfg.AddLintRule("brace-style", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::vector<std::string_view> stripped = Lines(ctx.CommentStripped());
|
|
std::vector<std::string> outLines;
|
|
outLines.reserve(ctx.lines.size());
|
|
bool changed = false;
|
|
for (std::size_t i = 0; i < ctx.lines.size(); ++i) {
|
|
std::string_view trimmed = Trim(stripped[i]);
|
|
if (trimmed == "{" && !outLines.empty()) {
|
|
std::string_view prevTrim = i > 0 ? Trim(stripped[i - 1]) : std::string_view{};
|
|
bool headerBefore = prevTrim.ends_with(')') || prevTrim == "else" || prevTrim == "do" || prevTrim == "try";
|
|
bool hasComment = ctx.LineHasComment(i + 1) || (i > 0 && ctx.LineHasComment(i));
|
|
bool suppressed = ctx.Suppressed("brace-style", i) || ctx.Suppressed("brace-style", i + 1);
|
|
if (headerBefore && !hasComment && !suppressed) {
|
|
std::string& prev = outLines.back();
|
|
while (!prev.empty() && (prev.back() == ' ' || prev.back() == '\t')) prev.pop_back();
|
|
prev += " {";
|
|
changed = true;
|
|
continue;
|
|
}
|
|
}
|
|
outLines.emplace_back(ctx.Line(i + 1));
|
|
}
|
|
if (!changed) return;
|
|
std::string out;
|
|
for (std::size_t i = 0; i < outLines.size(); ++i) {
|
|
out += outLines[i];
|
|
if (i + 1 < outLines.size() || ctx.content.ends_with('\n')) out += '\n';
|
|
}
|
|
ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
// Single-statement if bodies join onto the if line: `if (x)\n y;` →
|
|
// `if (x) y;` — when the condition's parens balance on one line, the body
|
|
// is one `;`-terminated statement, neither line carries a comment, and
|
|
// the joined line stays ≤ 250 columns.
|
|
cfg.AddLintRule("if-single-line", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::vector<std::string_view> stripped = Lines(ctx.CommentStripped());
|
|
static const std::regex ifHeader(R"(^\s*(?:\}?\s*else\s+)?if\s*\(.*\)\s*$)");
|
|
std::vector<std::string> outLines;
|
|
bool changed = false;
|
|
for (std::size_t i = 0; i < ctx.lines.size(); ++i) {
|
|
std::string lineStr(stripped[i]);
|
|
if (i + 1 < ctx.lines.size() && std::regex_match(lineStr, ifHeader) && ParenDelta(stripped[i]) == 0) {
|
|
std::string_view body = Trim(stripped[i + 1]);
|
|
bool joinable = !body.empty() && body != "{" && !body.starts_with("if") && body.ends_with(';')
|
|
&& !ctx.LineHasComment(i + 1) && !ctx.LineHasComment(i + 2)
|
|
&& !ctx.Suppressed("if-single-line", i + 1) && !ctx.Suppressed("if-single-line", i + 2);
|
|
std::string joined = std::string(ctx.Line(i + 1));
|
|
while (!joined.empty() && (joined.back() == ' ' || joined.back() == '\t')) joined.pop_back();
|
|
joined += " ";
|
|
joined += Trim(ctx.Line(i + 2));
|
|
if (joinable && joined.size() <= 250) {
|
|
outLines.push_back(std::move(joined));
|
|
++i; // consume the body line
|
|
changed = true;
|
|
continue;
|
|
}
|
|
}
|
|
outLines.emplace_back(ctx.Line(i + 1));
|
|
}
|
|
if (!changed) return;
|
|
std::string out;
|
|
for (std::size_t i = 0; i < outLines.size(); ++i) {
|
|
out += outLines[i];
|
|
if (i + 1 < outLines.size() || ctx.content.ends_with('\n')) out += '\n';
|
|
}
|
|
ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
// Wrapped call arguments join back onto one line when the whole
|
|
// expression fits in 250 columns. Lambda bodies (lines ending `{`),
|
|
// comments, raw strings, and preprocessor lines are left alone.
|
|
// Operator-style continuations (next line starts with && / || / |) join
|
|
// under the same length limit.
|
|
cfg.AddLintRule("wrap-join", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
// Fixpoint loop: a join can enable another (joining an inner paren
|
|
// wrap balances the line an operator continuation hangs off), so one
|
|
// pass is not idempotent. Iterate until a pass changes nothing; the
|
|
// cap is a safety net — joins strictly reduce the line count, so
|
|
// termination is guaranteed anyway.
|
|
for (std::int32_t pass = 0; pass < 16; ++pass) {
|
|
std::vector<std::string_view> stripped = Lines(ctx.CommentStripped());
|
|
std::vector<std::string> outLines;
|
|
bool changed = false;
|
|
for (std::size_t i = 0; i < ctx.lines.size(); ++i) {
|
|
std::string_view trimmed = Trim(stripped[i]);
|
|
std::int64_t delta = ParenDelta(stripped[i]);
|
|
bool candidate = delta > 0 && !trimmed.empty() && !trimmed.starts_with('#')
|
|
&& !trimmed.ends_with('{') && !ctx.LineHasComment(i + 1) && !ctx.LineHasMultiLineToken(i + 1);
|
|
if (candidate) {
|
|
std::string joined(ctx.Line(i + 1));
|
|
std::size_t j = i + 1;
|
|
bool ok = true;
|
|
while (delta > 0 && j < ctx.lines.size() && j - i <= 4) {
|
|
std::string_view next = Trim(stripped[j]);
|
|
// A `{`-ending line is fine when it closes the expression
|
|
// (a control header's `) {`); mid-expression it means a
|
|
// lambda body starts — leave those wrapped.
|
|
bool closes = delta + ParenDelta(stripped[j]) <= 0;
|
|
if (next.empty() || (next.ends_with('{') && !closes)
|
|
|| ctx.LineHasComment(j + 1) || ctx.LineHasMultiLineToken(j + 1)) {
|
|
ok = false;
|
|
break;
|
|
}
|
|
while (!joined.empty() && (joined.back() == ' ' || joined.back() == '\t')) joined.pop_back();
|
|
std::string_view fragment = Trim(ctx.Line(j + 1));
|
|
// No separator right after an opening paren or before a
|
|
// closing one — joining must not manufacture `( x` / `x )`.
|
|
if (!joined.ends_with('(') && !fragment.starts_with(')') && !fragment.starts_with(',')) joined += " ";
|
|
joined += fragment;
|
|
delta += ParenDelta(stripped[j]);
|
|
++j;
|
|
}
|
|
for (std::size_t l = i + 1; ok && l <= j; ++l) ok = !ctx.Suppressed("wrap-join", l);
|
|
if (ok && delta <= 0 && joined.size() <= 250) {
|
|
outLines.push_back(std::move(joined));
|
|
i = j - 1; // consumed through line j-1 (0-based i)
|
|
changed = true;
|
|
continue;
|
|
}
|
|
} else if (delta == 0 && i + 1 < ctx.lines.size() && !trimmed.starts_with('#')
|
|
&& !ctx.LineHasComment(i + 1) && !ctx.LineHasMultiLineToken(i + 1)) {
|
|
auto isOpStart = [](std::string_view s) {
|
|
return s.starts_with("&&") || s.starts_with("||") || s.starts_with("| ");
|
|
};
|
|
// Operator-style continuation chain (`a\n && b\n && c`).
|
|
// Joined when the WHOLE chain stays within 250 columns —
|
|
// longer conditions legitimately wrap. Same mechanics as the
|
|
// paren join: chain lines must be comment-free, raw-string
|
|
// free, and paren-balanced.
|
|
if (isOpStart(Trim(stripped[i + 1])) && !isOpStart(trimmed)) {
|
|
std::string joined(ctx.Line(i + 1));
|
|
std::size_t j = i + 1;
|
|
bool ok = true;
|
|
while (j < ctx.lines.size() && isOpStart(Trim(stripped[j]))) {
|
|
if (ParenDelta(stripped[j]) != 0 || ctx.LineHasComment(j + 1) || ctx.LineHasMultiLineToken(j + 1)) {
|
|
ok = false;
|
|
break;
|
|
}
|
|
while (!joined.empty() && (joined.back() == ' ' || joined.back() == '\t')) joined.pop_back();
|
|
joined += " ";
|
|
joined += Trim(ctx.Line(j + 1));
|
|
++j;
|
|
}
|
|
for (std::size_t l = i + 1; ok && l <= j; ++l) ok = !ctx.Suppressed("wrap-join", l);
|
|
if (ok && joined.size() <= 250) {
|
|
outLines.push_back(std::move(joined));
|
|
i = j - 1; // consumed the chain
|
|
changed = true;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
outLines.emplace_back(ctx.Line(i + 1));
|
|
}
|
|
if (!changed) return;
|
|
std::string out;
|
|
for (std::size_t i = 0; i < outLines.size(); ++i) {
|
|
out += outLines[i];
|
|
if (i + 1 < outLines.size() || ctx.content.ends_with('\n')) out += '\n';
|
|
}
|
|
ctx.SetContent(std::move(out));
|
|
}
|
|
});
|
|
|
|
// No space padding inside parens: `( x` / `x )` → `(x` / `x)`. Only
|
|
// intra-line (a line legitimately ends with '(' when a call wraps);
|
|
// string/comment interiors are excluded via the stripped text.
|
|
cfg.AddLintRule("paren-spacing", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
const std::string& code = ctx.CommentStripped();
|
|
std::vector<std::pair<std::size_t, std::size_t>> cuts; // [begin, end) spans of spaces to delete
|
|
for (std::size_t i = 0; i < code.size(); ++i) {
|
|
if (code[i] == '(' ) {
|
|
std::size_t j = i + 1;
|
|
while (j < code.size() && code[j] == ' ') ++j;
|
|
if (j > i + 1 && j < code.size() && code[j] != '\n' && code[j] != '\r') cuts.push_back({i + 1, j});
|
|
} else if (code[i] == ')') {
|
|
std::size_t j = i;
|
|
while (j > 0 && code[j - 1] == ' ') --j;
|
|
// Only single-space padding: multi-space runs are usually
|
|
// deliberate alignment columns.
|
|
if (j == i - 1 && j > 0 && code[j - 1] != '\n' && code[j - 1] != ',') cuts.push_back({j, i});
|
|
}
|
|
}
|
|
if (cuts.empty()) return;
|
|
std::string out = ctx.content;
|
|
for (auto it = cuts.rbegin(); it != cuts.rend(); ++it) out.erase(it->first, it->second - it->first);
|
|
ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
cfg.AddLintRule("trim-trailing-ws", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
std::string out;
|
|
out.reserve(ctx.content.size());
|
|
for (std::size_t n = 1; n <= ctx.lines.size(); ++n) {
|
|
std::string_view line = ctx.Line(n);
|
|
// Byte fidelity on CRLF files: peel the \r, trim, put it back.
|
|
bool crlf = line.ends_with('\r');
|
|
if (crlf) line.remove_suffix(1);
|
|
while (line.ends_with(' ') || line.ends_with('\t')) line.remove_suffix(1);
|
|
out += line;
|
|
if (crlf) out += '\r';
|
|
// The last line only had a newline if the file ended with one —
|
|
// preserve that byte exactly so this rule doesn't shadow
|
|
// final-newline.
|
|
if (n < ctx.lines.size() || ctx.content.ends_with('\n')) out += '\n';
|
|
}
|
|
ctx.SetContent(std::move(out));
|
|
});
|
|
|
|
cfg.AddLintRule("final-newline", [](LintContext& ctx) {
|
|
if (!IsCppFile(ctx)) return;
|
|
if (!ctx.content.empty() && !ctx.content.ends_with('\n')) {
|
|
ctx.SetContent(ctx.content + '\n');
|
|
}
|
|
});
|
|
}
|
|
|
|
} // namespace ProjectLint
|