Struct Spanned 

pub struct Spanned<T> {
    pub value: T,
    pub start: Location,
    pub end: Location,
}

A value annotated with source span information.

During serialization, Spanned<T> serializes transparently as T. During deserialization from a YAML string via from_str or from_str_with_config, real source locations are populated. When deserializing via from_value, locations default to zero.

Examples

use noyalib::Spanned;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct Config {
    port: Spanned<u16>,
}

Limitation: #[serde(flatten)]

Spanned<T> cannot be the target of a #[serde(flatten)] field. The limitation is in serde itself: FlatMapDeserializer::deserialize_struct uses FlatStructAccess, which filters the residue by the FIELDS list passed to deserialize_struct. Because Spanned advertises internal magic field names ($__noyalib_value and friends) that never appear in real input, every residue entry is filtered out before our visitor runs.

The supported pattern is to flatten a bare crate::Value (which works today) and look up source spans through the crate::cst::Document API separately:

// Works.
#[derive(Deserialize)]
struct Config {
    name: String,
    #[serde(flatten)]
    extra: noyalib::Value,
}

// Errors with a clear message at deserialize time.
#[derive(Deserialize)]
struct AlsoConfig {
    name: String,
    #[serde(flatten)]
    extra: noyalib::Spanned<noyalib::Value>,  // not supported
}

If the use case is “agent edits YAML, also wants source position of each unflattened field”, parse the source via crate::cst::parse_document and use crate::cst::Document::span_at / crate::cst::Document::comments_at — those resolve byte ranges by path, work post-edit, and are not constrained by serde’s flatten mechanics.

Fields

value: T

The deserialized value.

Examples

use noyalib::Spanned;
let s = Spanned::new("x".to_string());
assert_eq!(s.value, "x");

start: Location

Start location in the source.

Examples

use noyalib::Spanned;
let s: Spanned<i32> = Spanned::new(1);
assert_eq!(s.start.line(), 0);

end: Location

End location in the source.

Examples

use noyalib::Spanned;
let s: Spanned<i32> = Spanned::new(1);
assert_eq!(s.end.line(), 0);

Implementations

impl<T> Spanned<T>

pub fn new(value: T) -> Self

Create a new spanned value with sentinel zero locations (line = 0, column = 0, index = 0).

The sentinel form exists so callers can synthesise a Spanned<T> without owning a parser context; it is distinguishable from a parsed location because parsed locations always have line >= 1 and column >= 1. Use the deserialisation path (#[derive(Deserialize)] with a Spanned<T> field) when authentic source positions are required.

Examples

use noyalib::Spanned;
let s = Spanned::new(42_u16);
assert_eq!(*s, 42);
// Sentinel — distinguishable from a parsed location.
assert_eq!(s.start.line(), 0);

pub fn into_inner(self) -> T

Unwrap into the inner value.

Examples

use noyalib::Spanned;
let s = Spanned::new("hello".to_string());
assert_eq!(s.into_inner(), "hello");

Trait Implementations

impl<T: Clone> Clone for Spanned<T>

fn clone(&self) -> Spanned<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Spanned<T>

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

Formats the value using the given formatter.

impl<T> Deref for Spanned<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Spanned<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Eq> Eq for Spanned<T>

impl<T> From<T> for Spanned<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Spanned<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Spanned<T>

fn eq(&self, other: &Spanned<T>) -> 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<T: Serialize> Serialize for Spanned<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq> StructuralPartialEq for Spanned<T>