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

@@ -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", span: Span::default() },
+            key: VariantKey::Identifier { name: "one", #[cfg(feature = "spans")] span: Span::default() },
             value: Pattern {
                 elements: vec![
                     PatternElement::Placeable {

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,33 @@ 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 +62,7 @@ fn adapt_expression(expression: &mut ast::Expression<String>, crlf: bool) {
                 adapt_pattern(&mut variant.value, crlf);
             }
         }
-        ast::Expression::Inline(_) => {}
+        ast::Expression::Inline(..) => {}
     }
 }