Files
frameledger/qodana-native.yaml
poli0981andClaude Fable 5.2 4fbc14e698 ci: Qodana reads the C++ as a second report - a Visual Studio solution CMake writes, the job native, fifty-four .editorconfig lines each with its reason, eleven small fixes, nothing changed in code loaded into a game (Qodana PR-2, D99/D100) (#385)
The second of two pull requests. Qodana for .NET - whose C++ is ReSharper C++ - is the only linter of JetBrains' that
can read this code: it is MSVC-only, and qodana-cpp and qodana-clang are Linux images. It reads C++ through a Visual
Studio solution, and src/native is a CMake tree, so the job has CMake write one.

The job
- src/native/CMakePresets.json: the preset x64-vs-analysis (generator "Visual Studio 18 2026", tests and tools on).
  Nothing ships from it, and the gate and the release never use it.
- qodana-native.yaml: the solution, RelWithDebInfo and x64; the build tree, third_party, the vendor stubs and a
  compiled shader left out by path; a gate of zero.
- qodana.yml: the job `native` - configure, build the one target whose output is a header (the blocklist floor), then
  the action with --config qodana-native.yaml. Its own results folder, cache keys, artifact (qodana-report-native)
  and Qodana Cloud project (frameledger-cpp, QODANA_TOKEN_NATIVE). No comment and no annotations: the pull request's
  are the managed job's. Advisory.

What its first run reported, and what was done (docs/13_CI_CD.md, section Qodana)
- 4,695 problems, 4,040 of them hints (off, as on the managed side). Of the 655 left, 494 are distinct: a file
  compiled into three targets is reported three times.
- Off in .editorconfig, each with its reason - every clang-tidy check and clang diagnostic the engine runs has a key
  of ReSharper's, so no .clang-tidy file is added:
  278 a choice this code made (struct padding, MSVC's keywords, a function pointer got by name cast to its type,
      "can be const / constexpr / static", an #include of what the file uses);
   53 a newer idiom proposed for working code;
   25 the engine misreading std::atomic_ref, zero-initialised API structures and tests of constexpr functions;
   25 fields nothing names in structures Windows defines (four files);
   19 %lu with NvU32 in one probe - unsigned int only under clang, the linter's compiler;
   78 what a probe or a test does on purpose (tools and tests);
    7 in code loaded into a game, kept as it is.
- Fixed, 11, none changing what a shipped binary does: std::size for four hand-written array lengths; two
  multiplications done in a narrower type than their result (a constant in the guard's sources, a test); two unused
  member functions, an unused type alias and two unused includes in the tests and the probes.

Code loaded into a game - the Overlay, the Vulkan layer, the shared-memory headers, the guard's rule matcher - is not
changed (D100: there only a defect is fixed, and the report found none). One thing there is not as it should be and
is RECORDED, not removed: dllmain.cpp's LogNoteW, which nothing calls. .editorconfig leaves that one file unread for
an unused function, in a section that says to remove it with the function; whether it goes is the owner's call
(HANDOFF).

"Zero" proved to mean "analysed": a branch that put back three of the things fixed here was reported with exactly
those three, by the inspections that had found them (run 42942390715).

Runs on this branch: 42942068024 (one problem left: LogNoteW), 42943094415 (none).

Docs: 13_CI_CD (the native report), 12_BUILD (the preset), CLAUDE.md (the layout, the C++ conventions), HANDOFF,
wiki/Releasing, CHANGELOG.

Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 02:27:27 +00:00

46 lines
1.8 KiB
YAML

# Qodana's settings for the `native` job of .github/workflows/qodana.yml (owner decision D99, 2026-11-11;
# docs/13_CI_CD.md §Qodana).
#
# The C++ of src/native, read by Qodana for .NET (qodana-dotnet: Rider's engine, whose C++ is ReSharper C++) in native
# mode on a Windows runner. That linter is the only one that can: the native layer is MSVC-only, and JetBrains' two
# C/C++ linters (qodana-cpp, qodana-clang) are Linux images. It reads C++ through a Visual Studio solution, and
# src/native is a CMake tree, so the job generates one first - the `x64-vs-analysis` preset - and builds from it only
# the one header a build generates (the blocklist floor). Nothing else is compiled.
#
# A report of its own, in a Qodana Cloud project of its own (`frameledger-cpp`, the QODANA_TOKEN_NATIVE secret): the
# managed report (qodana.yaml) leaves src/native out, so every file is in exactly one of the two.
version: "1.0"
linter: qodana-dotnet
withinDocker: false
profile:
base:
name: qodana.recommended
groups:
- groupId: Hints
groups:
- "severity:TYPO"
inspections:
- group: Hints
enabled: false
dotnet:
solution: build/native/x64-vs-analysis/FrameLedgerNative.slnx
# The flags the shipped binaries are built with (the x64-release preset's build type).
configuration: RelWithDebInfo
platform: x64
# What is not FrameLedger's code: what CMake generates and fetches (MinHook, Catch2, jsmn, the floor header), the
# vendored SDK headers, the fixtures that carry the vendors' names on purpose, a compiled shader as a byte array.
exclude:
- name: All
paths:
- build
- src/native/third_party
- src/native/tools/vendor-stubs
- src/native/tools/hook-harness/dxr_raygen_dxil.h
failureConditions:
severityThresholds:
any: 0