use super::diff::WasmDiffResult;
use super::diff::WasmDiffStatus;
use super::elisp_compare::WasmElispCompare;
use super::logic::wasm_compare_additional_properties;
use super::logic::wasm_compare_list;
use super::logic::wasm_compare_property_quoted_string;
use super::logic::wasm_compare_standard_properties;
use crate::compare::ElispFact;
use crate::compare::EmacsField;
use crate::compare::Token;
use crate::wasm::WasmAngleLink;
use crate::wasm::WasmAstNode;
use crate::wasm::WasmBabelCall;
use crate::wasm::WasmBold;
use crate::wasm::WasmCenterBlock;
use crate::wasm::WasmCitation;
use crate::wasm::WasmCitationReference;
use crate::wasm::WasmClock;
use crate::wasm::WasmCode;
use crate::wasm::WasmComment;
use crate::wasm::WasmCommentBlock;
use crate::wasm::WasmDiarySexp;
use crate::wasm::WasmDocument;
use crate::wasm::WasmDrawer;
use crate::wasm::WasmDynamicBlock;
use crate::wasm::WasmEntity;
use crate::wasm::WasmExampleBlock;
use crate::wasm::WasmExportBlock;
use crate::wasm::WasmExportSnippet;
use crate::wasm::WasmFixedWidthArea;
use crate::wasm::WasmFootnoteDefinition;
use crate::wasm::WasmFootnoteReference;
use crate::wasm::WasmHeadline;
use crate::wasm::WasmHorizontalRule;
use crate::wasm::WasmInlineBabelCall;
use crate::wasm::WasmInlineSourceBlock;
use crate::wasm::WasmItalic;
use crate::wasm::WasmKeyword;
use crate::wasm::WasmLatexEnvironment;
use crate::wasm::WasmLatexFragment;
use crate::wasm::WasmLineBreak;
use crate::wasm::WasmNodeProperty;
use crate::wasm::WasmOrgMacro;
use crate::wasm::WasmParagraph;
use crate::wasm::WasmPlainLink;
use crate::wasm::WasmPlainList;
use crate::wasm::WasmPlainListItem;
use crate::wasm::WasmPlainText;
use crate::wasm::WasmPlanning;
use crate::wasm::WasmPropertyDrawer;
use crate::wasm::WasmQuoteBlock;
use crate::wasm::WasmRadioLink;
use crate::wasm::WasmRadioTarget;
use crate::wasm::WasmRegularLink;
use crate::wasm::WasmSection;
use crate::wasm::WasmSpecialBlock;
use crate::wasm::WasmSrcBlock;
use crate::wasm::WasmStatisticsCookie;
use crate::wasm::WasmStrikeThrough;
use crate::wasm::WasmSubscript;
use crate::wasm::WasmSuperscript;
use crate::wasm::WasmTable;
use crate::wasm::WasmTableCell;
use crate::wasm::WasmTableRow;
use crate::wasm::WasmTarget;
use crate::wasm::WasmTimestamp;
use crate::wasm::WasmUnderline;
use crate::wasm::WasmVerbatim;
use crate::wasm::WasmVerseBlock;
use crate::wasm_test::macros::wasm_compare;

pub fn wasm_compare_document<'b, 's, 'p>(
    source: &'s str,
    emacs: &'b Token<'s>,
    wasm: WasmDocument<'s, 'p>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    wasm.compare_ast_node(source, emacs)
}

impl<'s, 'p, WAN: WasmElispCompare<'s, 'p>> WasmElispCompare<'s, 'p> for &WAN {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        (*self).compare_ast_node(source, emacs)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAstNode<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        match self {
            WasmAstNode::Document(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Headline(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Section(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Paragraph(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::PlainList(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::PlainListItem(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::CenterBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::QuoteBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::SpecialBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::DynamicBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::FootnoteDefinition(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Comment(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Drawer(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::PropertyDrawer(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::NodeProperty(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Table(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::TableRow(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::VerseBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::CommentBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::ExampleBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::ExportBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::SrcBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Clock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::DiarySexp(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Planning(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::FixedWidthArea(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::HorizontalRule(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Keyword(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::BabelCall(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::LatexEnvironment(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Bold(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Italic(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Underline(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::StrikeThrough(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Code(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Verbatim(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::PlainText(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::RegularLink(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::RadioLink(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::RadioTarget(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::PlainLink(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::AngleLink(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::OrgMacro(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Entity(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::LatexFragment(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::ExportSnippet(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::FootnoteReference(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Citation(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::CitationReference(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::InlineBabelCall(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::InlineSourceBlock(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::LineBreak(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Target(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::StatisticsCookie(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Subscript(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Superscript(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::TableCell(inner) => inner.compare_ast_node(source, emacs),
            WasmAstNode::Timestamp(inner) => inner.compare_ast_node(source, emacs),
        }
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDocument<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        let result = wasm_compare!(
            source,
            emacs,
            self,
            (
                EmacsField::Required(":path"),
                |w| w.path.as_ref().and_then(|p| p.to_str()),
                wasm_compare_property_quoted_string
            ),
            (
                EmacsField::Required(":CATEGORY"),
                |w| w.category.as_ref(),
                wasm_compare_property_quoted_string
            )
        );
        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHeadline<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSection<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        let result = wasm_compare!(source, emacs, self,);

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmParagraph<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        let result = wasm_compare!(source, emacs, self,);

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainList<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainListItem<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCenterBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmQuoteBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSpecialBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDynamicBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFootnoteDefinition<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmComment<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDrawer<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPropertyDrawer<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmNodeProperty<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTable<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTableRow<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmVerseBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCommentBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExampleBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExportBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSrcBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmClock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDiarySexp<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlanning<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFixedWidthArea<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHorizontalRule<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmKeyword<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmBabelCall<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLatexEnvironment<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmBold<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmItalic<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmUnderline<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmStrikeThrough<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCode<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmVerbatim<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainText<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRegularLink<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRadioLink<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRadioTarget<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainLink<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAngleLink<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmOrgMacro<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmEntity<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLatexFragment<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExportSnippet<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFootnoteReference<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCitation<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCitationReference<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmInlineBabelCall<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmInlineSourceBlock<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLineBreak<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTarget<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmStatisticsCookie<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSubscript<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSuperscript<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTableCell<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTimestamp<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        // TODO: Implement this.
        let result = WasmDiffResult::default();
        // let result = wasm_compare!(
        //     source,
        //     emacs,
        //     self,
        //     (
        //         EmacsField::Required(":path"),
        //         |w| w.path.as_ref().and_then(|p| p.to_str()),
        //         wasm_compare_property_quoted_string
        //     ),
        //     (
        //         EmacsField::Required(":CATEGORY"),
        //         |w| w.category.as_ref(),
        //         wasm_compare_property_quoted_string
        //     )
        // );

        Ok(result)
    }
}