Struct CacheKey 

pub struct CacheKey {
    pub source_hash: [u8; 32],
    pub context_hash: [u8; 32],
    pub harn_version: Cow<'static, str>,
    pub compiler_tag: u8,
}

Cache key components for a single pipeline source. Equality of all fields is necessary and sufficient for cache reuse.

Fields

source_hash: [u8; 32]

context_hash: [u8; 32]

harn_version: Cow<'static, str>

Harn version stamped into, and required by, this artifact’s header.

Normally the running binary’s own HARN_VERSION. Release preparation bumps Cargo.toml after snapshotting the generator, so that one caller must stamp the version the shipped binary will report instead of the version the generator was built at — otherwise the shipped runtime rejects its own embedded payload and silently falls back to source compilation. Use CacheKey::for_artifact_version.

compiler_tag: u8

Compact tag for active CompilerOptions. Flipping HARN_DISABLE_OPTIMIZATIONS between runs would otherwise reuse a chunk compiled under the wrong setting.

Implementations

impl CacheKey

pub fn from_source(source_path: &Path, source: &str) -> Self

Compute the cache key for a .harn source file plus its transitive user imports. source is the entry-file contents; the import graph is walked from disk relative to source_path.

pub fn from_relocatable_source(source_path: &Path, source: &str) -> Self

Compute a relocatable entry-chunk key for a closed source tree.

Unlike Self::from_source, the dependency graph identifies files by their path relative to the entrypoint directory. Moving the complete tree therefore preserves the key, while changing a relative path, source byte, compiler build, or embedded stdlib still invalidates it. This is the key used by packaged adjacent artifacts; ordinary shared cache entries remain anchored to canonical host paths.

pub fn for_artifact_version(self, harn_version: impl Into<String>) -> Self

Restamp this key for an artifact that a different Harn version will load. Only release preparation needs this; every ordinary compile and lookup keeps the running binary’s own version.

pub fn from_module_source(source: &ModuleSource) -> Self

Compute the cache key for one independently-compiled module artifact.

A ModuleArtifact stores unresolved import specs and never compiles dependency contents into the parent artifact. Walking the transitive graph here therefore adds cold-start I/O without protecting correctness: the runtime loads every dependency under its own source-local key. Diagnostic paths are rebound when the artifact is loaded, so adjacent and packaged artifacts remain relocatable without aliasing attribution.

pub fn from_module_content_hash(content_hash: [u8; 32]) -> Self

As from_module_source, but from a digest recorded earlier instead of bytes in hand.

The digest is the only part of a module key that depends on the file; every other component is process-global. That asymmetry is what lets a validated GraphLinkTable name a module’s artifact without the file being read again.

pub fn filename(&self) -> String

Entry-chunk filename for this key. We hash by source content alone so two invocations of the same source from different paths share a cache entry; the header’s compilation-context hash still gates reuse on a per-load basis.

pub fn module_filename(&self) -> String

Module-artifact filename for this complete compilation key. Diagnostic source paths are rebound at load time, so identical source and compiler inputs share one relocatable artifact across paths.

Trait Implementations

impl Clone for CacheKey

fn clone(&self) -> CacheKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheKey

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

Formats the value using the given formatter.

impl Eq for CacheKey

impl PartialEq for CacheKey

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CacheKey