Struct GlobalEnv 

pub struct GlobalEnv {

    pub namespaces: RwLock<HashMap<Arc<str>, GcPtr<Namespace>>>,
    pub source_paths: RwLock<Vec<PathBuf>>,
    pub loaded: Mutex<HashSet<Arc<str>>>,
    pub loading: Mutex<HashMap<Arc<str>, ThreadId>>,
    pub loading_done: Condvar,
    pub builtin_sources: RwLock<HashMap<Arc<str>, &'static str>>,
    pub gc_config: RwLock<Option<Arc<GcConfig>>>,
    pub async_rt: RwLock<Option<Arc<dyn AsyncRuntime>>>,
    pub version_cache: Mutex<HashMap<Arc<str>, Value>>,
    pub deps_config: RwLock<Option<Arc<DepsConfig>>>,
    pub verify_commit_signatures: AtomicBool,
    pub sig_verify_cache: Mutex<HashSet<(Arc<str>, Arc<str>)>>,
    pub versioned_sources: RwLock<HashMap<Arc<str>, Arc<str>>>,
    pub versioned_offline: AtomicBool,
    pub native_provenance: RwLock<HashMap<Arc<str>, Arc<str>>>,
    pub enforce_native_versions: AtomicBool,
    pub provenance_warned: Mutex<HashSet<Arc<str>>>,
    pub pinned_native_loader: RwLock<Option<PinnedNativeLoader>>,
    pub native_require_loader: RwLock<Option<NativeRequireLoader>>,
    pub compiled_ns_loaders: RwLock<HashMap<Arc<str>, CompiledNsLoader>>,
    /* private fields */
}

The global mutable store of all namespaces.

Fields

namespaces: RwLock<HashMap<Arc<str>, GcPtr<Namespace>>>

source_paths: RwLock<Vec<PathBuf>>

Directories to search when resolving namespace names to files.

loaded: Mutex<HashSet<Arc<str>>>

Namespaces that have been fully loaded from a file (idempotent guard).

loading: Mutex<HashMap<Arc<str>, ThreadId>>

Namespaces currently being loaded, mapped to the thread loading them. Used to detect true circular requires (same thread) vs concurrent loads (different thread — those wait on loading_done instead of erroring).

loading_done: Condvar

Signalled whenever a namespace finishes loading (or fails).

builtin_sources: RwLock<HashMap<Arc<str>, &'static str>>

Built-in namespace sources embedded in the binary. Checked by load_ns before falling back to source-path search.

gc_config: RwLock<Option<Arc<GcConfig>>>

GC configuration for automatic collection based on memory pressure.

async_rt: RwLock<Option<Arc<dyn AsyncRuntime>>>

Optional async runtime registered by cljrs-async. None when the library is not linked; Some after cljrs_async::init.

version_cache: Mutex<HashMap<Arc<str>, Value>>

Cache of values resolved at a specific commit. Key format: "<ns>/<name>@<commit>" for individual vars, or "<ns>@<commit>" for whole versioned namespaces.

deps_config: RwLock<Option<Arc<DepsConfig>>>

Parsed cljrs.edn config, loaded once at startup.

verify_commit_signatures: AtomicBool

When true, every versioned-symbol or versioned-namespace resolution must carry a valid commit signature (verified natively against trusted_keys) before the historical code is executed. Off by default; enabled via --verify-commit-signatures CLI flag or :verify-commit-signatures true in cljrs.edn.

sig_verify_cache: Mutex<HashSet<(Arc<str>, Arc<str>)>>

Session-scoped cache of commits that have already passed signature verification this run, keyed by (repo_root, commit_hash).

versioned_sources: RwLock<HashMap<Arc<str>, Arc<str>>>

Pinned source texts fetched from git this session, keyed by "<ns>@<commit>". The AOT compiler embeds these in the produced binary so versioned namespaces resolve without git at runtime.

versioned_offline: AtomicBool

