test(fluent-syntax): Update test handling to support spans

Author: Ertanic

fluent-syntax/Cargo.toml

@@ -64,3 +64,6 @@ required-features = ["json"]
 name = "parser_fixtures"
 path = "tests/parser_fixtures.rs"
 required-features = ["json"]
+
+[lib]
+doctest = false

fluent-syntax/src/ast/mod.rs

@@ -88,9 +88,8 @@ mod helper;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use std::ops::Deref;
 #[cfg(feature = "spans")]
-use std::ops::Range;
+use std::ops::{Deref, Range};
 
 /// Root node of a Fluent Translation List.
 ///
@@ -1571,4 +1570,4 @@ impl Deref for Span {
     fn deref(&self) -> &Self::Target {
         &self.0
     }
-}
+}

fluent-syntax/src/parser/core.rs

@@ -3,7 +3,9 @@ use super::{
     errors::{ErrorKind, ParserError},
     slice::Slice,
 };
-use crate::ast::{self, Span};
+use crate::ast;
+#[cfg(feature = "spans")]
+use crate::ast::Span;
 
 pub type Result<T> = std::result::Result<T, ParserError>;
 

fluent-syntax/src/serializer.rs

@@ -580,6 +580,7 @@ mod test {
         let one_variant = Variant {
             key: VariantKey::Identifier {
                 name: "one",
+                #[cfg(feature = "spans")]
                 span: Span::default(),
             },
             value: Pattern {

fluent-syntax/tests/helper/mod.rs

@@ -13,7 +13,7 @@ fn adapt_pattern(pattern: &mut ast::Pattern<String>, crlf: bool) {
     let mut elements = vec![];
     for element in &pattern.elements {
         match element {
-            ast::PatternElement::TextElement { value } => {
+            ast::PatternElement::TextElement { value, .. } => {
                 let mut start = 0;
                 let len = value.len();
                 for (i, b) in value.as_bytes().iter().enumerate() {
@@ -22,29 +22,53 @@ fn adapt_pattern(pattern: &mut ast::Pattern<String>, crlf: bool) {
                             if i > start {
                                 let chunk = &value.as_bytes()[start..=i - 1];
                                 let value = String::from_utf8_lossy(chunk).to_string();
-                                elements.push(ast::PatternElement::TextElement { value });
+                                elements.push(ast::PatternElement::TextElement {
+                                    value,
+                                    #[cfg(feature = "spans")]
+                                    span: ast::Span(start..i),
+                                });
                             }
+
                             elements.push(ast::PatternElement::TextElement {
                                 value: "\n".to_string(),
+                                #[cfg(feature = "spans")]
+                                span: ast::Span(i..i + 1),
                             });
                         } else {
                             let chunk = &value.as_bytes()[start..=i];
                             let value = String::from_utf8_lossy(chunk).to_string();
-                            elements.push(ast::PatternElement::TextElement { value });
+                            elements.push(ast::PatternElement::TextElement {
+                                value,
+                                #[cfg(feature = "spans")]
+                                span: ast::Span(start..i + 1),
+                            });
                         }
                         start = i + 1;
                     }
                 }
+
                 if start < len {
                     let chunk = &value.as_bytes()[start..len];
                     let value = String::from_utf8_lossy(chunk).to_string();
-                    elements.push(ast::PatternElement::TextElement { value });
+                    elements.push(ast::PatternElement::TextElement {
+                        value,
+                        #[cfg(feature = "spans")]
+                        span: ast::Span(start..len),
+                    });
                 }
             }
-            ast::PatternElement::Placeable { expression } => {
+            ast::PatternElement::Placeable {
+                expression,
+                #[cfg(feature = "spans")]
+                span,
+            } => {
                 let mut expression = expression.clone();
                 adapt_expression(&mut expression, crlf);
-                elements.push(ast::PatternElement::Placeable { expression });
+                elements.push(ast::PatternElement::Placeable {
+                    expression,
+                    #[cfg(feature = "spans")]
+                    span: span.clone(),
+                });
             }
         }
     }
@@ -58,7 +82,7 @@ fn adapt_expression(expression: &mut ast::Expression<String>, crlf: bool) {
                 adapt_pattern(&mut variant.value, crlf);
             }
         }
-        ast::Expression::Inline(_) => {}
+        ast::Expression::Inline(..) => {}
     }
 }