Struct ReferenceMatch 

pub struct ReferenceMatch {
    pub match_id: String,
    pub span: Span,
    pub referenced_symbol: String,
    pub reference_kind: Option<String>,
    pub target_symbol_id: Option<String>,
}

Reference match result for refs command

Represents a reference to a symbol, including the location of the reference (Span), the name of the symbol being referenced, an optional reference kind for categorization (e.g., “call”, “read”, “write”), and the stable symbol ID of the referenced symbol for cross-run correlation.

Examples

Creating a reference match:

use magellan::output::command::{Span, ReferenceMatch};

let span = Span::new("main.rs".into(), 10, 14, 2, 4, 2, 8);
let reference = ReferenceMatch::new(
    span,
    "println".into(),  // referenced_symbol
    Some("call".into()), // reference_kind
    Some("abc123def456".into()), // target_symbol_id
);

assert_eq!(reference.referenced_symbol, "println");
assert_eq!(reference.reference_kind, Some("call".into()));
assert_eq!(reference.target_symbol_id, Some("abc123def456".into()));

Fields

match_id: String

Stable match ID

Generated from referenced symbol, file path, and byte position. See ReferenceMatch::generate_match_id for details.

span: Span

Reference span (location where the reference occurs)

referenced_symbol: String

Referenced symbol name

The name of the symbol being referenced (e.g., a function or variable name).

reference_kind: Option<String>

Reference kind (optional, for categorization)

Examples: “call”, “read”, “write”, “type_ref”, etc.

target_symbol_id: Option<String>

Stable symbol ID of the referenced symbol

This is the stable identifier (computed from language, FQN, and span) of the symbol being referenced. When present, it enables stable correlation across different indexing runs and database snapshots.

This field is optional for backward compatibility with existing JSON consumers. Symbols indexed before this feature was added will have None here.

Implementations

impl ReferenceMatch

pub fn generate_match_id( referenced_symbol: &str, file_path: &str, byte_start: usize, ) -> String

Generate a stable match ID for a reference

Uses DefaultHasher to combine the referenced symbol name, file path, and byte position into a unique hexadecimal identifier with a “ref_” prefix.

Algorithm

The hash combines:

• Referenced symbol name (e.g., “println”)
• File path (e.g., “src/main.rs”)
• Byte start position (e.g., 42)

The result is prefixed with “ref_” to distinguish reference IDs from symbol IDs.

Examples

use magellan::output::command::ReferenceMatch;

let id1 = ReferenceMatch::generate_match_id("println", "main.rs", 10);
let id2 = ReferenceMatch::generate_match_id("println", "main.rs", 10);
let id3 = ReferenceMatch::generate_match_id("foo", "main.rs", 10);

assert_eq!(id1, id2);  // Same inputs = same ID
assert_ne!(id1, id3);  // Different symbol = different ID
assert!(id1.starts_with("ref_"));  // Has prefix

pub fn new( span: Span, referenced_symbol: String, reference_kind: Option<String>, target_symbol_id: Option<String>, ) -> Self

Create a new ReferenceMatch

Constructs a ReferenceMatch with a stable match_id automatically generated using ReferenceMatch::generate_match_id.

Parameters

• span: Location where the reference occurs in source code
• referenced_symbol: Name of the symbol being referenced
• reference_kind: Optional kind categorization (e.g., “call”, “read”, “write”)
• target_symbol_id: Optional stable symbol ID of the referenced symbol

Examples

use magellan::output::command::{Span, ReferenceMatch};

let span = Span::new("main.rs".into(), 10, 14, 2, 4, 2, 8);
let reference = ReferenceMatch::new(
    span,
    "println".into(),
    Some("call".into()),
    Some("abc123def456".into()),
);

assert_eq!(reference.referenced_symbol, "println");
assert!(!reference.match_id.is_empty());
assert_eq!(reference.target_symbol_id, Some("abc123def456".into()));

Trait Implementations

impl Clone for ReferenceMatch

fn clone(&self) -> ReferenceMatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReferenceMatch

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReferenceMatch

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ReferenceMatch

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

where __S: Serializer,

Serialize this value into the given Serde serializer.