When true (set by AOT harness main), versioned namespaces resolve only from embedded builtin sources — never from git. A versioned namespace that was not embedded at compile time fails with a clear error instead of attempting a fetch.

native_provenance: RwLock<HashMap<Arc<str>, Arc<str>>>

Provenance of native (Rust-backed) packages recorded at registration: namespace → the git commit the package was built from. Consulted by the versioned resolver’s native HEAD fallback to detect pinned-commit mismatches.

enforce_native_versions: AtomicBool

When true, a pinned lookup of a native function whose recorded provenance does not match the requested commit is an error instead of a once-per-pin warning. CLI: --enforce-native-versions; cljrs.edn: :enforce-native-versions true.

provenance_warned: Mutex<HashSet<Arc<str>>>

Pinned-native mismatches already warned about this session (key: "<ns>@<commit>"), so each pin warns at most once.

pinned_native_loader: RwLock<Option<PinnedNativeLoader>>

Optional loader for pinned native packages (:rust/load :dylib), installed by the CLI. Called by the versioned resolver with (globals, base_ns, commit) before falling back to the HEAD native binding; returns Ok(true) when it registered the package’s pinned implementations into the "<base_ns>@<commit>" namespace.

native_require_loader: RwLock<Option<NativeRequireLoader>>

Optional loader for native dependencies on the plain require path (:rust/load :dylib), installed by the CLI. Called by the unversioned namespace loader with (globals, ns) when a required namespace has no Clojure source on the source path; returns Ok(true) when it built the dep’s crate at the pinned :git/sha and registered the package’s exports into the unversioned namespace, so a plain (require '[my.native.lib :as lib]) brings the native code in.

compiled_ns_loaders: RwLock<HashMap<Arc<str>, CompiledNsLoader>>

Loaders for AOT-compiled namespaces, installed by the binary produced by cljrs compile. Keyed by namespace name. When a plain require resolves a namespace that has a registered loader, load_ns invokes the loader instead of interpreting Clojure source: the loader evaluates the namespace’s small interpreted preamble (its ns/require and macro definitions) and then calls the namespace’s natively compiled initializer, so the bulk of the namespace runs as machine code rather than being tree-walked at startup.

Implementations

impl GlobalEnv

pub fn new(execution_mode: ExecutionMode) -> Arc<Self>

Create an empty global environment for the given execution mode.

This is the raw constructor: no builtins, no bootstrap, no source paths. Use crate::Runtime::builder unless you are the builder.

pub fn set_source_paths(&self, paths: Vec<PathBuf>)

Replace the source path list.

pub fn register_builtin_source(&self, ns: &str, src: &'static str)

Register an embedded namespace source (called by cljrs-stdlib at startup).

pub fn builtin_source(&self, ns: &str) -> Option<&'static str>

Look up an embedded source for a namespace, if one has been registered.

pub fn register_compiled_ns_loader(&self, ns: &str, loader: CompiledNsLoader)

Register a loader for an AOT-compiled namespace (called by the harness main of a binary produced by cljrs compile).

pub fn compiled_ns_loader(&self, ns: &str) -> Option<CompiledNsLoader>

Look up the loader for an AOT-compiled namespace, if one is registered.

pub fn mark_loaded(&self, ns: &str)

Mark a namespace as fully loaded from a file.

pub fn is_loaded(&self, ns: &str) -> bool

True if the namespace has already been loaded from a file.

pub fn set_gc_config(&self, config: Arc<GcConfig>)

Set the GC configuration for automatic memory pressure management.

pub fn gc_config(&self) -> Option<Arc<GcConfig>>

Get the GC configuration, if one has been set.

pub fn resolve_alias(&self, current_ns: &str, alias: &str) -> Option<Arc<str>>

Resolve a short alias to a full namespace name in current_ns.

pub fn resolve_auto_keyword( &self, current_ns: &str, name: &str, ) -> Result<String, String>

Resolve an auto-resolved keyword name (the text after ::) to its fully-qualified ns/name form.

::kw qualifies with current_ns directly; ::alias/kw looks alias up in current_ns’s alias table (populated by (require '[... :as alias])) and qualifies with the resolved namespace.

pub fn get_or_create_ns(&self, name: &str) -> GcPtr<Namespace>

Return the namespace with this name, creating it if it doesn’t exist.

pub fn intern(&self, ns_name: &str, name: Arc<str>, val: Value) -> GcPtr<Var>

Intern name with val in the given namespace, returning the Var.

pub fn lookup_var(&self, ns_name: &str, sym_name: &str) -> Option<GcPtr<Var>>

Look up a Var in the named namespace (interns only).

pub fn lookup_in_ns(&self, ns_name: &str, sym_name: &str) -> Option<Value>

Look up a value in ns_name: checks interns then refers. Routes through the dynamic binding stack so binding overrides work.

pub fn lookup_var_in_ns( &self, ns_name: &str, sym_name: &str, ) -> Option<GcPtr<Var>>

Look up the raw Var (not its value) in ns_name: interns then refers.

pub fn refer_all(&self, dst_ns: &str, src_ns: &str)

Copy all interns from src_ns into dst_ns as refers.

pub fn refer_named(&self, dst_ns: &str, src_ns: &str, names: &[Arc<str>])

Copy selected interns from src_ns into dst_ns as refers.

pub fn add_alias(&self, current_ns: &str, alias: &str, full_ns: &str)

Register alias → full_ns in current_ns’s alias table.

pub fn id(&self) -> u64

Process-unique identity of this runtime instance.

pub fn tiers(&self) -> &Arc<Tiers>

This runtime’s Tier-1/Tier-2 state.

pub fn ir_cache(&self) -> &IrCache

This runtime’s cache of lowered IR.

pub fn jit(&self) -> &JitState

This runtime’s JIT counters, profiles, and native-code tables.

pub fn jit_backend(&self) -> Option<Arc<dyn JitBackend>>

The JIT compiler attached to this runtime, if any.

None when no JIT is linked or installed; callers then keep to the interpreter tiers. Installed by cljrs_compiler::jit::install.

pub fn execution_mode(&self) -> ExecutionMode

How this runtime executes function calls.

pub fn tier_state(&self) -> TierState

Which tiers are live right now.

pub fn set_tier_state(&self, tier: TierState)

Raise the live tier state. Called once by the runtime builder after the bootstrap completes; lowering the tier is not supported, so a request below the current state is ignored.

pub fn ir_enabled(&self) -> bool

True when IR may be lowered, cached, and interpreted. This is the gate the old compiler_ready flag served.

pub fn eval(&self, form: &Form, env: &mut Env) -> EvalResult

Evaluate form in env.

pub fn call_cljrs_fn( &self, func: &CljxFn, args: &[Value], env: &mut Env, ) -> EvalResult

Call a Clojure function, taking the path this runtime’s ExecutionMode selects.

This is the single function-call dispatch point: tree walk, tier-1 IR, and JIT-native execution are all reached from here.

pub fn on_fn_defined(&self, f: &CljxFn, env: &mut Env)

Notify the active tier that a new fn* was defined.

In a tiered runtime with IR enabled this eagerly lowers the function (when eager lowering is on); in every other mode it does nothing.

pub fn set_async_runtime(&self, rt: Arc<dyn AsyncRuntime>)

Install an async runtime. Called once by cljrs_async::init. Subsequent calls are silently ignored (first writer wins).

pub fn async_runtime(&self) -> Option<Arc<dyn AsyncRuntime>>

Return the async runtime, if one has been registered.

pub fn get_ns_git_context(&self, ns_name: &str) -> Option<(Arc<str>, Arc<str>)>

Return (source_file, git_repo_root) for the named namespace, if both have been populated by the loader.

pub fn cache_versioned(&self, ns: &str, name: &str, commit: &str, val: Value)

Store a resolved versioned value in the cache. Key: "<ns>/<name>@<commit>".

pub fn get_cached_versioned( &self, ns: &str, name: &str, commit: &str, ) -> Option<Value>

Retrieve a previously resolved versioned value, if cached.

pub fn cache_versioned_ns(&self, ns: &str, commit: &str)

Mark namespace name@commit as loaded in the standard loaded set.

pub fn record_versioned_source(&self, versioned_ns: &str, src: &str)

Record the source text of a versioned namespace fetched from git. Key: "<ns>@<commit>". Consumed by the AOT compiler for embedding.

pub fn versioned_sources_snapshot(&self) -> Vec<(Arc<str>, Arc<str>)>

Snapshot of all versioned sources fetched this session, sorted by key.

pub fn set_versioned_offline(&self, offline: bool)

Restrict versioned-namespace resolution to embedded builtin sources (no git). Called by AOT harness binaries, which embed every pinned source discovered at compile time.

pub fn versioned_offline(&self) -> bool

True when versioned namespaces may only come from embedded sources.

pub fn set_native_provenance(&self, ns: &str, commit: &str)

Record the git commit a native (Rust-backed) package was built from. Called at registration time (Registry::set_provenance or the register_provenance! inventory entry in cljrs-interop).

pub fn native_provenance_for(&self, ns: &str) -> Option<Arc<str>>

The recorded provenance commit for a native package’s namespace.

pub fn set_enforce_native_versions(&self, enforce: bool)

Make pinned-native provenance mismatches hard errors.

pub fn enforce_native_versions(&self) -> bool

True when pinned-native provenance mismatches are errors.

pub fn set_pinned_native_loader(&self, loader: PinnedNativeLoader)

Install the pinned-native package loader (called once by cljrs::native::pinned::install; first writer wins).

pub fn set_native_require_loader(&self, loader: NativeRequireLoader)

Install the native-dependency require loader (called once by cljrs::native::pinned::install; first writer wins).

pub fn vcs(&self) -> Option<Arc<dyn VcsProvider>>

The installed VCS backend, or None when this build has none (see crate::env::vcs). Callers must degrade gracefully: “no provider” means “this source file is not in a git repository”.

pub fn set_vcs_provider(&self, provider: Option<Arc<dyn VcsProvider>>)

Replace the VCS backend. Lets an embedder that built without the deps feature supply its own git implementation, or a sandboxed host remove the default one (None) so no versioned resolution can reach the filesystem’s git history.

Drops every cached signature verdict: those were reached by the outgoing provider, against its trust set and its view of the repository, and say nothing about what the incoming one would decide for the same (repo, commit). Keeping them would let a permissive provider launder an approval for source a later provider serves.

pub fn invalidate_signature_cache(&self)

Forget every cached signature verdict, so the next check_commit_signature re-asks the current provider. Called whenever the thing that produced those verdicts changes: the provider itself, or its trusted-key set.

pub fn check_commit_signature( &self, repo_root: &str, commit: &str, ) -> EvalResult<()>

If :verify-commit-signatures is enabled, verify that commit inside repo_root carries a valid GPG or SSH signature.

Returns Ok(()) immediately when the feature is off. On the happy path the result is cached per (repo_root, commit) so each commit is only verified once per session. On failure returns EvalError::CommitSignatureVerificationFailed.

If verification is demanded but this build has no VCS provider, the check fails: silently accepting an unverifiable commit would defeat the flag the user explicitly turned on.

pub fn load_trusted_signers(&self, config: &DepsConfig) -> usize

Build the trusted-signer key set from a parsed cljrs.edn config and install it, so subsequent check_commit_signature calls verify against it. Inline keys are parsed directly; File entries are read from disk. Returns the number of keys loaded; warns (to stderr) on any key that fails to load rather than aborting. Returns 0 when this build has no VCS provider, since there is nothing that could consume the keys.

Replacing the trust set invalidates the signature cache for the same reason replacing the provider does: a verdict reached under the old keys is not a verdict under the new ones. (In the normal flow this runs at session start, before anything has been verified.)

Trait Implementations

impl Debug for GlobalEnv

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

Formats the value using the given formatter.