Add span to VariantKey

Author: Ertanic

fluent-bundle/src/resolver/expression.rs

@@ -32,8 +32,8 @@ impl<'bundle> WriteValue<'bundle> for ast::Expression<&'bundle str> {
                     FluentValue::String(_) | FluentValue::Number(_) => {
                         for variant in variants {
                             let key = match variant.key {
-                                ast::VariantKey::Identifier { name } => name.into(),
-                                ast::VariantKey::NumberLiteral { value } => {
+                                ast::VariantKey::Identifier { name, .. } => name.into(),
+                                ast::VariantKey::NumberLiteral { value, .. } => {
                                     FluentValue::try_number(value)
                                 }
                             };

fluent-syntax/src/ast/mod.rs

@@ -785,8 +785,16 @@ pub struct Variant<S> {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(tag = "type"))]
 pub enum VariantKey<S> {
-    Identifier { name: S },
-    NumberLiteral { value: S },
+    Identifier {
+        name: S,
+        #[cfg(feature = "spans")]
+        span: Span,
+    },
+    NumberLiteral {
+        value: S,
+        #[cfg(feature = "spans")]
+        span: Span,
+    },
 }
 
 /// Fluent [`Comment`].
@@ -1539,12 +1547,12 @@ pub enum Expression<S> {
 ///
 /// ```
 /// #![cfg(feature = "spans")]
-/// 
+///
 /// use fluent_syntax::parser;
 /// use fluent_syntax::ast::*;
-/// 
+///
 /// let ftl = "hello-world = Hello, World!";
-/// 
+///
 /// let resource = parser::parse(ftl).expect("Failed to parse an FTL resource.");
 /// let Entry::Message(Message { ref id, .. }) = resource.body[0] else { unreachable!() };
 ///  
@@ -1563,4 +1571,4 @@ impl Deref for Span {
     fn deref(&self) -> &Self::Target {
         &self.0
     }
-}
+}

fluent-syntax/src/parser/core.rs

@@ -3,7 +3,7 @@ use super::{
     errors::{ErrorKind, ParserError},
     slice::Slice,
 };
-use crate::ast;
+use crate::ast::{self, Span};
 
 pub type Result<T> = std::result::Result<T, ParserError>;
 
@@ -248,12 +248,22 @@ where
         self.skip_blank();
 
         let key = if self.is_number_start() {
+            #[cfg(feature = "spans")]
+            let start = self.ptr;
+
             ast::VariantKey::NumberLiteral {
                 value: self.get_number_literal()?,
+                #[cfg(feature = "spans")]
+                span: Span(start..self.ptr),
             }
         } else {
+            #[cfg(feature = "spans")]
+            let start = self.ptr;
+
             ast::VariantKey::Identifier {
                 name: self.get_identifier()?.name,
+                #[cfg(feature = "spans")]
+                span: Span(start..self.ptr),
             }
         };
 

fluent-syntax/src/serializer.rs

@@ -325,7 +325,7 @@ impl Serializer {
 
     fn serialize_variant_key<'s, S: Slice<'s>>(&mut self, key: &VariantKey<S>) {
         match key {
-            VariantKey::NumberLiteral { value } | VariantKey::Identifier { name: value } => {
+            VariantKey::NumberLiteral { value, .. } | VariantKey::Identifier { name: value, .. } => {
                 self.writer.write_literal(value.as_ref());
             }
         }
@@ -577,7 +577,7 @@ mod test {
         let mut ast = parse(message).expect("failed to parse ftl resource");
 
         let one_variant = Variant {
-            key: VariantKey::Identifier { name: "one" },
+            key: VariantKey::Identifier { name: "one", span: Span::default() },
             value: Pattern {
                 elements: vec![
                     PatternElement::Placeable {