Module compiler 

Typed compiler / tool identity and capability model.

Cabin’s build planner emits GCC/Clang-style commands. The ResolvedToolchain (see crate::toolchain) says which tools the user picked; this module says what those tools are and what they can do. The resolver in cabin-toolchain::detect runs harmless --version invocations against each resolved tool, hands the output to the pure parsers in this module, and assembles a typed ToolchainDetectionReport.

This module is data and pure logic only. Process spawning, filesystem traversal, and CLI dispatch live elsewhere.

Structs

ArchiverCapabilities

Capability set for a static-library archiver.

ArchiverIdentity

Detected identity of a static-library archiver.

Capability

One typed capability decision: whether the tool supports it, and where the answer came from.

CompilerCapabilities

Capability set for a C/C++ compiler. Every field is decided during detection so the planner can compare its required set against the resolved set without re-running parsing logic.

CompilerIdentity

Detected identity of one C/C++ compiler.

CompilerVersion

Decomposed compiler / archiver version (major.minor.patch).

ToolDetection

One tool’s detection outcome plus the path it was invoked at. path is the resolved absolute path from crate::ResolvedToolchain; it is preserved here so error messages can mention the exact executable.

ToolchainDetectionReport

Whole-toolchain detection report. The CLI builds one per invocation that needs detection (build / metadata) and threads it into the planner and the metadata view.

Enums

ArchiverKind

Recognized static-library archiver family.

CapabilitySource

Where one capability decision came from. Recorded so cabin metadata can show whether Cabin trusted the version alone, ran a probe, or fell back to a conservative default.

CompilerKind

Recognized C/C++ compiler family.

ToolDetectionError

Errors produced while validating a detection report against the current C++ backend’s required capability set.

Functions

c_standard_capability

Whether identity accepts the exact flag spelling for a C standard (-std=<std> on the GNU dialect, /std:<std> on MSVC). Version thresholds follow the audited table in docs/language-standards.md: unknown versions fail open (assumed-default), recognized-but-old versions fail closed, and MSVC-dialect gaps (no stable flag at any version) are Unsupported. Unknown compiler kinds are rejected earlier by the backend validation, so their entry here is conservative.

cxx_standard_capability

C++ twin of c_standard_capability.

derive_ar_capabilities

Derive an ArchiverCapabilities set from the detected identity.

derive_cxx_capabilities

parse_ar_version_output

Pure parser for archiver --version output. The recognized families (ar and llvm-ar) print one line that includes the family name. Anything else is classified as ArchiverKind::Unknown; archivers that exit non-zero on --version are left to the subprocess layer to surface as Unknown.

parse_cxx_version_output

Pure parser for compiler --version output.

standard_support_detail

Human-readable reason for an unsupported standard capability, used by the validation errors: either the compiler has no stable flag for the standard at any version, or the detected version predates the flag.

validate_ar_for_backend

Validate that the resolved archiver can drive one of Cabin’s two static-library backends: lib.exe for MSVC (lib /OUT:<lib> <objs>), or an ar-compatible archiver for GCC/Clang (ar crs <lib> <objs>).

validate_c_standards

C-side twin of validate_cxx_standards.

validate_cc_for_backend

Validate that the resolved C compiler supports the C-side command shape the active backend emits. An MSVC compiler drives the cl.exe backend; every other recognized compiler drives the GCC/Clang backend, which needs GCC-style flags plus -MMD -MF depfile generation. Support for the requested C standards is validated separately by validate_c_standards.

validate_cxx_for_backend

Validate that the resolved C++ compiler can drive one of Cabin’s two C++ backends.

validate_cxx_standards

Validate that the C++ compiler accepts every requested C++ standard. The whole set is checked, not the maximum: MSVC support is non-monotonic (/std:c++20 exists, /std:c++11 does not).