Enum PhaseKind 

pub enum PhaseKind {
    MaskOutputsAndEnv,
    Serialize,
    Sha256,
    ComputeOutputPaths,
    FillPlaceholders,
    ComputeDrvPath,
    SerializeModulo,
    CacheSelfModulo,
    SeedFixedOutputHash,
    MarkContentAddressed,
    EmitCaPlaceholders,
}

Enumeration of every phase the interpreter knows how to run. Adding a new phase here IS adding a new primitive to the spec language — the typed border is exactly this set.

Variants

MaskOutputsAndEnv

Set every output’s path to "" AND every env entry whose name matches an output to "". This is what CppNix calls “maskOutputs” — it’s the precondition for hashing the “unresolved” form of a derivation.

Serialize

ATerm-serialize the current derivation into the bytes slot named by bind.

Sha256

Compute SHA-256 of the bytes in slot from, store the lowercase-hex digest into slot bind.

ComputeOutputPaths

Given the inner hex stored in slot from_hash, compute the per-output store path via sui_compat::store_path::compute_output_path and populate the shared out_paths map.

FillPlaceholders

Copy each entry of out_paths back into the derivation: drv.outputs[<name>].path = <path> AND drv.env[<name>] = <path>. After this phase the derivation is in CppNix’s “final” form.

ComputeDrvPath

Given the final hex stored in slot from_hash, compute the .drv store path via sui_compat::store_path::compute_drv_path and record it as the overall result.

SerializeModulo

Like Serialize but replace every input_derivations key (a .drv path) with its hashDerivationModulo lookup from the thread-local modulo cache — CppNix’s recursion over dependent derivations. Input drvs with no cached modulo hash are passed through unchanged, which matches the parity-on-leaves case (a drv with no dependencies serialises identically in both forms).

CacheSelfModulo

Record the current hex hash in from_hash as the modulo hash for the produced .drv path, so derivations that depend on this one can look it up during their own SerializeModulo phase.

SeedFixedOutputHash

For a fixed-output derivation: read drv.env.outputHash, outputHashAlgo, outputHashMode and seed the per-output fingerprint from the output content hash rather than the recipe hash. Output store path follows from this seed via the same compute_output_path route as input-addressed.

MarkContentAddressed

Mark the derivation as CA (__contentAddressed = true). CA outputs’ paths aren’t known at recipe time; the builder resolves them post-realisation and rewrites the .drv in place. This phase plants the marker so downstream phases route correctly.

EmitCaPlaceholders

For CA derivations only: write a placeholder output path (cppnix uses /nix/store/<placeholder>-<name> style); the builder substitutes real paths after a successful build.

Trait Implementations

impl Clone for PhaseKind

fn clone(&self) -> PhaseKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PhaseKind

impl Debug for PhaseKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PhaseKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for PhaseKind

impl PartialEq for PhaseKind

fn eq(&self, other: &PhaseKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PhaseKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PhaseKind