Struct OriginMap 

pub struct OriginMap {
    pub definition: HashMap<NodeId, CstNodeId>,
    pub value: HashMap<NodeId, CstNodeId>,
    pub key: HashMap<(NodeId, ObjectKey), CstNodeId>,
    pub key_span: HashMap<(NodeId, ObjectKey), InputSpan>,
    pub key_span_by_cst: HashMap<(CstNodeId, ObjectKey), InputSpan>,
}

Origin tracking for document nodes and map keys.

This structure provides span resolution for error reporting:

• definition: Where the node’s key/name is defined (for MissingRequiredField)
• value: The full value expression (for TypeMismatch, etc.)
• key: Maps (MapNodeId, ObjectKey) to the key’s CstNodeId (for precise key spans)

Fields

definition: HashMap<NodeId, CstNodeId>

Definition span (where the node’s key/name is defined). Only the first definition is kept (via entry().or_insert()).

value: HashMap<NodeId, CstNodeId>

Value span (the full value expression). Later values overwrite earlier ones.

key: HashMap<(NodeId, ObjectKey), CstNodeId>

(MapNodeId, ObjectKey) -> key’s CstNodeId. Used for precise error spans on map keys.

key_span: HashMap<(NodeId, ObjectKey), InputSpan>

Direct span storage for special cases (e.g., split float keys). Used when we need precise sub-spans that don’t correspond to a single CST node.

key_span_by_cst: HashMap<(CstNodeId, ObjectKey), InputSpan>

CST-based key span storage: (CstNodeId, ObjectKey) -> InputSpan. Used for error reporting when we only have the CST node ID, not the document NodeId.

Implementations

impl OriginMap

pub fn new() -> Self

Create a new empty OriginMap.

pub fn record_definition(&mut self, node_id: NodeId, cst_node_id: CstNodeId)

Record a definition span for a node (typically the key). Only the first definition is kept.

pub fn record_value(&mut self, node_id: NodeId, cst_node_id: CstNodeId)

Record a value span for a node (the full expression). Later values overwrite earlier ones.

pub fn record_key( &mut self, map_node_id: NodeId, key: ObjectKey, cst_node_id: CstNodeId, )

Record a map key origin.

pub fn record_key_span( &mut self, map_node_id: NodeId, key: ObjectKey, span: InputSpan, )

Record a map key origin with direct InputSpan. Used for special cases where the key span doesn’t correspond to a CST node.

pub fn record_key_span_by_cst( &mut self, cst_node_id: CstNodeId, key: ObjectKey, span: InputSpan, )

Record a map key origin with direct InputSpan, indexed by CST node ID. Used for error reporting when we only have the CST node ID.

pub fn get_value_span(&self, node_id: NodeId, cst: &Cst) -> Option<InputSpan>

Get the value span for a node (the full value expression). Used for TypeMismatch and other value-related errors.

pub fn get_definition_span( &self, node_id: NodeId, cst: &Cst, ) -> Option<InputSpan>

Get the definition span for a node (where the key is defined). Used for MissingRequiredField errors to point to where the record is defined.

pub fn get_key_span( &self, map_node_id: NodeId, key: &ObjectKey, cst: &Cst, ) -> Option<InputSpan>

Get the span for a specific map key.

Trait Implementations

impl Clone for OriginMap

fn clone(&self) -> OriginMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OriginMap

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

Formats the value using the given formatter.

impl Default for OriginMap

fn default() -> OriginMap

Returns the “default value” for a type.

impl PartialEq for OriginMap

fn eq(&self, other: &OriginMap) -> 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 Eq for OriginMap

impl StructuralPartialEq for OriginMap