helm-schema-ir 0.0.7

use std::collections::BTreeMap;
use std::rc::Rc;

use helm_schema_ast::DefineIndex;

use crate::analysis_db::IrAnalysisDb;
use crate::contract::ContractIr;

/// Immutable non-values inputs supplied by the Helm render environment.
///
/// These inputs may decide control flow, but never become `.Values` schema
/// evidence themselves. Static root strings use path segments rather than a
/// dotted spelling so literal map keys containing dots remain unambiguous.
#[derive(Clone, Debug, Default)]
pub struct SymbolicPolicy {
    /// Chart-authored string defaults executed through `tpl`.
    pub chart_default_strings: BTreeMap<String, String>,
    /// Normalized Kubernetes version used by `.Capabilities.KubeVersion`.
    pub kubernetes_version: Option<String>,
    /// Exact scalar strings beneath immutable roots such as `.Chart`.
    pub static_root_strings: BTreeMap<Vec<String>, String>,
}

/// Reusable state for generating symbolic IR across many templates that
/// share one [`DefineIndex`].
///
/// The context owns exact parse/helper-analysis caches. Reusing it across
/// templates avoids recomputing helper bodies without changing analysis
/// semantics; a cache miss and cache hit return the same structural facts.
#[derive(Clone)]
pub struct SymbolicIrContext {
    analysis_db: Rc<IrAnalysisDb>,
}

impl SymbolicIrContext {
    /// Creates a reusable symbolic-analysis context for indexed chart sources.
    #[tracing::instrument(skip_all)]
    pub fn new(defines: &DefineIndex) -> Self {
        Self {
            analysis_db: Rc::new(IrAnalysisDb::new(defines)),
        }
    }

    /// Build a context that can execute chart-authored string defaults when
    /// a `tpl` call selects them. The strings are not general inference
    /// evidence; they are consulted only at that explicit execution boundary.
    #[must_use]
    pub fn with_chart_default_strings(
        defines: &DefineIndex,
        chart_default_strings: BTreeMap<String, String>,
    ) -> Self {
        Self::with_policy(
            defines,
            SymbolicPolicy {
                chart_default_strings,
                ..SymbolicPolicy::default()
            },
        )
    }

    /// Build a context carrying immutable render-policy inputs.
    #[must_use]
    pub fn with_policy(defines: &DefineIndex, policy: SymbolicPolicy) -> Self {
        Self {
            analysis_db: Rc::new(IrAnalysisDb::with_policy(defines, policy)),
        }
    }

    /// Generate the opaque contract graph without finalizing it.
    ///
    /// Callers that need to combine, scope, or otherwise transform chart-local
    /// contracts should use this method and derive schema facts with
    /// [`ContractIr::finalize`]. Inspection output can finalize the graph once
    /// and ask the resulting contract for its stable document.
    #[must_use]
    pub fn generate_contract_ir(&self, src: &str) -> ContractIr {
        self.generate_contract_ir_with_provenance(src, None)
    }

    /// Builds contract IR while attaching a logical template source path.
    #[must_use]
    pub fn generate_contract_ir_for_source(&self, src: &str, source_path: &str) -> ContractIr {
        self.generate_contract_ir_with_provenance(src, Some(source_path))
    }

    /// Evaluate a template into the abstract fragment domain, reusing this
    /// context's memoized helper analyses.
    #[must_use]
    #[cfg(test)]
    pub(crate) fn eval_document_fragment(
        &self,
        src: &str,
    ) -> crate::fragment_eval::EvaluatedDocument {
        crate::fragment_eval::eval_document(src, None, &self.analysis_db)
    }

    fn generate_contract_ir_with_provenance(
        &self,
        src: &str,
        source_path: Option<&str>,
    ) -> ContractIr {
        let document = crate::fragment_eval::eval_document(src, source_path, &self.analysis_db);
        let mut contract = crate::fragment_eval::contract_ir_from_document(&document);
        for name in &document.observed_facts.values_root_helper_includes {
            contract.extend_values_program_wrappers(
                self.analysis_db
                    .program_wrapper_sentinels(name)
                    .into_iter()
                    .map(|(key, spread)| helm_schema_core::ValuesProgramWrapper {
                        scope_path: helm_schema_core::ValuesPath::default(),
                        key,
                        spread,
                    }),
            );
        }
        contract.extend_values_program_wrapper_exclusions(
            document.pre_rewrite_strict_paths.iter().cloned(),
        );
        contract
    }
}