src/compare/mod.rs

@@ -16,10 +16,8 @@ pub(crate) use compare_field::EmacsField;
 pub(crate) use elisp_fact::ElispFact;
 pub use sexp::sexp;
 pub(crate) use sexp::unquote;
-pub(crate) use sexp::TextWithProperties;
 pub use sexp::Token;
 pub(crate) use util::get_emacs_standard_properties;
 pub(crate) use util::get_property;
 pub(crate) use util::get_property_quoted_string;
-pub(crate) use util::maybe_token_to_usize;
 pub(crate) use util::EmacsStandardProperties;

src/compare/util.rs

@@ -203,7 +203,7 @@ pub(crate) fn get_emacs_standard_properties(
     })
 }
 
-pub(crate) fn maybe_token_to_usize(
+fn maybe_token_to_usize(
     token: Option<&Token<'_>>,
 ) -> Result<Option<usize>, Box<dyn std::error::Error>> {
     Ok(token

src/lib.rs

@@ -3,7 +3,6 @@
 #![feature(path_file_prefix)]
 #![feature(is_sorted)]
 #![feature(test)]
-#![feature(iter_intersperse)]
 // TODO: #![warn(missing_docs)]
 #![allow(clippy::bool_assert_comparison)] // Sometimes you want the long form because its easier to see at a glance.
 

src/wasm/additional_property.rs

@@ -1,7 +1,5 @@
-use std::borrow::Cow;
 use std::collections::HashMap;
 
-use serde::Deserialize;
 use serde::Serialize;
 
 use super::macros::to_wasm;
@@ -10,35 +8,32 @@ use super::WasmAstNode;
 use crate::types::AffiliatedKeywordValue;
 use crate::types::AffiliatedKeywords;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
 #[serde(untagged)]
-pub enum AdditionalPropertyValue {
+pub enum AdditionalPropertyValue<'s, 'p> {
-    SingleString(String),
+    SingleString(&'s str),
-    ListOfStrings(Vec<String>),
+    ListOfStrings(Vec<&'s str>),
     OptionalPair {
-        optval: Option<String>,
+        optval: Option<&'s str>,
-        val: String,
+        val: &'s str,
-    },
-    ObjectTree {
-        #[serde(rename = "object-tree")]
-        object_tree: Vec<(Option<Vec<WasmAstNode>>, Vec<WasmAstNode>)>,
     },
+    ObjectTree(Vec<(Option<Vec<WasmAstNode<'s, 'p>>>, Vec<WasmAstNode<'s, 'p>>)>),
 }
 
-#[derive(Debug, Serialize, Deserialize, Default)]
+#[derive(Debug, Serialize, Default)]
-pub struct AdditionalProperties {
+pub struct AdditionalProperties<'s, 'p> {
     #[serde(flatten)]
-    pub(crate) properties: HashMap<String, AdditionalPropertyValue>,
+    pub(crate) properties: HashMap<String, AdditionalPropertyValue<'s, 'p>>,
 }
 
-impl AdditionalProperties {
+impl<'s, 'p> AdditionalProperties<'s, 'p> {
     pub(crate) fn get_elisp_names<'c>(&'c self) -> impl Iterator<Item = String> + 'c {
         self.properties.keys().map(move |key| format!(":{}", key))
     }
 }
 
 to_wasm!(
-    AdditionalProperties,
+    AdditionalProperties<'s, 'p>,
     AffiliatedKeywords<'s>,
     original,
     wasm_context,
@@ -47,17 +42,15 @@ to_wasm!(
         for (name, val) in original.keywords.iter() {
             let converted_val = match val {
                 AffiliatedKeywordValue::SingleString(val) => {
-                    AdditionalPropertyValue::SingleString((*val).to_owned())
+                    AdditionalPropertyValue::SingleString(val)
                 }
                 AffiliatedKeywordValue::ListOfStrings(val) => {
-                    AdditionalPropertyValue::ListOfStrings(
+                    AdditionalPropertyValue::ListOfStrings(val.clone())
-                        val.iter().map(|s| (*s).to_owned()).collect(),
-                    )
                 }
                 AffiliatedKeywordValue::OptionalPair { optval, val } => {
                     AdditionalPropertyValue::OptionalPair {
-                        optval: optval.map(|s| (*s).to_owned()),
+                        optval: optval.clone(),
-                        val: (*val).to_owned(),
+                        val: val,
                     }
                 }
                 AffiliatedKeywordValue::ObjectTree(val) => {
@@ -71,7 +64,7 @@ to_wasm!(
                                     .map(|child| {
                                         child
                                             .to_wasm(wasm_context.clone())
-                                            .map(Into::<WasmAstNode>::into)
+                                            .map(Into::<WasmAstNode<'_, '_>>::into)
                                     })
                                     .collect::<Result<Vec<_>, _>>()?,
                             )
@@ -83,14 +76,14 @@ to_wasm!(
                             .map(|child| {
                                 child
                                     .to_wasm(wasm_context.clone())
-                                    .map(Into::<WasmAstNode>::into)
+                                    .map(Into::<WasmAstNode<'_, '_>>::into)
                             })
                             .collect::<Result<Vec<_>, _>>()?;
 
                         ret.push((converted_optval, converted_value));
                     }
 
-                    AdditionalPropertyValue::ObjectTree { object_tree: ret }
+                    AdditionalPropertyValue::ObjectTree(ret)
                 }
             };
             additional_properties

src/wasm/angle_link.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::AngleLink;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmAngleLink {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmAngleLink<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmAngleLink,
+    WasmAngleLink<'s, 'p>,
     AngleLink<'s>,
     original,
     wasm_context,
-    { WasmAstNode::AngleLink(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmAngleLink {
-            Vec::new(),
+            standard_properties,
-            WasmAngleLink {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmAngleLink<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::AngleLink(self)
+    }
+}

src/wasm/ast_node.rs

@@ -1,4 +1,3 @@
-use serde::Deserialize;
 use serde::Serialize;
 
 use super::angle_link::WasmAngleLink;
@@ -59,84 +58,71 @@ use super::timestamp::WasmTimestamp;
 use super::underline::WasmUnderline;
 use super::verbatim::WasmVerbatim;
 use super::verse_block::WasmVerseBlock;
-use super::WasmStandardProperties;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmAstNodeWrapper<I> {
-    #[serde(rename = "ast-node")]
-    pub(crate) ast_node: String,
-    #[serde(rename = "standard-properties")]
-    pub(crate) standard_properties: WasmStandardProperties,
-    #[serde(rename = "children")]
-    pub(crate) children: Vec<WasmAstNode>,
-    #[serde(rename = "properties")]
-    pub(crate) properties: I,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
-pub enum WasmAstNode {
+pub enum WasmAstNode<'s, 'p> {
     // Document Nodes
-    Document(WasmAstNodeWrapper<WasmDocument>),
+    Document(WasmDocument<'s, 'p>),
-    Headline(WasmAstNodeWrapper<WasmHeadline>),
+    Headline(WasmHeadline<'s, 'p>),
-    Section(WasmAstNodeWrapper<WasmSection>),
+    Section(WasmSection<'s, 'p>),
     // Elements
-    Paragraph(WasmAstNodeWrapper<WasmParagraph>),
+    Paragraph(WasmParagraph<'s, 'p>),
-    PlainList(WasmAstNodeWrapper<WasmPlainList>),
+    PlainList(WasmPlainList<'s, 'p>),
-    PlainListItem(WasmAstNodeWrapper<WasmPlainListItem>),
+    PlainListItem(WasmPlainListItem<'s, 'p>),
-    CenterBlock(WasmAstNodeWrapper<WasmCenterBlock>),
+    CenterBlock(WasmCenterBlock<'s, 'p>),
-    QuoteBlock(WasmAstNodeWrapper<WasmQuoteBlock>),
+    QuoteBlock(WasmQuoteBlock<'s, 'p>),
-    SpecialBlock(WasmAstNodeWrapper<WasmSpecialBlock>),
+    SpecialBlock(WasmSpecialBlock<'s, 'p>),
-    DynamicBlock(WasmAstNodeWrapper<WasmDynamicBlock>),
+    DynamicBlock(WasmDynamicBlock<'s, 'p>),
-    FootnoteDefinition(WasmAstNodeWrapper<WasmFootnoteDefinition>),
+    FootnoteDefinition(WasmFootnoteDefinition<'s, 'p>),
-    Comment(WasmAstNodeWrapper<WasmComment>),
+    Comment(WasmComment<'s, 'p>),
-    Drawer(WasmAstNodeWrapper<WasmDrawer>),
+    Drawer(WasmDrawer<'s, 'p>),
-    PropertyDrawer(WasmAstNodeWrapper<WasmPropertyDrawer>),
+    PropertyDrawer(WasmPropertyDrawer<'s, 'p>),
-    NodeProperty(WasmAstNodeWrapper<WasmNodeProperty>),
+    NodeProperty(WasmNodeProperty<'s, 'p>),
-    Table(WasmAstNodeWrapper<WasmTable>),
+    Table(WasmTable<'s, 'p>),
-    TableRow(WasmAstNodeWrapper<WasmTableRow>),
+    TableRow(WasmTableRow<'s, 'p>),
-    VerseBlock(WasmAstNodeWrapper<WasmVerseBlock>),
+    VerseBlock(WasmVerseBlock<'s, 'p>),
-    CommentBlock(WasmAstNodeWrapper<WasmCommentBlock>),
+    CommentBlock(WasmCommentBlock<'s, 'p>),
-    ExampleBlock(WasmAstNodeWrapper<WasmExampleBlock>),
+    ExampleBlock(WasmExampleBlock<'s, 'p>),
-    ExportBlock(WasmAstNodeWrapper<WasmExportBlock>),
+    ExportBlock(WasmExportBlock<'s, 'p>),
-    SrcBlock(WasmAstNodeWrapper<WasmSrcBlock>),
+    SrcBlock(WasmSrcBlock<'s, 'p>),
-    Clock(WasmAstNodeWrapper<WasmClock>),
+    Clock(WasmClock<'s, 'p>),
-    DiarySexp(WasmAstNodeWrapper<WasmDiarySexp>),
+    DiarySexp(WasmDiarySexp<'s, 'p>),
-    Planning(WasmAstNodeWrapper<WasmPlanning>),
+    Planning(WasmPlanning<'s, 'p>),
-    FixedWidthArea(WasmAstNodeWrapper<WasmFixedWidthArea>),
+    FixedWidthArea(WasmFixedWidthArea<'s, 'p>),
-    HorizontalRule(WasmAstNodeWrapper<WasmHorizontalRule>),
+    HorizontalRule(WasmHorizontalRule<'s, 'p>),
-    Keyword(WasmAstNodeWrapper<WasmKeyword>),
+    Keyword(WasmKeyword<'s, 'p>),
-    BabelCall(WasmAstNodeWrapper<WasmBabelCall>),
+    BabelCall(WasmBabelCall<'s, 'p>),
-    LatexEnvironment(WasmAstNodeWrapper<WasmLatexEnvironment>),
+    LatexEnvironment(WasmLatexEnvironment<'s, 'p>),
     // Objects
-    Bold(WasmAstNodeWrapper<WasmBold>),
+    Bold(WasmBold<'s, 'p>),
-    Italic(WasmAstNodeWrapper<WasmItalic>),
+    Italic(WasmItalic<'s, 'p>),
-    Underline(WasmAstNodeWrapper<WasmUnderline>),
+    Underline(WasmUnderline<'s, 'p>),
-    StrikeThrough(WasmAstNodeWrapper<WasmStrikeThrough>),
+    StrikeThrough(WasmStrikeThrough<'s, 'p>),
-    Code(WasmAstNodeWrapper<WasmCode>),
+    Code(WasmCode<'s, 'p>),
-    Verbatim(WasmAstNodeWrapper<WasmVerbatim>),
+    Verbatim(WasmVerbatim<'s, 'p>),
-    PlainText(WasmAstNodeWrapper<WasmPlainText>),
+    PlainText(WasmPlainText<'s, 'p>),
-    RegularLink(WasmAstNodeWrapper<WasmRegularLink>),
+    RegularLink(WasmRegularLink<'s, 'p>),
-    RadioLink(WasmAstNodeWrapper<WasmRadioLink>),
+    RadioLink(WasmRadioLink<'s, 'p>),
-    RadioTarget(WasmAstNodeWrapper<WasmRadioTarget>),
+    RadioTarget(WasmRadioTarget<'s, 'p>),
-    PlainLink(WasmAstNodeWrapper<WasmPlainLink>),
+    PlainLink(WasmPlainLink<'s, 'p>),
-    AngleLink(WasmAstNodeWrapper<WasmAngleLink>),
+    AngleLink(WasmAngleLink<'s, 'p>),
-    OrgMacro(WasmAstNodeWrapper<WasmOrgMacro>),
+    OrgMacro(WasmOrgMacro<'s, 'p>),
-    Entity(WasmAstNodeWrapper<WasmEntity>),
+    Entity(WasmEntity<'s, 'p>),
-    LatexFragment(WasmAstNodeWrapper<WasmLatexFragment>),
+    LatexFragment(WasmLatexFragment<'s, 'p>),
-    ExportSnippet(WasmAstNodeWrapper<WasmExportSnippet>),
+    ExportSnippet(WasmExportSnippet<'s, 'p>),
-    FootnoteReference(WasmAstNodeWrapper<WasmFootnoteReference>),
+    FootnoteReference(WasmFootnoteReference<'s, 'p>),
-    Citation(WasmAstNodeWrapper<WasmCitation>),
+    Citation(WasmCitation<'s, 'p>),
-    CitationReference(WasmAstNodeWrapper<WasmCitationReference>),
+    CitationReference(WasmCitationReference<'s, 'p>),
-    InlineBabelCall(WasmAstNodeWrapper<WasmInlineBabelCall>),
+    InlineBabelCall(WasmInlineBabelCall<'s, 'p>),
-    InlineSourceBlock(WasmAstNodeWrapper<WasmInlineSourceBlock>),
+    InlineSourceBlock(WasmInlineSourceBlock<'s, 'p>),
-    LineBreak(WasmAstNodeWrapper<WasmLineBreak>),
+    LineBreak(WasmLineBreak<'s, 'p>),
-    Target(WasmAstNodeWrapper<WasmTarget>),
+    Target(WasmTarget<'s, 'p>),
-    StatisticsCookie(WasmAstNodeWrapper<WasmStatisticsCookie>),
+    StatisticsCookie(WasmStatisticsCookie<'s, 'p>),
-    Subscript(WasmAstNodeWrapper<WasmSubscript>),
+    Subscript(WasmSubscript<'s, 'p>),
-    Superscript(WasmAstNodeWrapper<WasmSuperscript>),
+    Superscript(WasmSuperscript<'s, 'p>),
-    TableCell(WasmAstNodeWrapper<WasmTableCell>),
+    TableCell(WasmTableCell<'s, 'p>),
-    Timestamp(WasmAstNodeWrapper<WasmTimestamp>),
+    Timestamp(WasmTimestamp<'s, 'p>),
 }
 
-impl WasmAstNode {}
+impl<'s, 'p> WasmAstNode<'s, 'p> {}

src/wasm/babel_call.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::BabelCall;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmBabelCall {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmBabelCall<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmBabelCall,
+    WasmBabelCall<'s, 'p>,
     BabelCall<'s>,
     original,
     wasm_context,
-    { WasmAstNode::BabelCall(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmBabelCall {
-            Vec::new(),
+            standard_properties,
-            WasmBabelCall {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmBabelCall<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::BabelCall(self)
+    }
+}

src/wasm/bold.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Bold;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmBold {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmBold<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmBold,
+    WasmBold<'s, 'p>,
     Bold<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Bold(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmBold {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmBold {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmBold<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Bold(self)
+    }
+}

src/wasm/center_block.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::CenterBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmCenterBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmCenterBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmCenterBlock,
+    WasmCenterBlock<'s, 'p>,
     CenterBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::CenterBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmCenterBlock {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmCenterBlock {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmCenterBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::CenterBlock(self)
+    }
+}

src/wasm/citation.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Citation;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmCitation {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmCitation<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmCitation,
+    WasmCitation<'s, 'p>,
     Citation<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Citation(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmCitation {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmCitation {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmCitation<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Citation(self)
+    }
+}

src/wasm/citation_reference.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::CitationReference;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmCitationReference {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmCitationReference<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmCitationReference,
+    WasmCitationReference<'s, 'p>,
     CitationReference<'s>,
     original,
     wasm_context,
-    { WasmAstNode::CitationReference(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmCitationReference {
-            Vec::new(),
+            standard_properties,
-            WasmCitationReference {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmCitationReference<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::CitationReference(self)
+    }
+}

src/wasm/clock.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Clock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmClock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmClock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmClock,
+    WasmClock<'s, 'p>,
     Clock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Clock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmClock {
-            Vec::new(),
+            standard_properties,
-            WasmClock {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmClock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Clock(self)
+    }
+}

src/wasm/code.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Code;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmCode {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmCode<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmCode,
+    WasmCode<'s, 'p>,
     Code<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Code(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmCode {
-            Vec::new(),
+            standard_properties,
-            WasmCode {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmCode<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Code(self)
+    }
+}

src/wasm/comment.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Comment;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmComment {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmComment<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmComment,
+    WasmComment<'s, 'p>,
     Comment<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Comment(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmComment {
-            Vec::new(),
+            standard_properties,
-            WasmComment {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmComment<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Comment(self)
+    }
+}

src/wasm/comment_block.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::CommentBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmCommentBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmCommentBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmCommentBlock,
+    WasmCommentBlock<'s, 'p>,
     CommentBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::CommentBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmCommentBlock {
-            Vec::new(),
+            standard_properties,
-            WasmCommentBlock {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmCommentBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::CommentBlock(self)
+    }
+}

src/wasm/diary_sexp.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::DiarySexp;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmDiarySexp {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmDiarySexp<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmDiarySexp,
+    WasmDiarySexp<'s, 'p>,
     DiarySexp<'s>,
     original,
     wasm_context,
-    { WasmAstNode::DiarySexp(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmDiarySexp {
-            Vec::new(),
+            standard_properties,
-            WasmDiarySexp {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmDiarySexp<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::DiarySexp(self)
+    }
+}

src/wasm/document.rs

@@ -1,33 +1,36 @@
 use std::path::PathBuf;
 
-use serde::Deserialize;
 use serde::Serialize;
 
 use super::additional_property::AdditionalProperties;
 use super::additional_property::AdditionalPropertyValue;
 use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+#[cfg(feature = "wasm_test")]
 use crate::compare::ElispFact;
 use crate::types::Document;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmDocument {
+#[serde(tag = "ast_node")]
+#[serde(rename = "org-data")]
+pub struct WasmDocument<'s, 'p> {
+    pub(crate) standard_properties: WasmStandardProperties,
     #[serde(flatten)]
-    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) additional_properties: AdditionalProperties<'s, 'p>,
-    #[serde(rename = "CATEGORY")]
+    pub(crate) children: Vec<WasmAstNode<'s, 'p>>,
-    pub(crate) category: Option<String>,
+    pub(crate) category: Option<&'p str>,
     pub(crate) path: Option<PathBuf>,
 }
 
 to_wasm!(
-    WasmDocument,
+    WasmDocument<'s, 'p>,
     Document<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Document(original) },
+    standard_properties,
-    { "org-data".into() },
     {
         let category = original.category.as_ref().map(String::as_str);
         let path = original.path.clone();
@@ -36,7 +39,7 @@ to_wasm!(
         for (name, val) in original.get_additional_properties().map(|node_property| {
             (
                 node_property.property_name.to_uppercase(),
-                AdditionalPropertyValue::SingleString(node_property.value.unwrap_or("").to_owned()),
+                AdditionalPropertyValue::SingleString(node_property.value.unwrap_or("")),
             )
         }) {
             additional_properties.properties.insert(name, val);
@@ -48,22 +51,34 @@ to_wasm!(
             .map(|child| {
                 child
                     .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
+                    .map(Into::<WasmAstNode<'_, '_>>::into)
             })
             .chain(original.children.iter().map(|child| {
                 child
                     .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
+                    .map(Into::<WasmAstNode<'_, '_>>::into)
             }))
             .collect::<Result<Vec<_>, _>>()?;
 
-        Ok((
+        Ok(WasmDocument {
+            standard_properties,
+            additional_properties,
             children,
-            WasmDocument {
+            category,
-                additional_properties,
+            path,
-                category: category.map(str::to_owned),
+        })
-                path,
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmDocument<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Document(self)
+    }
+}
+
+#[cfg(feature = "wasm_test")]
+impl<'s, 'p> ElispFact<'s> for WasmDocument<'s, 'p> {
+    fn get_elisp_name<'b>(&'b self) -> std::borrow::Cow<'s, str> {
+        "org-data".into()
+    }
+}

src/wasm/drawer.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Drawer;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmDrawer {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmDrawer<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmDrawer,
+    WasmDrawer<'s, 'p>,
     Drawer<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Drawer(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmDrawer {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmDrawer {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmDrawer<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Drawer(self)
+    }
+}

src/wasm/dynamic_block.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::DynamicBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmDynamicBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmDynamicBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmDynamicBlock,
+    WasmDynamicBlock<'s, 'p>,
     DynamicBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::DynamicBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmDynamicBlock {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmDynamicBlock {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmDynamicBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::DynamicBlock(self)
+    }
+}

src/wasm/entity.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Entity;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmEntity {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmEntity<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmEntity,
+    WasmEntity<'s, 'p>,
     Entity<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Entity(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmEntity {
-            Vec::new(),
+            standard_properties,
-            WasmEntity {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmEntity<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Entity(self)
+    }
+}

src/wasm/example_block.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::ExampleBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmExampleBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmExampleBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmExampleBlock,
+    WasmExampleBlock<'s, 'p>,
     ExampleBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::ExampleBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmExampleBlock {
-            Vec::new(),
+            standard_properties,
-            WasmExampleBlock {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmExampleBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::ExampleBlock(self)
+    }
+}

src/wasm/export_block.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::ExportBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmExportBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmExportBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmExportBlock,
+    WasmExportBlock<'s, 'p>,
     ExportBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::ExportBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmExportBlock {
-            Vec::new(),
+            standard_properties,
-            WasmExportBlock {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmExportBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::ExportBlock(self)
+    }
+}

src/wasm/export_snippet.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::ExportSnippet;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmExportSnippet {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmExportSnippet<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmExportSnippet,
+    WasmExportSnippet<'s, 'p>,
     ExportSnippet<'s>,
     original,
     wasm_context,
-    { WasmAstNode::ExportSnippet(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmExportSnippet {
-            Vec::new(),
+            standard_properties,
-            WasmExportSnippet {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmExportSnippet<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::ExportSnippet(self)
+    }
+}

src/wasm/fixed_width_area.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::FixedWidthArea;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmFixedWidthArea {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmFixedWidthArea<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmFixedWidthArea,
+    WasmFixedWidthArea<'s, 'p>,
     FixedWidthArea<'s>,
     original,
     wasm_context,
-    { WasmAstNode::FixedWidthArea(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmFixedWidthArea {
-            Vec::new(),
+            standard_properties,
-            WasmFixedWidthArea {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmFixedWidthArea<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::FixedWidthArea(self)
+    }
+}

src/wasm/footnote_definition.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::FootnoteDefinition;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmFootnoteDefinition {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmFootnoteDefinition<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmFootnoteDefinition,
+    WasmFootnoteDefinition<'s, 'p>,
     FootnoteDefinition<'s>,
     original,
     wasm_context,
-    { WasmAstNode::FootnoteDefinition(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmFootnoteDefinition {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmFootnoteDefinition {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmFootnoteDefinition<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::FootnoteDefinition(self)
+    }
+}

src/wasm/footnote_reference.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::FootnoteReference;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmFootnoteReference {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmFootnoteReference<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmFootnoteReference,
+    WasmFootnoteReference<'s, 'p>,
     FootnoteReference<'s>,
     original,
     wasm_context,
-    { WasmAstNode::FootnoteReference(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmFootnoteReference {
-            Vec::new(),
+            standard_properties,
-            WasmFootnoteReference {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmFootnoteReference<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::FootnoteReference(self)
+    }
+}

src/wasm/headline.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
 use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Heading;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmHeadline {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "headline")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmHeadline<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmHeadline,
+    WasmHeadline<'s, 'p>,
     Heading<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Headline(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmHeadline {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmHeadline {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmHeadline<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Headline(self)
+    }
+}

src/wasm/horizontal_rule.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::HorizontalRule;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmHorizontalRule {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmHorizontalRule<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmHorizontalRule,
+    WasmHorizontalRule<'s, 'p>,
     HorizontalRule<'s>,
     original,
     wasm_context,
-    { WasmAstNode::HorizontalRule(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmHorizontalRule {
-            Vec::new(),
+            standard_properties,
-            WasmHorizontalRule {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmHorizontalRule<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::HorizontalRule(self)
+    }
+}

src/wasm/inline_babel_call.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::InlineBabelCall;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmInlineBabelCall {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmInlineBabelCall<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmInlineBabelCall,
+    WasmInlineBabelCall<'s, 'p>,
     InlineBabelCall<'s>,
     original,
     wasm_context,
-    { WasmAstNode::InlineBabelCall(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmInlineBabelCall {
-            Vec::new(),
+            standard_properties,
-            WasmInlineBabelCall {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmInlineBabelCall<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::InlineBabelCall(self)
+    }
+}

src/wasm/inline_source_block.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::InlineSourceBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmInlineSourceBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmInlineSourceBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmInlineSourceBlock,
+    WasmInlineSourceBlock<'s, 'p>,
     InlineSourceBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::InlineSourceBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmInlineSourceBlock {
-            Vec::new(),
+            standard_properties,
-            WasmInlineSourceBlock {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmInlineSourceBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::InlineSourceBlock(self)
+    }
+}

src/wasm/italic.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Italic;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmItalic {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmItalic<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmItalic,
+    WasmItalic<'s, 'p>,
     Italic<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Italic(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmItalic {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmItalic {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmItalic<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Italic(self)
+    }
+}

src/wasm/keyword.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Keyword;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmKeyword {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmKeyword<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmKeyword,
+    WasmKeyword<'s, 'p>,
     Keyword<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Keyword(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmKeyword {
-            Vec::new(),
+            standard_properties,
-            WasmKeyword {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmKeyword<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Keyword(self)
+    }
+}

src/wasm/latex_environment.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::LatexEnvironment;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmLatexEnvironment {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmLatexEnvironment<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmLatexEnvironment,
+    WasmLatexEnvironment<'s, 'p>,
     LatexEnvironment<'s>,
     original,
     wasm_context,
-    { WasmAstNode::LatexEnvironment(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmLatexEnvironment {
-            Vec::new(),
+            standard_properties,
-            WasmLatexEnvironment {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmLatexEnvironment<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::LatexEnvironment(self)
+    }
+}

src/wasm/latex_fragment.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::LatexFragment;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmLatexFragment {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmLatexFragment<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmLatexFragment,
+    WasmLatexFragment<'s, 'p>,
     LatexFragment<'s>,
     original,
     wasm_context,
-    { WasmAstNode::LatexFragment(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmLatexFragment {
-            Vec::new(),
+            standard_properties,
-            WasmLatexFragment {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmLatexFragment<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::LatexFragment(self)
+    }
+}

src/wasm/line_break.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::LineBreak;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmLineBreak {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmLineBreak<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmLineBreak,
+    WasmLineBreak<'s, 'p>,
     LineBreak<'s>,
     original,
     wasm_context,
-    { WasmAstNode::LineBreak(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmLineBreak {
-            Vec::new(),
+            standard_properties,
-            WasmLineBreak {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmLineBreak<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::LineBreak(self)
+    }
+}

src/wasm/macros.rs

@@ -3,11 +3,11 @@
 /// This exists to make changing the type signature easier.
 macro_rules! to_wasm {
     ($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $fnbody:tt) => {
-        impl<'s> ToWasm for $istruct {
+        impl<'s, 'p> ToWasm<'p> for $istruct {
             type Output = $ostruct;
 
             fn to_wasm(
-                &self,
+                &'p self,
                 $wasm_context: crate::wasm::to_wasm::ToWasmContext<'_>,
             ) -> Result<Self::Output, crate::error::CustomError> {
                 let $original = self;
@@ -15,43 +15,18 @@ macro_rules! to_wasm {
             }
         }
     };
-    ($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $toastnodebody:tt, $elispnamebody:tt, $fnbody:tt) => {
+    ($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $standard_properties:ident, $fnbody:tt) => {
-        impl<'s> ToWasm for $istruct {
+        impl<'s, 'p> ToWasm<'p> for $istruct {
-            type Output = crate::wasm::ast_node::WasmAstNodeWrapper<$ostruct>;
+            type Output = $ostruct;
 
             fn to_wasm(
-                &self,
+                &'p self,
                 $wasm_context: crate::wasm::to_wasm::ToWasmContext<'_>,
             ) -> Result<Self::Output, crate::error::CustomError> {
                 let $original = self;
-                let standard_properties =
+                let $standard_properties =
                     self.to_wasm_standard_properties($wasm_context.clone())?;
-
+                $fnbody
-                $fnbody.map(
-                    |(children, inner)| crate::wasm::ast_node::WasmAstNodeWrapper {
-                        ast_node: inner.get_elisp_name().into_owned(),
-                        standard_properties,
-                        children,
-                        properties: inner,
-                    },
-                )
-            }
-        }
-
-        impl Into<WasmAstNode> for crate::wasm::ast_node::WasmAstNodeWrapper<$ostruct> {
-            fn into(self) -> WasmAstNode {
-                let $original = self;
-                let ret = $toastnodebody;
-                ret
-            }
-        }
-
-        #[cfg(feature = "wasm_test")]
-        impl<'s> crate::compare::ElispFact<'s> for $ostruct {
-            fn get_elisp_name<'b>(&'b self) -> std::borrow::Cow<'s, str> {
-                let $original = self;
-                let ret = $elispnamebody;
-                ret
             }
         }
     };

src/wasm/mod.rs

@@ -67,7 +67,6 @@ pub use additional_property::AdditionalProperties;
 pub use additional_property::AdditionalPropertyValue;
 pub(crate) use angle_link::WasmAngleLink;
 pub use ast_node::WasmAstNode;
-pub use ast_node::WasmAstNodeWrapper;
 pub(crate) use babel_call::WasmBabelCall;
 pub(crate) use bold::WasmBold;
 pub(crate) use center_block::WasmCenterBlock;

src/wasm/node_property.rs

@@ -1,33 +1,30 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::NodeProperty;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmNodeProperty {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmNodeProperty<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmNodeProperty,
+    WasmNodeProperty<'s, 'p>,
     NodeProperty<'s>,
     original,
     wasm_context,
-    { WasmAstNode::NodeProperty(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmNodeProperty {
-            Vec::new(),
+            standard_properties,
-            WasmNodeProperty {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );

src/wasm/org_macro.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::OrgMacro;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmOrgMacro {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmOrgMacro<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmOrgMacro,
+    WasmOrgMacro<'s, 'p>,
     OrgMacro<'s>,
     original,
     wasm_context,
-    { WasmAstNode::OrgMacro(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmOrgMacro {
-            Vec::new(),
+            standard_properties,
-            WasmOrgMacro {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmOrgMacro<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::OrgMacro(self)
+    }
+}

src/wasm/paragraph.rs

@@ -1,28 +1,32 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
 use super::AdditionalProperties;
+#[cfg(feature = "wasm_test")]
 use crate::compare::ElispFact;
 use crate::types::GetAffiliatedKeywords;
 use crate::types::Paragraph;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmParagraph {
+#[serde(tag = "ast_node")]
+#[serde(rename = "paragraph")]
+pub struct WasmParagraph<'s, 'p> {
+    pub(crate) standard_properties: WasmStandardProperties,
     #[serde(flatten)]
-    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) additional_properties: AdditionalProperties<'s, 'p>,
+    pub(crate) children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmParagraph,
+    WasmParagraph<'s, 'p>,
     Paragraph<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Paragraph(original) },
+    standard_properties,
-    { "paragraph".into() },
     {
         let additional_properties = original
             .get_affiliated_keywords()
@@ -34,15 +38,27 @@ to_wasm!(
             .map(|child| {
                 child
                     .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
+                    .map(Into::<WasmAstNode<'_, '_>>::into)
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        Ok((
+        Ok(WasmParagraph {
+            standard_properties,
+            additional_properties,
             children,
-            WasmParagraph {
+        })
-                additional_properties,
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmParagraph<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Paragraph(self)
+    }
+}
+
+#[cfg(feature = "wasm_test")]
+impl<'s, 'p> ElispFact<'s> for WasmParagraph<'s, 'p> {
+    fn get_elisp_name<'b>(&'b self) -> std::borrow::Cow<'s, str> {
+        "paragraph".into()
+    }
+}

src/wasm/parse_result.rs

@@ -1,14 +1,12 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNodeWrapper;
 use super::document::WasmDocument;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
 #[serde(tag = "status", content = "content")]
-pub enum ParseResult {
+pub enum ParseResult<'s, 'p> {
     #[serde(rename = "success")]
-    Success(WasmAstNodeWrapper<WasmDocument>),
+    Success(WasmDocument<'s, 'p>),
 
     #[serde(rename = "error")]
     Error(String),

src/wasm/plain_link.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::PlainLink;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmPlainLink {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmPlainLink<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmPlainLink,
+    WasmPlainLink<'s, 'p>,
     PlainLink<'s>,
     original,
     wasm_context,
-    { WasmAstNode::PlainLink(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmPlainLink {
-            Vec::new(),
+            standard_properties,
-            WasmPlainLink {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmPlainLink<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::PlainLink(self)
+    }
+}

src/wasm/plain_list.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::PlainList;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmPlainList {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmPlainList<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmPlainList,
+    WasmPlainList<'s, 'p>,
     PlainList<'s>,
     original,
     wasm_context,
-    { WasmAstNode::PlainList(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmPlainList {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmPlainList {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmPlainList<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::PlainList(self)
+    }
+}

src/wasm/plain_list_item.rs

@@ -1,43 +1,30 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::PlainListItem;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmPlainListItem {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmPlainListItem<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmPlainListItem,
+    WasmPlainListItem<'s, 'p>,
     PlainListItem<'s>,
     original,
     wasm_context,
-    { WasmAstNode::PlainListItem(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmPlainListItem {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmPlainListItem {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );

src/wasm/plain_text.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::PlainText;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmPlainText {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmPlainText<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmPlainText,
+    WasmPlainText<'s, 'p>,
     PlainText<'s>,
     original,
     wasm_context,
-    { WasmAstNode::PlainText(original) },
+    standard_properties,
-    { "plain-text".into() },
     {
-        Ok((
+        Ok(WasmPlainText {
-            Vec::new(),
+            standard_properties,
-            WasmPlainText {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmPlainText<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::PlainText(self)
+    }
+}

src/wasm/planning.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Planning;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmPlanning {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmPlanning<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmPlanning,
+    WasmPlanning<'s, 'p>,
     Planning<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Planning(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmPlanning {
-            Vec::new(),
+            standard_properties,
-            WasmPlanning {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmPlanning<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Planning(self)
+    }
+}

src/wasm/property_drawer.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::PropertyDrawer;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmPropertyDrawer {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmPropertyDrawer<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmPropertyDrawer,
+    WasmPropertyDrawer<'s, 'p>,
     PropertyDrawer<'s>,
     original,
     wasm_context,
-    { WasmAstNode::PropertyDrawer(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmPropertyDrawer {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmPropertyDrawer {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmPropertyDrawer<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::PropertyDrawer(self)
+    }
+}

src/wasm/quote_block.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::QuoteBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmQuoteBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmQuoteBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmQuoteBlock,
+    WasmQuoteBlock<'s, 'p>,
     QuoteBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::QuoteBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmQuoteBlock {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmQuoteBlock {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmQuoteBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::QuoteBlock(self)
+    }
+}

src/wasm/radio_link.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::RadioLink;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmRadioLink {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmRadioLink<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmRadioLink,
+    WasmRadioLink<'s, 'p>,
     RadioLink<'s>,
     original,
     wasm_context,
-    { WasmAstNode::RadioLink(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmRadioLink {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmRadioLink {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmRadioLink<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::RadioLink(self)
+    }
+}

src/wasm/radio_target.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::RadioTarget;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmRadioTarget {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmRadioTarget<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmRadioTarget,
+    WasmRadioTarget<'s, 'p>,
     RadioTarget<'s>,
     original,
     wasm_context,
-    { WasmAstNode::RadioTarget(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmRadioTarget {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmRadioTarget {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmRadioTarget<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::RadioTarget(self)
+    }
+}

src/wasm/regular_link.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::RegularLink;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmRegularLink {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmRegularLink<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmRegularLink,
+    WasmRegularLink<'s, 'p>,
     RegularLink<'s>,
     original,
     wasm_context,
-    { WasmAstNode::RegularLink(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmRegularLink {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmRegularLink {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmRegularLink<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::RegularLink(self)
+    }
+}

src/wasm/section.rs

@@ -1,27 +1,31 @@
-use serde::Deserialize;
 use serde::Serialize;
 
 use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
 use super::AdditionalProperties;
+#[cfg(feature = "wasm_test")]
 use crate::compare::ElispFact;
 use crate::types::Section;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmSection {
+#[serde(tag = "ast_node")]
+#[serde(rename = "section")]
+pub struct WasmSection<'s, 'p> {
+    pub(crate) standard_properties: WasmStandardProperties,
     #[serde(flatten)]
-    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) additional_properties: AdditionalProperties<'s, 'p>,
+    pub(crate) children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmSection,
+    WasmSection<'s, 'p>,
     Section<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Section(original) },
+    standard_properties,
-    { "section".into() },
     {
         let children = original
             .children
@@ -29,15 +33,27 @@ to_wasm!(
             .map(|child| {
                 child
                     .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
+                    .map(Into::<WasmAstNode<'_, '_>>::into)
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        Ok((
+        Ok(WasmSection {
+            standard_properties,
+            additional_properties: AdditionalProperties::default(),
             children,
-            WasmSection {
+        })
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmSection<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Section(self)
+    }
+}
+
+#[cfg(feature = "wasm_test")]
+impl<'s, 'p> ElispFact<'s> for WasmSection<'s, 'p> {
+    fn get_elisp_name<'b>(&'b self) -> std::borrow::Cow<'s, str> {
+        "section".into()
+    }
+}

src/wasm/special_block.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::SpecialBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmSpecialBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmSpecialBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmSpecialBlock,
+    WasmSpecialBlock<'s, 'p>,
     SpecialBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::SpecialBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmSpecialBlock {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmSpecialBlock {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmSpecialBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::SpecialBlock(self)
+    }
+}

src/wasm/src_block.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::SrcBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmSrcBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmSrcBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmSrcBlock,
+    WasmSrcBlock<'s, 'p>,
     SrcBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::SrcBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmSrcBlock {
-            Vec::new(),
+            standard_properties,
-            WasmSrcBlock {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmSrcBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::SrcBlock(self)
+    }
+}

src/wasm/standard_properties.rs

@@ -1,4 +1,3 @@
-use serde::Deserialize;
 use serde::Serialize;
 
 use super::to_wasm::ToWasmContext;
@@ -6,15 +5,12 @@ use super::to_wasm::ToWasmStandardProperties;
 use crate::types::PostBlank;
 use crate::types::StandardProperties;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
 pub(crate) struct WasmStandardProperties {
     pub(crate) begin: usize,
     pub(crate) end: usize,
-    #[serde(rename = "contents-begin")]
     pub(crate) contents_begin: Option<usize>,
-    #[serde(rename = "contents-end")]
     pub(crate) contents_end: Option<usize>,
-    #[serde(rename = "post-blank")]
     pub(crate) post_blank: PostBlank,
 }
 

src/wasm/statistics_cookie.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::StatisticsCookie;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmStatisticsCookie {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmStatisticsCookie<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmStatisticsCookie,
+    WasmStatisticsCookie<'s, 'p>,
     StatisticsCookie<'s>,
     original,
     wasm_context,
-    { WasmAstNode::StatisticsCookie(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmStatisticsCookie {
-            Vec::new(),
+            standard_properties,
-            WasmStatisticsCookie {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmStatisticsCookie<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::StatisticsCookie(self)
+    }
+}

src/wasm/strike_through.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::StrikeThrough;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmStrikeThrough {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmStrikeThrough<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmStrikeThrough,
+    WasmStrikeThrough<'s, 'p>,
     StrikeThrough<'s>,
     original,
     wasm_context,
-    { WasmAstNode::StrikeThrough(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmStrikeThrough {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmStrikeThrough {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmStrikeThrough<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::StrikeThrough(self)
+    }
+}

src/wasm/subscript.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Subscript;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmSubscript {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmSubscript<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmSubscript,
+    WasmSubscript<'s, 'p>,
     Subscript<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Subscript(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmSubscript {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmSubscript {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmSubscript<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Subscript(self)
+    }
+}

src/wasm/superscript.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Superscript;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmSuperscript {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmSuperscript<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmSuperscript,
+    WasmSuperscript<'s, 'p>,
     Superscript<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Superscript(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmSuperscript {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmSuperscript {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmSuperscript<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Superscript(self)
+    }
+}

src/wasm/table.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Table;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmTable {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmTable<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmTable,
+    WasmTable<'s, 'p>,
     Table<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Table(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmTable {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmTable {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmTable<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Table(self)
+    }
+}

src/wasm/table_cell.rs

@@ -1,43 +1,30 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::TableCell;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmTableCell {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmTableCell<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmTableCell,
+    WasmTableCell<'s, 'p>,
     TableCell<'s>,
     original,
     wasm_context,
-    { WasmAstNode::TableCell(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmTableCell {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmTableCell {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );

src/wasm/table_row.rs

@@ -1,43 +1,30 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::TableRow;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmTableRow {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmTableRow<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmTableRow,
+    WasmTableRow<'s, 'p>,
     TableRow<'s>,
     original,
     wasm_context,
-    { WasmAstNode::TableRow(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmTableRow {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmTableRow {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );

src/wasm/target.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Target;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmTarget {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmTarget<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmTarget,
+    WasmTarget<'s, 'p>,
     Target<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Target(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmTarget {
-            Vec::new(),
+            standard_properties,
-            WasmTarget {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmTarget<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Target(self)
+    }
+}

src/wasm/timestamp.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Timestamp;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmTimestamp {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmTimestamp<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmTimestamp,
+    WasmTimestamp<'s, 'p>,
     Timestamp<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Timestamp(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmTimestamp {
-            Vec::new(),
+            standard_properties,
-            WasmTimestamp {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmTimestamp<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Timestamp(self)
+    }
+}

src/wasm/to_wasm.rs

@@ -1,14 +1,13 @@
 use super::macros::to_wasm;
 use super::WasmAstNode;
 use crate::error::CustomError;
-use crate::types::DocumentElement;
 use crate::types::Element;
 use crate::types::Object;
 
-pub trait ToWasm {
+pub trait ToWasm<'p> {
     type Output;
 
-    fn to_wasm(&self, full_document: ToWasmContext<'_>) -> Result<Self::Output, CustomError>;
+    fn to_wasm(&'p self, full_document: ToWasmContext<'_>) -> Result<Self::Output, CustomError>;
 }
 
 pub(crate) trait ToWasmStandardProperties {
@@ -31,94 +30,125 @@ impl<'s> ToWasmContext<'s> {
     }
 }
 
-to_wasm!(WasmAstNode, DocumentElement<'s>, original, wasm_context, {
+to_wasm!(
-    match original {
+    WasmAstNode<'s, 'p>,
-        DocumentElement::Heading(inner) => {
+    Element<'s>,
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+    original,
-        }
+    wasm_context,
-        DocumentElement::Section(inner) => {
+    standard_properties,
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+    {
+        match original {
+            Element::Paragraph(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::PlainList(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::CenterBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::QuoteBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::SpecialBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::DynamicBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::FootnoteDefinition(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::Comment(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::Drawer(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::PropertyDrawer(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::Table(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::VerseBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::CommentBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::ExampleBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::ExportBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::SrcBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::Clock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::DiarySexp(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::Planning(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::FixedWidthArea(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::HorizontalRule(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Element::Keyword(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::BabelCall(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Element::LatexEnvironment(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
         }
     }
-});
+);
 
-to_wasm!(WasmAstNode, Element<'s>, original, wasm_context, {
+to_wasm!(
-    match original {
+    WasmAstNode<'s, 'p>,
-        Element::Paragraph(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+    Object<'s>,
-        Element::PlainList(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+    original,
-        Element::CenterBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+    wasm_context,
-        Element::QuoteBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+    standard_properties,
-        Element::SpecialBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+    {
-        Element::DynamicBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        match original {
-        Element::FootnoteDefinition(inner) => {
+            Object::Bold(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            Object::Italic(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        }
+            Object::Underline(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Element::Comment(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::StrikeThrough(inner) => {
-        Element::Drawer(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        Element::PropertyDrawer(inner) => {
+            }
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            Object::Code(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        }
+            Object::Verbatim(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Element::Table(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::PlainText(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Element::VerseBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::RegularLink(inner) => {
-        Element::CommentBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        Element::ExampleBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            }
-        Element::ExportBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::RadioLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Element::SrcBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::RadioTarget(inner) => {
-        Element::Clock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        Element::DiarySexp(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            }
-        Element::Planning(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::PlainLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Element::FixedWidthArea(inner) => {
+            Object::AngleLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            Object::OrgMacro(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        }
+            Object::Entity(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Element::HorizontalRule(inner) => {
+            Object::LatexFragment(inner) => {
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        }
+            }
-        Element::Keyword(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::ExportSnippet(inner) => {
-        Element::BabelCall(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        Element::LatexEnvironment(inner) => {
+            }
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            Object::FootnoteReference(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Object::Citation(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::CitationReference(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Object::InlineBabelCall(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Object::InlineSourceBlock(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Object::LineBreak(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::Target(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::StatisticsCookie(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Object::Subscript(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+            Object::Superscript(inner) => {
+                inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+            }
+            Object::Timestamp(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
         }
     }
-});
+);
-
-to_wasm!(WasmAstNode, Object<'s>, original, wasm_context, {
-    match original {
-        Object::Bold(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Italic(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Underline(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::StrikeThrough(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Code(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Verbatim(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::PlainText(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::RegularLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::RadioLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::RadioTarget(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::PlainLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::AngleLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::OrgMacro(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Entity(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::LatexFragment(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::ExportSnippet(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::FootnoteReference(inner) => {
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        }
-        Object::Citation(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::CitationReference(inner) => {
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        }
-        Object::InlineBabelCall(inner) => {
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        }
-        Object::InlineSourceBlock(inner) => {
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        }
-        Object::LineBreak(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Target(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::StatisticsCookie(inner) => {
-            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
-        }
-        Object::Subscript(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Superscript(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-        Object::Timestamp(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
-    }
-});

src/wasm/underline.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Underline;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmUnderline {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmUnderline<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmUnderline,
+    WasmUnderline<'s, 'p>,
     Underline<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Underline(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmUnderline {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmUnderline {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmUnderline<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Underline(self)
+    }
+}

src/wasm/verbatim.rs

@@ -1,33 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::Verbatim;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmVerbatim {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmVerbatim<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmVerbatim,
+    WasmVerbatim<'s, 'p>,
     Verbatim<'s>,
     original,
     wasm_context,
-    { WasmAstNode::Verbatim(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        Ok((
+        Ok(WasmVerbatim {
-            Vec::new(),
+            standard_properties,
-            WasmVerbatim {
+            children: Vec::new(),
-                additional_properties: AdditionalProperties::default(),
+        })
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmVerbatim<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::Verbatim(self)
+    }
+}

src/wasm/verse_block.rs

@@ -1,43 +1,36 @@
-use serde::Deserialize;
 use serde::Serialize;
 
-use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
+use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
-use super::AdditionalProperties;
-use crate::compare::ElispFact;
 use crate::types::VerseBlock;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
+use crate::wasm::WasmAstNode;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
-pub struct WasmVerseBlock {
+#[serde(tag = "ast_node")]
-    #[serde(flatten)]
+#[serde(rename = "org-data")]
-    pub(crate) additional_properties: AdditionalProperties,
+pub struct WasmVerseBlock<'s, 'p> {
+    standard_properties: WasmStandardProperties,
+    children: Vec<WasmAstNode<'s, 'p>>,
 }
 
 to_wasm!(
-    WasmVerseBlock,
+    WasmVerseBlock<'s, 'p>,
     VerseBlock<'s>,
     original,
     wasm_context,
-    { WasmAstNode::VerseBlock(original) },
+    standard_properties,
-    { "TODO".into() },
     {
-        let children = original
+        Ok(WasmVerseBlock {
-            .children
+            standard_properties,
-            .iter()
+            children: Vec::new(),
-            .map(|child| {
+        })
-                child
-                    .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode>::into)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok((
-            children,
-            WasmVerseBlock {
-                additional_properties: AdditionalProperties::default(),
-            },
-        ))
     }
 );
+
+impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmVerseBlock<'s, 'p> {
+    fn into(self) -> WasmAstNode<'s, 'p> {
+        WasmAstNode::VerseBlock(self)
+    }
+}

src/wasm_test/diff.rs

@@ -55,7 +55,7 @@ impl<'s> WasmDiffResult<'s> {
         original_document: &str,
     ) -> Result<(), Box<dyn std::error::Error>> {
         let status_text = {
-            if self.is_self_bad() {
+            if self.is_bad() {
                 format!(
                     "{color}BAD{reset}",
                     color = foreground_color(255, 0, 0),

src/wasm_test/elisp_compare.rs

@@ -0,0 +1,10 @@
+use super::diff::WasmDiffResult;
+use crate::compare::Token;
+
+pub trait WasmElispCompare<'s, 'p> {
+    fn compare_ast_node<'b>(
+        &self,
+        source: &'s str,
+        emacs: &'b Token<'s>,
+    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>>;
+}

src/wasm_test/logic.rs

@@ -0,0 +1,387 @@
+use super::diff::WasmDiffResult;
+use super::diff::WasmDiffStatus;
+use super::elisp_compare::WasmElispCompare;
+use crate::compare::get_emacs_standard_properties;
+use crate::compare::get_property;
+use crate::compare::get_property_quoted_string;
+use crate::compare::unquote;
+use crate::compare::Token;
+use crate::wasm::AdditionalProperties;
+use crate::wasm::AdditionalPropertyValue;
+use crate::wasm::WasmStandardProperties;
+
+pub(crate) fn wasm_compare_list<'b, 's: 'b, 'p, EI, WI, WC>(
+    source: &'s str,
+    emacs: EI,
+    wasm: WI,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>>
+where
+    EI: Iterator<Item = &'b Token<'s>> + ExactSizeIterator,
+    WI: Iterator<Item = WC> + ExactSizeIterator,
+    WC: WasmElispCompare<'s, 'p>,
+{
+    let status = Vec::new();
+    let emacs_length = emacs.len();
+    let wasm_length = wasm.len();
+    if emacs_length != wasm_length {
+        return Ok(WasmDiffResult {
+            status: vec![WasmDiffStatus::Bad(
+                format!(
+                    "Child length mismatch (emacs != rust) {:?} != {:?}",
+                    emacs_length, wasm_length
+                )
+                .into(),
+            )],
+            children: Vec::new(),
+            name: "".into(),
+        });
+    }
+
+    let mut child_status = Vec::with_capacity(emacs_length);
+    for (emacs_child, wasm_child) in emacs.zip(wasm) {
+        child_status.push(wasm_child.compare_ast_node(source, emacs_child)?);
+    }
+    Ok(WasmDiffResult {
+        status,
+        children: child_status,
+        name: "".into(),
+    })
+}
+
+pub(crate) fn wasm_compare_property_quoted_string<
+    'b,
+    's,
+    W,
+    WV: AsRef<str> + std::fmt::Debug,
+    WG: Fn(W) -> Option<WV>,
+>(
+    _source: &'s str,
+    emacs: &'b Token<'s>,
+    wasm_node: W,
+    emacs_field: &str,
+    wasm_value_getter: WG,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let emacs_value = get_property_quoted_string(emacs, emacs_field)?;
+    let wasm_value = wasm_value_getter(wasm_node);
+    if wasm_value.as_ref().map(|s| s.as_ref()) != emacs_value.as_deref() {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                property = emacs_field,
+                emacs = emacs_value,
+                wasm = wasm_value,
+            )
+            .into(),
+        ))
+    }
+    Ok(result)
+}
+
+pub(crate) fn wasm_compare_property_list_of_quoted_string<
+    'b,
+    's,
+    WI: Iterator<Item = WV> + ExactSizeIterator,
+    W,
+    WV: AsRef<str> + std::fmt::Debug,
+    WG: Fn(W) -> Option<WI>,
+>(
+    _source: &'s str,
+    emacs: &'b Token<'s>,
+    wasm_node: W,
+    emacs_field: &str,
+    wasm_value_getter: WG,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let emacs_value = get_property(emacs, emacs_field)?
+        .map(Token::as_list)
+        .map_or(Ok(None), |r| r.map(Some))?;
+    let wasm_value = wasm_value_getter(wasm_node);
+    match (emacs_value, wasm_value) {
+        (None, None) => {}
+        (None, Some(_)) | (Some(_), None) => {
+            return Ok(WasmDiffResult {
+            status: vec![WasmDiffStatus::Bad(
+                format!(
+                    "Property list length mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    property = emacs_field,
+                    emacs = if emacs_value.is_some() {"Some"} else {"None"},
+                    wasm = if !emacs_value.is_some() {"Some"} else {"None"}
+                )
+                .into(),
+            )],
+            children: Vec::new(),
+            name: "".into(),
+        });
+        }
+        (Some(el), Some(wl)) if el.len() != wl.len() => {
+            return Ok(WasmDiffResult {
+            status: vec![WasmDiffStatus::Bad(
+                format!(
+                    "Property list length mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    property = emacs_field,
+                    emacs = el.len(),
+                    wasm = wl.len()
+                )
+                .into(),
+            )],
+            children: Vec::new(),
+            name: "".into(),
+        });
+        }
+        (Some(el), Some(wl)) => {
+            for (e, w) in el.iter().zip(wl) {
+                let e = unquote(e.as_atom()?)?;
+                let w = w.as_ref();
+                if e != w {
+                    result.status.push(WasmDiffStatus::Bad(
+                        format!(
+                            "Property list value mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                            property = emacs_field,
+                            emacs = e,
+                            wasm = w
+                        )
+                            .into(),
+                    ));
+                }
+            }
+        }
+    };
+
+    Ok(result)
+}
+
+pub(crate) fn wasm_compare_property_optional_pair<
+    'b,
+    's,
+    W,
+    WV: AsRef<str> + std::fmt::Debug,
+    WOV: AsRef<str> + std::fmt::Debug,
+    WG: Fn(W) -> Option<(Option<WOV>, WV)>,
+>(
+    _source: &'s str,
+    emacs: &'b Token<'s>,
+    wasm_node: W,
+    emacs_field: &str,
+    wasm_value_getter: WG,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let emacs_value = get_property(emacs, emacs_field)?
+        .map(Token::as_list)
+        .map_or(Ok(None), |r| r.map(Some))?;
+    let wasm_value = wasm_value_getter(wasm_node);
+    match (emacs_value, &wasm_value) {
+        (None, None) => {}
+        (None, Some(_)) | (Some(_), None) => {
+            return Ok(WasmDiffResult {
+            status: vec![WasmDiffStatus::Bad(
+                format!(
+                    "Property list length mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    property = emacs_field,
+                    emacs = if emacs_value.is_some() {"Some"} else {"None"},
+                    wasm = if !emacs_value.is_some() {"Some"} else {"None"}
+                )
+                .into(),
+            )],
+            children: Vec::new(),
+            name: "".into(),
+        });
+        }
+        (Some(el), Some((Some(owl), wl))) if el.len() == 3 => {
+            let e = el
+                .first()
+                .map(Token::as_atom)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .map(unquote)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .expect("Above match proved length to be 3.");
+            let oe = el
+                .get(2)
+                .map(Token::as_atom)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .map(unquote)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .expect("Above match proved length to be 3.");
+            let w = wl.as_ref();
+            let ow = owl.as_ref();
+            if e != w {
+                result.status.push(WasmDiffStatus::Bad(
+                    format!(
+                        "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                        property = "end",
+                        emacs = e,
+                        wasm = w,
+                    )
+                        .into(),
+                ));
+            }
+            if oe != ow {
+                result.status.push(WasmDiffStatus::Bad(
+                    format!(
+                        "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                        property = "end",
+                        emacs = oe,
+                        wasm = ow,
+                    )
+                        .into(),
+                ));
+            }
+        }
+        (Some(el), Some((None, wl))) if el.len() == 1 => {
+            let e = el
+                .first()
+                .map(Token::as_atom)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .map(unquote)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .expect("Above match proved length to be 3.");
+            let w = wl.as_ref();
+            if e != w {
+                result.status.push(WasmDiffStatus::Bad(
+                    format!(
+                        "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                        property = "end",
+                        emacs = e,
+                        wasm = w,
+                    )
+                        .into(),
+                ));
+            }
+        }
+        (Some(el), Some(_)) => {
+            return Ok(WasmDiffResult {
+            status: vec![WasmDiffStatus::Bad(
+                format!(
+                    "Property list length mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    property = emacs_field,
+                    emacs = el.len(),
+                    wasm = wasm_value
+                )
+                .into(),
+            )],
+            children: Vec::new(),
+            name: "".into(),
+        });
+        }
+    }
+    Ok(result)
+}
+
+pub(crate) fn wasm_compare_standard_properties<'b, 's>(
+    _source: &'s str,
+    emacs: &'b Token<'s>,
+    wasm: &WasmStandardProperties,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let mut layer = WasmDiffResult::default();
+    layer.name = "standard-properties".into();
+    let standard_properties = get_emacs_standard_properties(emacs)?;
+
+    if Some(wasm.begin) != standard_properties.begin {
+        layer.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                property = "begin",
+                emacs = standard_properties.begin,
+                wasm = Some(wasm.begin),
+            )
+            .into(),
+        ));
+    }
+    if Some(wasm.end) != standard_properties.end {
+        layer.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                property = "end",
+                emacs = standard_properties.end,
+                wasm = Some(wasm.end),
+            )
+            .into(),
+        ));
+    }
+    if wasm.contents_begin != standard_properties.contents_begin {
+        layer.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                property = "contents-begin",
+                emacs = standard_properties.contents_begin,
+                wasm = wasm.contents_begin,
+            )
+            .into(),
+        ));
+    }
+    if wasm.contents_end != standard_properties.contents_end {
+        layer.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                property = "contents-end",
+                emacs = standard_properties.contents_end,
+                wasm = wasm.contents_end,
+            )
+            .into(),
+        ));
+    }
+    if Some(wasm.post_blank).map(|post_blank| post_blank as usize) != standard_properties.post_blank
+    {
+        layer.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Property mismatch. Property=({property}) Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                property = "post-blank",
+                emacs = standard_properties.post_blank,
+                wasm = Some(wasm.post_blank),
+            )
+            .into(),
+        ));
+    }
+
+    result.children.push(layer);
+    Ok(result)
+}
+
+pub(crate) fn wasm_compare_additional_properties<'b, 's>(
+    source: &'s str,
+    emacs: &'b Token<'s>,
+    wasm: &AdditionalProperties<'_, '_>,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let mut layer = WasmDiffResult::default();
+    layer.name = "additional-properties".into();
+
+    for (property_name, property_value) in wasm.properties.iter() {
+        let emacs_property_name = format!(":{property_name}", property_name = property_name);
+        match property_value {
+            AdditionalPropertyValue::SingleString(wasm_value) => {
+                layer.extend(wasm_compare_property_quoted_string(
+                    source,
+                    emacs,
+                    wasm,
+                    &emacs_property_name,
+                    |_| Some(wasm_value),
+                )?)?;
+            }
+            AdditionalPropertyValue::ListOfStrings(wasm_value) => {
+                layer.extend(wasm_compare_property_list_of_quoted_string(
+                    source,
+                    emacs,
+                    wasm,
+                    &emacs_property_name,
+                    |_| Some(wasm_value.iter()),
+                )?)?;
+            }
+            // TODO: similar to compare_affiliated_keywords
+            AdditionalPropertyValue::OptionalPair { optval, val } => {
+                layer.extend(wasm_compare_property_optional_pair(
+                    source,
+                    emacs,
+                    wasm,
+                    &emacs_property_name,
+                    |_| Some((*optval, *val)),
+                )?)?;
+            }
+            AdditionalPropertyValue::ObjectTree(_) => todo!(),
+        }
+    }
+
+    result.children.push(layer);
+    Ok(result)
+}

src/wasm_test/mod.rs

@@ -1,5 +1,7 @@
 mod compare;
 mod diff;
+mod elisp_compare;
+mod logic;
 mod macros;
 mod runner;
 

src/wasm_test/runner.rs

@@ -47,7 +47,7 @@ pub async fn wasm_run_anonymous_compare_with_settings<'g, 's, P: AsRef<str>>(
     }
 
     // We do the diffing after printing out both parsed forms in case the diffing panics
-    let diff_result = wasm_compare_document(org_contents, &parsed_sexp, &wasm_parsed)?;
+    let diff_result = wasm_compare_document(org_contents, &parsed_sexp, wasm_parsed)?;
     if !silent {
         diff_result.print(org_contents)?;
     }
@@ -112,7 +112,7 @@ pub async fn wasm_run_compare_on_file_with_settings<'g, 's, P: AsRef<Path>>(
     }
 
     // We do the diffing after printing out both parsed forms in case the diffing panics
-    let diff_result = wasm_compare_document(org_contents, &parsed_sexp, &wasm_parsed)?;
+    let diff_result = wasm_compare_document(org_contents, &parsed_sexp, wasm_parsed)?;
     if !silent {
         diff_result.print(org_contents)?;
     }