.gitignore

@@ -1,3 +1,2 @@
 /target
 Cargo.lock
-TODO.org

org_mode_samples/greater_element/plain_list/regular_link.org

@@ -1,2 +0,0 @@
-# This test causes problems with regular links if we do not create a new ContextTree when calling into confine_context.
-- foo [[info:bar][baz]] lorem

org_mode_samples/object/text_markup/double_star.org

@@ -1,3 +1 @@
-**foo**
-
 foo ** bar ** baz

org_mode_samples/object/text_markup/double_underscore.org

@@ -1 +0,0 @@
-__foo_bar_baz__

src/compare/compare_field.rs

@@ -1,46 +1,36 @@
 use std::fmt::Debug;
 
-use super::diff::artificial_diff_scope;
-use super::diff::compare_ast_node;
-use super::diff::DiffEntry;
 use super::diff::DiffStatus;
 use super::sexp::unquote;
 use super::sexp::Token;
 use super::util::get_property;
 use super::util::get_property_quoted_string;
 use super::util::get_property_unquoted_atom;
-use crate::types::AstNode;
 
 #[derive(Debug)]
 pub(crate) enum EmacsField<'s> {
     Required(&'s str),
+    #[allow(dead_code)]
     Optional(&'s str),
 }
 
-#[derive(Debug)]
-pub(crate) enum ComparePropertiesResult<'b, 's> {
-    NoChange,
-    /// Return when you want the status for "this" node to change (as opposed to collecting child status).
-    SelfChange(DiffStatus, Option<String>),
-    DiffEntry(DiffEntry<'b, 's>),
-}
-
 /// Do no comparison.
 ///
 /// This is for when you want to acknowledge that a field exists in the emacs token, but you do not have any validation for it when using the compare_properties!() macro. Ideally, this should be kept to a minimum since this represents untested values.
+#[allow(dead_code)]
 pub(crate) fn compare_noop<'b, 's, 'x, R, RG>(
-    _source: &'s str,
     _emacs: &'b Token<'s>,
     _rust_node: R,
     _emacs_field: &'x str,
     _rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
-    Ok(ComparePropertiesResult::NoChange)
+) -> Result<Option<(DiffStatus, Option<String>)>, Box<dyn std::error::Error>> {
+    Ok(None)
 }
 
 /// Do no comparison.
 ///
 /// This is for when you want to acknowledge that a field exists in the emacs token, but you do not have any validation for it when using the compare_properties!() macro. Ideally, this should be kept to a minimum since this represents untested values.
+#[allow(dead_code)]
 pub(crate) fn compare_identity() -> () {
     ()
 }
@@ -49,12 +39,11 @@ pub(crate) fn compare_identity() -> () {
 ///
 /// This is usually used for fields which, in my testing, are always nil. Using this compare function instead of simply doing a compare_noop will enable us to be alerted when we finally come across an org-mode document that has a value other than nil for the property.
 pub(crate) fn compare_property_always_nil<'b, 's, 'x, R, RG>(
-    _source: &'s str,
     emacs: &'b Token<'s>,
     _rust_node: R,
     emacs_field: &'x str,
     _rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
+) -> Result<Option<(DiffStatus, Option<String>)>, Box<dyn std::error::Error>> {
     let value = get_property(emacs, emacs_field)?;
     if value.is_some() {
         let this_status = DiffStatus::Bad;
@@ -62,9 +51,9 @@ pub(crate) fn compare_property_always_nil<'b, 's, 'x, R, RG>(
             "{} was expected to always be nil: {:?}",
             emacs_field, value
         ));
-        Ok(ComparePropertiesResult::SelfChange(this_status, message))
+        Ok(Some((this_status, message)))
     } else {
-        Ok(ComparePropertiesResult::NoChange)
+        Ok(None)
     }
 }
 
@@ -76,12 +65,11 @@ pub(crate) fn compare_property_quoted_string<
     RV: AsRef<str> + std::fmt::Debug,
     RG: Fn(R) -> Option<RV>,
 >(
-    _source: &'s str,
     emacs: &'b Token<'s>,
     rust_node: R,
     emacs_field: &'x str,
     rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
+) -> Result<Option<(DiffStatus, Option<String>)>, Box<dyn std::error::Error>> {
     let value = get_property_quoted_string(emacs, emacs_field)?;
     let rust_value = rust_value_getter(rust_node);
     if rust_value.as_ref().map(|s| s.as_ref()) != value.as_ref().map(String::as_str) {
@@ -90,19 +78,18 @@ pub(crate) fn compare_property_quoted_string<
             "{} mismatch (emacs != rust) {:?} != {:?}",
             emacs_field, value, rust_value
         ));
-        Ok(ComparePropertiesResult::SelfChange(this_status, message))
+        Ok(Some((this_status, message)))
     } else {
-        Ok(ComparePropertiesResult::NoChange)
+        Ok(None)
     }
 }
 
 pub(crate) fn compare_property_unquoted_atom<'b, 's, 'x, R, RG: Fn(R) -> Option<&'s str>>(
-    _source: &'s str,
     emacs: &'b Token<'s>,
     rust_node: R,
     emacs_field: &'x str,
     rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
+) -> Result<Option<(DiffStatus, Option<String>)>, Box<dyn std::error::Error>> {
     let value = get_property_unquoted_atom(emacs, emacs_field)?;
     let rust_value = rust_value_getter(rust_node);
     if rust_value != value {
@@ -111,9 +98,9 @@ pub(crate) fn compare_property_unquoted_atom<'b, 's, 'x, R, RG: Fn(R) -> Option<
             "{} mismatch (emacs != rust) {:?} != {:?}",
             emacs_field, value, rust_value
         ));
-        Ok(ComparePropertiesResult::SelfChange(this_status, message))
+        Ok(Some((this_status, message)))
     } else {
-        Ok(ComparePropertiesResult::NoChange)
+        Ok(None)
     }
 }
 
@@ -126,12 +113,11 @@ pub(crate) fn compare_property_list_of_quoted_string<
     RI: Iterator<Item = RV>,
     RG: Fn(R) -> Option<RI>,
 >(
-    _source: &'s str,
     emacs: &'b Token<'s>,
     rust_node: R,
     emacs_field: &'x str,
     rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
+) -> Result<Option<(DiffStatus, Option<String>)>, Box<dyn std::error::Error>> {
     let value = get_property(emacs, emacs_field)?
         .map(Token::as_list)
         .map_or(Ok(None), |r| r.map(Some))?;
@@ -146,7 +132,7 @@ pub(crate) fn compare_property_list_of_quoted_string<
                 "{} mismatch (emacs != rust) {:?} != {:?}",
                 emacs_field, value, rust_value
             ));
-            return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+            return Ok(Some((this_status, message)));
         }
         (Some(el), Some(rl)) if el.len() != rl.len() => {
             let this_status = DiffStatus::Bad;
@@ -154,7 +140,7 @@ pub(crate) fn compare_property_list_of_quoted_string<
                 "{} mismatch (emacs != rust) {:?} != {:?}",
                 emacs_field, value, rust_value
             ));
-            return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+            return Ok(Some((this_status, message)));
         }
         (Some(el), Some(rl)) => {
             for (e, r) in el.iter().zip(rl) {
@@ -166,21 +152,20 @@ pub(crate) fn compare_property_list_of_quoted_string<
                         "{} mismatch (emacs != rust) {:?} != {:?}. Full list: {:?} != {:?}",
                         emacs_field, e, r, value, rust_value
                     ));
-                    return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+                    return Ok(Some((this_status, message)));
                 }
             }
         }
     }
-    Ok(ComparePropertiesResult::NoChange)
+    Ok(None)
 }
 
 pub(crate) fn compare_property_boolean<'b, 's, 'x, R, RG: Fn(R) -> bool>(
-    _source: &'s str,
     emacs: &'b Token<'s>,
     rust_node: R,
     emacs_field: &'x str,
     rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
+) -> Result<Option<(DiffStatus, Option<String>)>, Box<dyn std::error::Error>> {
     // get_property already converts nil to None.
     let value = get_property(emacs, emacs_field)?.is_some();
     let rust_value = rust_value_getter(rust_node);
@@ -190,62 +175,8 @@ pub(crate) fn compare_property_boolean<'b, 's, 'x, R, RG: Fn(R) -> bool>(
             "{} mismatch (emacs != rust) {:?} != {:?}",
             emacs_field, value, rust_value
         ));
-        Ok(ComparePropertiesResult::SelfChange(this_status, message))
+        Ok(Some((this_status, message)))
     } else {
-        Ok(ComparePropertiesResult::NoChange)
+        Ok(None)
     }
 }
-
-pub(crate) fn compare_property_list_of_ast_nodes<
-    'b,
-    's,
-    'x: 'b + 's,
-    R,
-    RV: std::fmt::Debug,
-    RI: Iterator<Item = RV>,
-    RG: Fn(R) -> Option<RI>,
->(
-    source: &'s str,
-    emacs: &'b Token<'s>,
-    rust_node: R,
-    emacs_field: &'x str,
-    rust_value_getter: RG,
-) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>>
-where
-    AstNode<'b, 's>: From<RV>,
-{
-    let value = get_property(emacs, emacs_field)?
-        .map(Token::as_list)
-        .map_or(Ok(None), |r| r.map(Some))?;
-    let rust_value = rust_value_getter(rust_node);
-    // TODO: Seems we are needlessly coverting to a vec here.
-    let rust_value: Option<Vec<RV>> = rust_value.map(|it| it.collect());
-    match (value, rust_value) {
-        (None, None) => {}
-        (None, rv @ Some(_)) | (Some(_), rv @ None) => {
-            let this_status = DiffStatus::Bad;
-            let message = Some(format!(
-                "{} mismatch (emacs != rust) {:?} != {:?}",
-                emacs_field, value, rv
-            ));
-            return Ok(ComparePropertiesResult::SelfChange(this_status, message));
-        }
-        (Some(el), Some(rl)) if el.len() != rl.len() => {
-            let this_status = DiffStatus::Bad;
-            let message = Some(format!(
-                "{} mismatch (emacs != rust) {:?} != {:?}",
-                emacs_field, el, rl
-            ));
-            return Ok(ComparePropertiesResult::SelfChange(this_status, message));
-        }
-        (Some(el), Some(rl)) => {
-            let mut child_status: Vec<DiffEntry<'b, 's>> = Vec::with_capacity(rl.len());
-            for (e, r) in el.iter().zip(rl) {
-                child_status.push(compare_ast_node(source, e, r.into())?);
-            }
-            let diff_scope = artificial_diff_scope(emacs_field, child_status)?;
-            return Ok(ComparePropertiesResult::DiffEntry(diff_scope));
-        }
-    }
-    Ok(ComparePropertiesResult::NoChange)
-}

src/compare/diff.rs

@@ -8,7 +8,6 @@ use super::compare_field::compare_identity;
 use super::compare_field::compare_noop;
 use super::compare_field::compare_property_always_nil;
 use super::compare_field::compare_property_boolean;
-use super::compare_field::compare_property_list_of_ast_nodes;
 use super::compare_field::compare_property_list_of_quoted_string;
 use super::compare_field::compare_property_quoted_string;
 use super::compare_field::compare_property_unquoted_atom;
@@ -24,7 +23,6 @@ use super::util::get_property_boolean;
 use super::util::get_property_numeric;
 use super::util::get_property_quoted_string;
 use super::util::get_property_unquoted_atom;
-use crate::compare::compare_field::ComparePropertiesResult;
 use crate::compare::compare_field::EmacsField;
 use crate::compare::macros::compare_properties;
 use crate::types::AngleLink;
@@ -56,7 +54,6 @@ use crate::types::ExportSnippet;
 use crate::types::FixedWidthArea;
 use crate::types::FootnoteDefinition;
 use crate::types::FootnoteReference;
-use crate::types::FootnoteReferenceType;
 use crate::types::GetStandardProperties;
 use crate::types::Heading;
 use crate::types::HorizontalRule;
@@ -330,8 +327,8 @@ impl<'b, 's> DiffLayer<'b, 's> {
     }
 }
 
-pub(crate) fn artificial_diff_scope<'b, 's>(
-    name: &'s str,
+fn artificial_diff_scope<'b, 's>(
+    name: &'static str,
     children: Vec<DiffEntry<'b, 's>>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     Ok(DiffLayer {
@@ -2587,35 +2584,25 @@ fn compare_bold<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b Bold<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(emacs) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    if let Some((new_status, new_message)) = compare_properties!(emacs)? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2627,35 +2614,25 @@ fn compare_italic<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b Italic<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(emacs) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    if let Some((new_status, new_message)) = compare_properties!(emacs)? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2667,35 +2644,25 @@ fn compare_underline<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b Underline<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(emacs) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    if let Some((new_status, new_message)) = compare_properties!(emacs)? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2703,18 +2670,14 @@ fn compare_underline<'b, 's>(
 }
 
 fn compare_verbatim<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b Verbatim<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -2722,22 +2685,16 @@ fn compare_verbatim<'b, 's>(
             |r| Some(r.contents),
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2745,18 +2702,14 @@ fn compare_verbatim<'b, 's>(
 }
 
 fn compare_code<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b Code<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -2764,22 +2717,16 @@ fn compare_code<'b, 's>(
             |r| Some(r.contents),
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2791,35 +2738,25 @@ fn compare_strike_through<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b StrikeThrough<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(emacs) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    if let Some((new_status, new_message)) = compare_properties!(emacs)? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2831,21 +2768,12 @@ fn compare_regular_link<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b RegularLink<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -2887,22 +2815,20 @@ fn compare_regular_link<'b, 's>(
             |r| r.get_search_option(),
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2914,21 +2840,12 @@ fn compare_radio_link<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b RadioLink<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -2961,22 +2878,20 @@ fn compare_radio_link<'b, 's>(
             compare_identity,
             compare_property_always_nil
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -2988,6 +2903,7 @@ fn compare_radio_target<'b, 's>(
     emacs: &'b Token<'s>,
     rust: &'b RadioTarget<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
     let mut this_status = DiffStatus::Good;
     let mut child_status = Vec::new();
     let mut message = None;
@@ -3001,8 +2917,7 @@ fn compare_radio_target<'b, 's>(
         &mut message,
     )?;
 
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3010,22 +2925,20 @@ fn compare_radio_target<'b, 's>(
             |r| Some(r.value),
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
+        message = new_message;
     }
+
+    for (emacs_child, rust_child) in children.iter().skip(2).zip(rust.children.iter()) {
+        child_status.push(compare_ast_node(source, emacs_child, rust_child.into())?);
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3033,18 +2946,14 @@ fn compare_radio_target<'b, 's>(
 }
 
 fn compare_plain_link<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b PlainLink<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3086,22 +2995,16 @@ fn compare_plain_link<'b, 's>(
             |r| r.search_option,
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3109,18 +3012,14 @@ fn compare_plain_link<'b, 's>(
 }
 
 fn compare_angle_link<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b AngleLink<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3162,22 +3061,16 @@ fn compare_angle_link<'b, 's>(
             |r| r.get_search_option(),
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3185,18 +3078,14 @@ fn compare_angle_link<'b, 's>(
 }
 
 fn compare_org_macro<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b OrgMacro<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3218,22 +3107,16 @@ fn compare_org_macro<'b, 's>(
             },
             compare_property_list_of_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3241,18 +3124,14 @@ fn compare_org_macro<'b, 's>(
 }
 
 fn compare_entity<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b Entity<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3296,22 +3175,16 @@ fn compare_entity<'b, 's>(
             |r| r.use_brackets,
             compare_property_boolean
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3319,18 +3192,14 @@ fn compare_entity<'b, 's>(
 }
 
 fn compare_latex_fragment<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b LatexFragment<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3338,22 +3207,16 @@ fn compare_latex_fragment<'b, 's>(
             |r| Some(r.value),
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3361,18 +3224,16 @@ fn compare_latex_fragment<'b, 's>(
 }
 
 fn compare_export_snippet<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b ExportSnippet<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
     let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
     let mut message = None;
 
     assert_no_children(emacs, &mut this_status, &mut message)?;
 
-    for diff in compare_properties!(
-        source,
+    if let Some((new_status, new_message)) = compare_properties!(
         emacs,
         rust,
         (
@@ -3385,22 +3246,16 @@ fn compare_export_snippet<'b, 's>(
             |r| r.contents,
             compare_property_quoted_string
         )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
+    )? {
         this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
+        message = new_message;
     }
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3408,56 +3263,20 @@ fn compare_export_snippet<'b, 's>(
 }
 
 fn compare_footnote_reference<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b FootnoteReference<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
-    let mut child_status = Vec::new();
-    let mut this_status = DiffStatus::Good;
-    let mut message = None;
+    let this_status = DiffStatus::Good;
+    let message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.definition,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(
-        source,
-        emacs,
-        rust,
-        (
-            EmacsField::Required(":label"),
-            |r| r.label,
-            compare_property_quoted_string
-        ),
-        (
-            EmacsField::Required(":type"),
-            |r| Some(match r.get_type() {
-                FootnoteReferenceType::Standard => "standard",
-                FootnoteReferenceType::Inline => "inline",
-            }),
-            compare_property_unquoted_atom
-        )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
-                this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
-    }
+    // TODO: Compare :label :type
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3465,66 +3284,20 @@ fn compare_footnote_reference<'b, 's>(
 }
 
 fn compare_citation<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b Citation<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
-    let mut child_status = Vec::new();
-    let mut this_status = DiffStatus::Good;
-    let mut message = None;
+    let this_status = DiffStatus::Good;
+    let message = None;
 
-    compare_children(
-        source,
-        emacs,
-        &rust.children,
-        &mut child_status,
-        &mut this_status,
-        &mut message,
-    )?;
-
-    for diff in compare_properties!(
-        source,
-        emacs,
-        rust,
-        (
-            EmacsField::Required(":style"),
-            |r| r.style,
-            compare_property_quoted_string
-        ),
-        (
-            EmacsField::Optional(":prefix"),
-            |r| if r.prefix.is_empty() {
-                None
-            } else {
-                Some(r.prefix.iter())
-            },
-            compare_property_list_of_ast_nodes
-        ),
-        (
-            EmacsField::Optional(":suffix"),
-            |r| if r.suffix.is_empty() {
-                None
-            } else {
-                Some(r.suffix.iter())
-            },
-            compare_property_list_of_ast_nodes
-        )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
-                this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
-    }
+    // TODO: Compare :style :prefix :suffix
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }
@@ -3532,59 +3305,20 @@ fn compare_citation<'b, 's>(
 }
 
 fn compare_citation_reference<'b, 's>(
-    source: &'s str,
+    _source: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b CitationReference<'s>,
 ) -> Result<DiffEntry<'b, 's>, Box<dyn std::error::Error>> {
-    let mut this_status = DiffStatus::Good;
-    let mut child_status = Vec::new();
-    let mut message = None;
+    let this_status = DiffStatus::Good;
+    let message = None;
 
-    assert_no_children(emacs, &mut this_status, &mut message)?;
-
-    for diff in compare_properties!(
-        source,
-        emacs,
-        rust,
-        (
-            EmacsField::Required(":key"),
-            |r| Some(r.key),
-            compare_property_quoted_string
-        ),
-        (
-            EmacsField::Optional(":prefix"),
-            |r| if r.prefix.is_empty() {
-                None
-            } else {
-                Some(r.prefix.iter())
-            },
-            compare_property_list_of_ast_nodes
-        ),
-        (
-            EmacsField::Optional(":suffix"),
-            |r| if r.suffix.is_empty() {
-                None
-            } else {
-                Some(r.suffix.iter())
-            },
-            compare_property_list_of_ast_nodes
-        )
-    ) {
-        match diff {
-            ComparePropertiesResult::NoChange => {}
-            ComparePropertiesResult::SelfChange(new_status, new_message) => {
-                this_status = new_status;
-                message = new_message
-            }
-            ComparePropertiesResult::DiffEntry(diff_entry) => child_status.push(diff_entry),
-        }
-    }
+    // TODO: Compare :key :prefix :suffix
 
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),
         message,
-        children: child_status,
+        children: Vec::new(),
         rust_source: rust.get_source(),
         emacs_token: emacs,
     }

src/compare/macros.rs

@@ -30,9 +30,10 @@
 ///     }
 /// ```
 macro_rules! compare_properties {
-    ($source:expr, $emacs:expr, $rust:expr, $(($emacs_field:expr, $rust_value_getter:expr, $compare_fn: expr)),+) => {
+    ($emacs:expr, $rust:expr, $(($emacs_field:expr, $rust_value_getter:expr, $compare_fn: expr)),+) => {
         {
-            let mut new_status = Vec::new();
+            let mut this_status = DiffStatus::Good;
+            let mut message: Option<String> = None;
             let children = $emacs.as_list()?;
             let attributes_child = children
             .iter()
@@ -43,9 +44,10 @@ macro_rules! compare_properties {
             if emacs_keys.contains(":standard-properties") {
                 emacs_keys.remove(":standard-properties");
             } else {
-                new_status.push(ComparePropertiesResult::SelfChange(DiffStatus::Bad, Some(format!(
+                this_status = DiffStatus::Bad;
+                message = Some(format!(
                     "Emacs token lacks :standard-properties field.",
-                ))));
+                ));
             }
             $(
             match $emacs_field {
@@ -56,10 +58,11 @@ macro_rules! compare_properties {
                     emacs_keys.remove(name);
                 },
                 EmacsField::Required(name) => {
-                    new_status.push(ComparePropertiesResult::SelfChange(DiffStatus::Bad, Some(format!(
+                    this_status = DiffStatus::Bad;
+                    message = Some(format!(
                         "Emacs token lacks required field: {}",
                         name
-                    ))));
+                    ));
                 },
                 EmacsField::Optional(_name) => {},
             }
@@ -68,10 +71,11 @@ macro_rules! compare_properties {
             if !emacs_keys.is_empty() {
                 let unexpected_keys: Vec<&str> = emacs_keys.into_iter().collect();
                 let unexpected_keys = unexpected_keys.join(", ");
-                new_status.push(ComparePropertiesResult::SelfChange(DiffStatus::Bad, Some(format!(
+                this_status = DiffStatus::Bad;
+                message = Some(format!(
                     "Emacs token had extra field(s): {}",
                     unexpected_keys
-                ))));
+                ));
             }
 
             $(
@@ -83,23 +87,33 @@ macro_rules! compare_properties {
                     name
                 },
             };
-            let result = $compare_fn($source, $emacs, $rust, emacs_name, $rust_value_getter)?;
+            let result = $compare_fn($emacs, $rust, emacs_name, $rust_value_getter)?;
             match result {
-                ComparePropertiesResult::SelfChange(DiffStatus::Good, _) => unreachable!("No comparison functions should return SelfChange() when DiffStatus is good."),
-                ComparePropertiesResult::NoChange => {},
-                result => {
-                    new_status.push(result);
-                }
+                Some((DiffStatus::Good, _)) => unreachable!("No comparison functions should return Some() when DiffStatus is good."),
+                Some((status, msg)) => {
+                    this_status = status;
+                    message = msg;
+                },
+                _ => {}
             }
             )+
 
-            new_status
+            match this_status {
+                DiffStatus::Good => {
+                    let result: Result<_, Box<dyn std::error::Error>> = Ok(None);
+                    result
+                },
+                _ => {
+                    Ok(Some((this_status, message)))
+                }
+            }
         }
     };
     // Default case for when there are no expected properties except for :standard-properties
     ($emacs:expr) => {
         {
-            let mut new_status = Vec::new();
+            let mut this_status = DiffStatus::Good;
+            let mut message: Option<String> = None;
             let children = $emacs.as_list()?;
             let attributes_child = children
             .iter()
@@ -110,20 +124,30 @@ macro_rules! compare_properties {
             if emacs_keys.contains(":standard-properties") {
                 emacs_keys.remove(":standard-properties");
             } else {
-                new_status.push(ComparePropertiesResult::SelfChange(DiffStatus::Bad, Some(format!(
+                this_status = DiffStatus::Bad;
+                message = Some(format!(
                     "Emacs token lacks :standard-properties field.",
-                ))));
+                ));
             }
 
             if !emacs_keys.is_empty() {
                 let unexpected_keys: Vec<&str> = emacs_keys.into_iter().collect();
                 let unexpected_keys = unexpected_keys.join(", ");
-                new_status.push(ComparePropertiesResult::SelfChange(DiffStatus::Bad, Some(format!(
+                this_status = DiffStatus::Bad;
+                message = Some(format!(
                     "Emacs token had extra field(s): {}",
                     unexpected_keys
-                ))));
+                ));
+            }
+            match this_status {
+                DiffStatus::Good => {
+                    let result: Result<_, Box<dyn std::error::Error>> = Ok(None);
+                    result
+                },
+                _ => {
+                    Ok(Some((this_status, message)))
+                }
             }
-            new_status
         }
     };
 }

src/context/context.rs

@@ -116,10 +116,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
         }
     }
 
-    #[cfg_attr(
-        feature = "tracing",
-        tracing::instrument(ret, level = "debug", skip(self))
-    )]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     pub(crate) fn check_exit_matcher(
         &'r self,
         i: OrgSource<'s>,
@@ -166,10 +163,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn document_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/angle_link.rs

@@ -29,10 +29,7 @@ use crate::parser::util::get_consumed;
 use crate::types::AngleLink;
 use crate::types::LinkType;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn angle_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -71,10 +68,7 @@ struct PathAngle<'s> {
     application: Option<&'s str>,
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_angle<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -89,10 +83,7 @@ fn path_angle<'b, 'g, 'r, 's>(
     Ok((remaining, path))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_angle_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -100,10 +91,7 @@ fn path_angle_end<'b, 'g, 'r, 's>(
     tag(">")(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parse_angle_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -114,10 +102,7 @@ fn parse_angle_link<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parse_file_angle_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -152,10 +137,7 @@ fn parse_file_angle_link<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parse_protocol_angle_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/babel_call.rs

@@ -29,10 +29,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::org_line_ending;
 use crate::types::BabelCall;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn babel_call<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/citation.rs

@@ -2,7 +2,6 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::bytes::complete::tag_no_case;
 use nom::character::complete::anychar;
-use nom::combinator::map;
 use nom::combinator::opt;
 use nom::combinator::recognize;
 use nom::combinator::verify;
@@ -31,27 +30,24 @@ use crate::parser::util::get_consumed;
 use crate::types::Citation;
 use crate::types::Object;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn citation<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Citation<'s>> {
     // TODO: Despite being a standard object, citations cannot exist inside the global prefix/suffix for other citations because citations must contain something that matches @key which is forbidden inside the global prefix/suffix. This TODO is to evaluate if its worth putting in an explicit check for this (which can be easily accomplished by checking the output of `get_bracket_depth()`). I suspect its not worth it because I expect, outside of intentionally crafted inputs, this parser will exit immediately inside a citation since it is unlikely to find the "[cite" substring inside a citation global prefix/suffix.
     let (remaining, _) = tag_no_case("[cite")(input)?;
-    let (remaining, style) = opt(citestyle)(remaining)?;
+    let (remaining, _) = opt(citestyle)(remaining)?;
     let (remaining, _) = tag(":")(remaining)?;
-    let (remaining, prefix) =
+    let (remaining, _prefix) =
         must_balance_bracket(opt(parser_with_context!(global_prefix)(context)))(remaining)?;
 
-    let (remaining, references) =
+    let (remaining, _references) =
         separated_list1(tag(";"), parser_with_context!(citation_reference)(context))(remaining)?;
-    let (remaining, suffix) = must_balance_bracket(opt(map(
-        tuple((tag(";"), parser_with_context!(global_suffix)(context))),
-        |(_, suffix)| suffix,
-    )))(remaining)?;
+    let (remaining, _suffix) = must_balance_bracket(opt(tuple((
+        tag(";"),
+        parser_with_context!(global_suffix)(context),
+    ))))(remaining)?;
     let (remaining, _) = tag("]")(remaining)?;
     let (remaining, _trailing_whitespace) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
@@ -60,23 +56,16 @@ pub(crate) fn citation<'b, 'g, 'r, 's>(
         remaining,
         Citation {
             source: source.into(),
-            style: style.map(Into::<&str>::into),
-            prefix: prefix.unwrap_or(Vec::new()),
-            suffix: suffix.unwrap_or(Vec::new()),
-            children: references,
         },
     ))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn citestyle<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    map(
-        tuple((
-            tag("/"),
-            recognize(tuple((style, opt(tuple((tag("/"), variant)))))),
-        )),
-        |(_, style)| style,
-    )(input)
+    let (remaining, _) = tuple((tag("/"), style))(input)?;
+    let (remaining, _) = opt(tuple((tag("/"), variant)))(remaining)?;
+    let source = get_consumed(input, remaining);
+    Ok((remaining, source))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@@ -93,10 +82,7 @@ fn variant<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     })))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn global_prefix<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -122,10 +108,7 @@ fn global_prefix_end(starting_bracket_depth: BracketDepth) -> impl ContextMatche
     move |context, input: OrgSource<'_>| _global_prefix_end(context, input, starting_bracket_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _global_prefix_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -148,10 +131,7 @@ fn _global_prefix_end<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn global_suffix<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -176,10 +156,7 @@ fn global_suffix_end(starting_bracket_depth: BracketDepth) -> impl ContextMatche
     move |context, input: OrgSource<'_>| _global_suffix_end(context, input, starting_bracket_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _global_suffix_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -209,7 +186,6 @@ mod tests {
     use crate::context::GlobalSettings;
     use crate::context::List;
     use crate::parser::element_parser::element;
-    use crate::types::CitationReference;
     use crate::types::Element;
     use crate::types::GetStandardProperties;
 
@@ -237,16 +213,7 @@ mod tests {
                 .get(0)
                 .expect("Len already asserted to be 1"),
             &Object::Citation(Citation {
-                source: "[cite:@foo]",
-                style: None,
-                prefix: vec![],
-                suffix: vec![],
-                children: vec![CitationReference {
-                    source: "@foo",
-                    key: "foo",
-                    prefix: vec![],
-                    suffix: vec![]
-                }]
+                source: "[cite:@foo]"
             })
         );
     }

src/parser/citation_reference.rs

@@ -1,7 +1,6 @@
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::anychar;
-use nom::combinator::map;
 use nom::combinator::not;
 use nom::combinator::opt;
 use nom::combinator::recognize;
@@ -29,65 +28,47 @@ use crate::parser::util::WORD_CONSTITUENT_CHARACTERS;
 use crate::types::CitationReference;
 use crate::types::Object;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn citation_reference<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, CitationReference<'s>> {
-    let (remaining, prefix) =
+    let (remaining, _prefix) =
         must_balance_bracket(opt(parser_with_context!(key_prefix)(context)))(input)?;
-    let (remaining, key) = parser_with_context!(citation_reference_key)(context)(remaining)?;
-    let (remaining, suffix) =
+    let (remaining, _key) = parser_with_context!(citation_reference_key)(context)(remaining)?;
+    let (remaining, _suffix) =
         must_balance_bracket(opt(parser_with_context!(key_suffix)(context)))(remaining)?;
-    let without_closing_semi_remaining = remaining;
-    let (remaining, _closing_semi) = opt(tag(";"))(remaining)?;
     let source = get_consumed(input, remaining);
 
     Ok((
-        without_closing_semi_remaining,
+        remaining,
         CitationReference {
             source: source.into(),
-            key: key.into(),
-            prefix: prefix.unwrap_or(Vec::new()),
-            suffix: suffix.unwrap_or(Vec::new()),
         },
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn citation_reference_key<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    let (remaining, source) = map(
-        tuple((
+    let (remaining, source) = recognize(tuple((
         tag("@"),
-            recognize(many1(verify(
+        many1(verify(
             preceded(
                 not(parser_with_context!(exit_matcher_parser)(context)),
                 anychar,
             ),
             |c| {
-                    WORD_CONSTITUENT_CHARACTERS.contains(*c)
-                        || "-.:?~`'/*@+|(){}<>&_^$#%~".contains(*c)
+                WORD_CONSTITUENT_CHARACTERS.contains(*c) || "-.:?~`'/*@+|(){}<>&_^$#%~".contains(*c)
             },
-            ))),
         )),
-        |(_, key)| key,
-    )(input)?;
+    )))(input)?;
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn key_prefix<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -108,10 +89,7 @@ fn key_prefix<'b, 'g, 'r, 's>(
     Ok((remaining, children))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn key_suffix<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -136,10 +114,7 @@ fn key_prefix_end(starting_bracket_depth: BracketDepth) -> impl ContextMatcher {
     move |context, input: OrgSource<'_>| _key_prefix_end(context, input, starting_bracket_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _key_prefix_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -166,10 +141,7 @@ fn key_suffix_end(starting_bracket_depth: BracketDepth) -> impl ContextMatcher {
     move |context, input: OrgSource<'_>| _key_suffix_end(context, input, starting_bracket_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _key_suffix_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/clock.rs

@@ -24,10 +24,7 @@ use crate::types::Clock;
 use crate::types::ClockStatus;
 use crate::types::Timestamp;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn clock<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -58,10 +55,7 @@ pub(crate) fn clock<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn clock_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/comment.rs

@@ -26,10 +26,7 @@ use crate::parser::util::immediate_in_section;
 use crate::parser::util::start_of_line;
 use crate::types::Comment;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn comment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -72,10 +69,7 @@ pub(crate) fn comment<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn comment_line<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/diary_sexp.rs

@@ -15,10 +15,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 use crate::types::DiarySexp;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn diary_sexp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/document.rs

@@ -109,7 +109,7 @@ fn document<'b, 'g, 'r, 's>(
     Ok((Into::<&str>::into(remaining), doc))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 #[allow(dead_code)]
 fn document_org_source<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
@@ -186,7 +186,7 @@ fn document_org_source<'b, 'g, 'r, 's>(
     Ok((remaining.into(), document))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _document<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/drawer.rs

@@ -35,10 +35,7 @@ use crate::types::Element;
 use crate::types::Paragraph;
 use crate::types::SetSource;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn drawer<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -112,10 +109,7 @@ fn name<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     take_while(|c| WORD_CONSTITUENT_CHARACTERS.contains(c) || "-_".contains(c))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn drawer_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/dynamic_block.rs

@@ -40,10 +40,7 @@ use crate::types::Element;
 use crate::types::Paragraph;
 use crate::types::SetSource;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn dynamic_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -125,10 +122,7 @@ fn parameters<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     recognize(many_till(anychar, peek(tuple((space0, line_ending)))))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dynamic_block_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/element_parser.rs

@@ -51,7 +51,7 @@ pub(crate) const fn element(
     move |context, input: OrgSource<'_>| _element(context, input, can_be_paragraph)
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _element<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -177,7 +177,7 @@ pub(crate) const fn detect_element(
     move |context, input: OrgSource<'_>| _detect_element(context, input, can_be_paragraph)
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _detect_element<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/entity.rs

@@ -18,10 +18,7 @@ use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Entity;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn entity<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -48,10 +45,7 @@ pub(crate) fn entity<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/export_snippet.rs

@@ -19,10 +19,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::types::ExportSnippet;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn export_snippet<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -52,10 +49,7 @@ pub(crate) fn export_snippet<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn backend<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -66,10 +60,7 @@ fn backend<'b, 'g, 'r, 's>(
     Ok((remaining, backend_name))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn contents<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -81,10 +72,7 @@ fn contents<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn export_snippet_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/fixed_width_area.rs

@@ -22,10 +22,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 use crate::types::FixedWidthArea;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn fixed_width_area<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -63,10 +60,7 @@ pub(crate) fn fixed_width_area<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn fixed_width_area_line<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/footnote_definition.rs

@@ -34,10 +34,7 @@ use crate::parser::util::maybe_consume_trailing_whitespace;
 use crate::parser::util::start_of_line;
 use crate::types::FootnoteDefinition;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn footnote_definition<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -106,10 +103,7 @@ pub(crate) fn label<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
     take_while(|c| WORD_CONSTITUENT_CHARACTERS.contains(c) || "-_".contains(c))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn footnote_definition_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/footnote_reference.rs

@@ -1,36 +1,28 @@
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::bytes::complete::tag_no_case;
-use nom::combinator::all_consuming;
-use nom::combinator::map_parser;
 use nom::combinator::verify;
-use nom::multi::many1;
+use nom::multi::many_till;
 
 use super::org_source::BracketDepth;
 use super::org_source::OrgSource;
-use super::util::confine_context;
 use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
-use super::util::text_until_exit;
 use crate::context::parser_with_context;
-use crate::context::Context;
 use crate::context::ContextElement;
 use crate::context::ContextMatcher;
 use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
-use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
 use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::footnote_definition::label;
 use crate::parser::object_parser::standard_set_object;
+use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::types::FootnoteReference;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn footnote_reference<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -42,10 +34,7 @@ pub(crate) fn footnote_reference<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn anonymous_footnote<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -57,21 +46,13 @@ fn anonymous_footnote<'b, 'g, 'r, 's>(
         exit_matcher: &exit_with_depth,
     });
     let parser_context = context.with_additional_node(&parser_context);
-    let initial_context = ContextElement::document_context();
-    let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
-
-    let (remaining, children) = map_parser(
-        verify(
-            parser_with_context!(text_until_exit)(&parser_context),
-            |text| text.len() > 0,
+    let (remaining, (children, _exit_contents)) = verify(
+        many_till(
+            parser_with_context!(standard_set_object)(&parser_context),
+            parser_with_context!(exit_matcher_parser)(&parser_context),
         ),
-        confine_context(|i| {
-            all_consuming(many1(parser_with_context!(standard_set_object)(
-                &initial_context,
-            )))(i)
-        }),
+        |(children, _exit_contents)| !children.is_empty(),
     )(remaining)?;
-
     let (remaining, _) = tag("]")(remaining)?;
 
     let (remaining, _trailing_whitespace) =
@@ -87,10 +68,7 @@ fn anonymous_footnote<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inline_footnote<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -104,21 +82,13 @@ fn inline_footnote<'b, 'g, 'r, 's>(
         exit_matcher: &exit_with_depth,
     });
     let parser_context = context.with_additional_node(&parser_context);
-    let initial_context = ContextElement::document_context();
-    let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
-
-    let (remaining, children) = map_parser(
-        verify(
-            parser_with_context!(text_until_exit)(&parser_context),
-            |text| text.len() > 0,
+    let (remaining, (children, _exit_contents)) = verify(
+        many_till(
+            parser_with_context!(standard_set_object)(&parser_context),
+            parser_with_context!(exit_matcher_parser)(&parser_context),
         ),
-        confine_context(|i| {
-            all_consuming(many1(parser_with_context!(standard_set_object)(
-                &initial_context,
-            )))(i)
-        }),
+        |(children, _exit_contents)| !children.is_empty(),
     )(remaining)?;
-
     let (remaining, _) = tag("]")(remaining)?;
 
     let (remaining, _trailing_whitespace) =
@@ -134,10 +104,7 @@ fn inline_footnote<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn footnote_reference_only<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -164,10 +131,7 @@ fn footnote_definition_end(starting_bracket_depth: BracketDepth) -> impl Context
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _footnote_definition_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/greater_block.rs

@@ -44,10 +44,7 @@ use crate::types::QuoteBlock;
 use crate::types::SetSource;
 use crate::types::SpecialBlock;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn greater_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -89,10 +86,7 @@ pub(crate) fn greater_block<'b, 'g, 'r, 's>(
     Ok((remaining, element))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn center_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -116,10 +110,7 @@ fn center_block<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn quote_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -165,10 +156,7 @@ fn special_block<'s>(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _special_block<'c, 'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -197,10 +185,7 @@ fn _special_block<'c, 'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn greater_block_body<'c, 'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -269,10 +254,7 @@ fn greater_block_end<'c>(name: &'c str) -> impl ContextMatcher + 'c {
     move |context, input: OrgSource<'_>| _greater_block_end(context, input, name)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _greater_block_end<'b, 'g, 'r, 's, 'c>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/headline.rs

@@ -50,10 +50,7 @@ pub(crate) const fn heading(
     move |context, input: OrgSource<'_>| _heading(context, input, parent_level)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _heading<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -137,10 +134,7 @@ struct PreHeadline<'s> {
     is_footnote_section: bool,
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn headline<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -217,10 +211,7 @@ fn headline<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn headline_title_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -242,10 +233,7 @@ fn single_tag<'r, 's>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>
     })))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn heading_keyword<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -305,10 +293,7 @@ fn priority_cookie<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, PriorityCooki
     Ok((remaining, cookie))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn headline_level<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/horizontal_rule.rs

@@ -19,7 +19,7 @@ use crate::error::Res;
 use crate::parser::util::start_of_line;
 use crate::types::HorizontalRule;
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn horizontal_rule<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/in_buffer_settings.rs

@@ -84,7 +84,7 @@ fn in_buffer_settings_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSou
     ))(input)
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(level = "debug"))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
     keywords: Vec<Keyword<'sf>>,
     original_settings: &'g GlobalSettings<'g, 's>,

src/parser/inline_babel_call.rs

@@ -25,10 +25,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::types::InlineBabelCall;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn inline_babel_call<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -49,10 +46,7 @@ pub(crate) fn inline_babel_call<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -69,10 +63,7 @@ fn name<'b, 'g, 'r, 's>(
     Ok((remaining, name))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -80,10 +71,7 @@ fn name_end<'b, 'g, 'r, 's>(
     recognize(one_of("[("))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn header<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -109,10 +97,7 @@ fn header_end(starting_bracket_depth: BracketDepth) -> impl ContextMatcher {
     move |context, input: OrgSource<'_>| _header_end(context, input, starting_bracket_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _header_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -132,10 +117,7 @@ fn _header_end<'b, 'g, 'r, 's>(
     alt((tag("]"), line_ending))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn argument<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -161,10 +143,7 @@ fn argument_end(starting_parenthesis_depth: BracketDepth) -> impl ContextMatcher
     move |context, input: OrgSource<'_>| _argument_end(context, input, starting_parenthesis_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _argument_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/inline_source_block.rs

@@ -27,10 +27,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::types::InlineSourceBlock;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn inline_source_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -50,10 +47,7 @@ pub(crate) fn inline_source_block<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn lang<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -70,10 +64,7 @@ fn lang<'b, 'g, 'r, 's>(
     Ok((remaining, lang))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn lang_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -81,10 +72,7 @@ fn lang_end<'b, 'g, 'r, 's>(
     recognize(one_of("[{"))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn header<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -110,10 +98,7 @@ fn header_end(starting_bracket_depth: BracketDepth) -> impl ContextMatcher {
     move |context, input: OrgSource<'_>| _header_end(context, input, starting_bracket_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _header_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -133,10 +118,7 @@ fn _header_end<'b, 'g, 'r, 's>(
     alt((tag("]"), line_ending))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn body<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -172,10 +154,7 @@ fn body_end(starting_brace_depth: BracketDepth) -> impl ContextMatcher {
     move |context, input: OrgSource<'_>| _body_end(context, input, starting_brace_depth)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _body_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/keyword.rs

@@ -89,10 +89,7 @@ fn _filtered_keyword<'s, F: Matcher>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn keyword<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -107,10 +104,7 @@ pub(crate) fn keyword<'b, 'g, 'r, 's>(
     Ok((remaining, kw))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn affiliated_keyword_as_regular_keyword<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -128,10 +122,7 @@ pub(crate) fn affiliated_keyword<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>,
     filtered_keyword(affiliated_key)(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn table_formula_keyword<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/latex_environment.rs

@@ -28,10 +28,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::start_of_line;
 use crate::types::LatexEnvironment;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn latex_environment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -84,7 +81,7 @@ fn contents<F: ContextMatcher>(end_matcher: F) -> impl ContextMatcher {
 
 #[cfg_attr(
     feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context, end_matcher))
+    tracing::instrument(ret, level = "debug", skip(end_matcher))
 )]
 fn _contents<'b, 'g, 'r, 's, F: ContextMatcher>(
     end_matcher: F,
@@ -109,10 +106,7 @@ fn latex_environment_end(current_name: &str) -> impl ContextMatcher {
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _latex_environment_end<'b, 'g, 'r, 's, 'c>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/latex_fragment.rs

@@ -23,10 +23,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::types::LatexFragment;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn latex_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -52,10 +49,7 @@ pub(crate) fn latex_fragment<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn raw_latex_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -68,10 +62,7 @@ fn raw_latex_fragment<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -79,10 +70,7 @@ fn name<'b, 'g, 'r, 's>(
     alpha1(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn brackets<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -114,10 +102,7 @@ fn brackets<'b, 'g, 'r, 's>(
     Ok((remaining, body))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn escaped_parenthesis_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -136,10 +121,7 @@ fn escaped_parenthesis_fragment<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn escaped_bracket_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -158,10 +140,7 @@ fn escaped_bracket_fragment<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn double_dollar_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -181,10 +160,7 @@ fn double_dollar_fragment<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dollar_char_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -199,10 +175,7 @@ fn dollar_char_fragment<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -216,10 +189,7 @@ fn pre<'b, 'g, 'r, 's>(
     Ok((input, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn post<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -231,10 +201,7 @@ fn post<'b, 'g, 'r, 's>(
     Ok((remaining, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn bordered_dollar_fragment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -260,10 +227,7 @@ fn bordered_dollar_fragment<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn open_border<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -271,10 +235,7 @@ fn open_border<'b, 'g, 'r, 's>(
     recognize(verify(none_of(".,;$"), |c| !c.is_whitespace()))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn close_border<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/lesser_block.rs

@@ -48,10 +48,7 @@ use crate::types::SrcBlock;
 use crate::types::SwitchNumberLines;
 use crate::types::VerseBlock;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn verse_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -109,10 +106,7 @@ pub(crate) fn verse_block<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn comment_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -150,10 +144,7 @@ pub(crate) fn comment_block<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn example_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -216,10 +207,7 @@ pub(crate) fn example_block<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn export_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -265,10 +253,7 @@ pub(crate) fn export_block<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn src_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -353,10 +338,7 @@ fn lesser_block_end<'c>(current_name: &'c str) -> impl ContextMatcher + 'c {
     move |context, input: OrgSource<'_>| _lesser_block_end(context, input, current_name)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _lesser_block_end<'b, 'g, 'r, 's, 'c>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -382,10 +364,7 @@ const fn lesser_block_begin<'c>(current_name: &'c str) -> impl ContextMatcher +
     move |context, input: OrgSource<'_>| _lesser_block_begin(context, input, current_name)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _lesser_block_begin<'b, 'g, 'r, 's, 'c>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -615,10 +594,7 @@ fn switch_word<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn content<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/line_break.rs

@@ -12,10 +12,7 @@ use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::LineBreak;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn line_break<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -33,10 +30,7 @@ pub(crate) fn line_break<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/object_parser.rs

@@ -31,7 +31,7 @@ use crate::parser::text_markup::text_markup;
 use crate::parser::timestamp::timestamp;
 use crate::types::Object;
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn standard_set_object<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -46,7 +46,7 @@ pub(crate) fn standard_set_object<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn minimal_set_object<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -61,7 +61,7 @@ pub(crate) fn minimal_set_object<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -118,7 +118,7 @@ fn standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -139,7 +139,7 @@ fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -156,7 +156,7 @@ pub(crate) fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     ))));
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -173,7 +173,7 @@ fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     ))));
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn regular_link_description_set_object<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -191,7 +191,7 @@ pub(crate) fn regular_link_description_set_object<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -220,7 +220,7 @@ fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -237,7 +237,7 @@ fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     ))));
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn table_cell_set_object<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -252,7 +252,7 @@ pub(crate) fn table_cell_set_object<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -286,7 +286,7 @@ fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     Ok((remaining, object))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/org_macro.rs

@@ -19,10 +19,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::types::OrgMacro;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn org_macro<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -51,10 +48,7 @@ pub(crate) fn org_macro<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_macro_name<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -67,10 +61,7 @@ fn org_macro_name<'b, 'g, 'r, 's>(
     Ok((remaining, source))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_macro_args<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -83,10 +74,7 @@ fn org_macro_args<'b, 'g, 'r, 's>(
     Ok((remaining, args))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_macro_arg<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/paragraph.rs

@@ -29,7 +29,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::start_of_line;
 use crate::types::Paragraph;
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn paragraph<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -71,7 +71,7 @@ pub(crate) fn paragraph<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn paragraph_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/plain_link.rs

@@ -44,10 +44,7 @@ use crate::parser::util::WORD_CONSTITUENT_CHARACTERS;
 use crate::types::LinkType;
 use crate::types::PlainLink;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn plain_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -80,10 +77,7 @@ struct PathPlain<'s> {
     application: Option<&'s str>,
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -103,10 +97,7 @@ fn pre<'b, 'g, 'r, 's>(
     Ok((input, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn post<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -115,10 +106,7 @@ fn post<'b, 'g, 'r, 's>(
     Ok((remaining, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parse_path_plain<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -179,10 +167,7 @@ pub(crate) fn parse_path_and_search_option_without_search_option<'s>(
     map(rest, |path| (path, None))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn file_path_plain<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -222,10 +207,7 @@ fn file_path_plain<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn protocol_path_plain<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -253,10 +235,7 @@ fn protocol_path_plain<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn protocol<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -276,10 +255,7 @@ pub(crate) fn protocol<'b, 'g, 'r, 's>(
     ))))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_plain<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -308,10 +284,7 @@ fn path_plain_end(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn impl_path_plain_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -350,10 +323,7 @@ fn impl_path_plain_end<'b, 'g, 'r, 's>(
     ))))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_plain_no_parenthesis<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -381,10 +351,7 @@ fn path_plain_no_parenthesis_disallowed_character<'s>(
     }))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_plain_parenthesis<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/plain_list.rs

@@ -50,10 +50,7 @@ use crate::types::PlainListItemCounter;
 use crate::types::PlainListItemPreBlank;
 use crate::types::PlainListType;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn detect_plain_list<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -79,10 +76,7 @@ pub(crate) fn detect_plain_list<'b, 'g, 'r, 's>(
     ))));
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn plain_list<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -170,10 +164,7 @@ pub(crate) fn plain_list<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn plain_list_item<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -303,10 +294,7 @@ enum BulletType {
     Unordered,
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn bullet<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -330,10 +318,7 @@ fn bullet<'b, 'g, 'r, 's>(
     Ok((remaining, (bullet_type, with_space)))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn counter<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -373,10 +358,7 @@ fn counter_set_value<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, PlainListIt
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn plain_list_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -398,7 +380,7 @@ const fn plain_list_item_end(indent_level: IndentationLevel) -> impl ContextMatc
 
 #[cfg_attr(
     feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context, line_indented_lte_matcher))
+    tracing::instrument(ret, level = "debug", skip(line_indented_lte_matcher))
 )]
 fn _plain_list_item_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
@@ -416,10 +398,7 @@ const fn line_indented_lte(indent_level: IndentationLevel) -> impl ContextMatche
     move |context, input: OrgSource<'_>| _line_indented_lte(context, input, indent_level)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _line_indented_lte<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -437,10 +416,7 @@ fn _line_indented_lte<'b, 'g, 'r, 's>(
     Ok(matched)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn item_tag<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -462,10 +438,7 @@ fn item_tag<'b, 'g, 'r, 's>(
     Ok((remaining, children))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn item_tag_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -488,10 +461,7 @@ fn item_tag_divider<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
     )))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn item_tag_post_gap<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -524,10 +494,7 @@ fn item_checkbox<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, (CheckboxType,
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn detect_contentless_item_contents<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/plain_text.rs

@@ -42,7 +42,7 @@ where
 
 #[cfg_attr(
     feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context, end_condition))
+    tracing::instrument(ret, level = "debug", skip(end_condition))
 )]
 fn _plain_text<'b, 'g, 'r, 's, F>(
     end_condition: F,
@@ -75,10 +75,7 @@ where
 }
 
 impl<'x> RematchObject<'x> for PlainText<'x> {
-    #[cfg_attr(
-        feature = "tracing",
-        tracing::instrument(ret, level = "debug", skip(_context))
-    )]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'b, 'g, 'r, 's>(
         &'x self,
         _context: RefContext<'b, 'g, 'r, 's>,

src/parser/planning.rs

@@ -19,7 +19,7 @@ use crate::parser::util::start_of_line;
 use crate::types::Planning;
 use crate::types::Timestamp;
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn planning<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -70,7 +70,7 @@ enum PlanningTimestampType {
     Closed,
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn planning_parameter<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/property_drawer.rs

@@ -30,10 +30,7 @@ use crate::parser::util::start_of_line;
 use crate::types::NodeProperty;
 use crate::types::PropertyDrawer;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -85,10 +82,7 @@ pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn property_drawer_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -102,10 +96,7 @@ fn property_drawer_end<'b, 'g, 'r, 's>(
     )))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn node_property<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -150,10 +141,7 @@ fn node_property<'b, 'g, 'r, 's>(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn node_property_name<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -178,10 +166,7 @@ fn node_property_name<'b, 'g, 'r, 's>(
     Ok((remaining, name))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn node_property_name_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/radio_link.rs

@@ -2,23 +2,19 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
-use nom::combinator::all_consuming;
 use nom::combinator::consumed;
-use nom::combinator::map_parser;
+use nom::combinator::map;
 use nom::combinator::verify;
-use nom::multi::many1;
+use nom::multi::many_till;
 
 use super::object_parser::minimal_set_object;
 use super::org_source::OrgSource;
-use super::util::confine_context;
+use super::util::exit_matcher_parser;
 use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
-use super::util::text_until_exit;
 use crate::context::parser_with_context;
-use crate::context::Context;
 use crate::context::ContextElement;
 use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
-use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
 use crate::error::MyError;
@@ -28,10 +24,7 @@ use crate::types::Object;
 use crate::types::RadioLink;
 use crate::types::RadioTarget;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn radio_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -57,10 +50,7 @@ pub(crate) fn radio_link<'b, 'g, 'r, 's>(
     ))))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn rematch_target<'x, 'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     target: &'x Vec<Object<'x>>,
@@ -107,10 +97,7 @@ pub(crate) fn rematch_target<'x, 'b, 'g, 'r, 's>(
     Ok((remaining, new_matches))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn radio_target<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -121,19 +108,16 @@ pub(crate) fn radio_target<'b, 'g, 'r, 's>(
         exit_matcher: &radio_target_end,
     });
     let parser_context = context.with_additional_node(&parser_context);
-    let initial_context = ContextElement::document_context();
-    let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
 
-    let (remaining, (raw_value, children)) = consumed(map_parser(
-        verify(
-            parser_with_context!(text_until_exit)(&parser_context),
-            |text| text.len() > 0,
+    let (remaining, (raw_value, children)) = consumed(verify(
+        map(
+            many_till(
+                parser_with_context!(minimal_set_object)(&parser_context),
+                parser_with_context!(exit_matcher_parser)(&parser_context),
             ),
-        confine_context(|i| {
-            all_consuming(many1(parser_with_context!(minimal_set_object)(
-                &initial_context,
-            )))(i)
-        }),
+            |(children, _)| children,
+        ),
+        |children: &Vec<_>| !children.is_empty(),
     ))(remaining)?;
 
     let (remaining, _closing) = tag(">>>")(remaining)?;
@@ -150,10 +134,7 @@ pub(crate) fn radio_target<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn radio_target_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/regular_link.rs

@@ -8,7 +8,6 @@ use nom::bytes::complete::take;
 use nom::bytes::complete::take_till1;
 use nom::bytes::complete::take_until;
 use nom::character::complete::anychar;
-use nom::combinator::all_consuming;
 use nom::combinator::consumed;
 use nom::combinator::eof;
 use nom::combinator::flat_map;
@@ -19,7 +18,6 @@ use nom::combinator::peek;
 use nom::combinator::recognize;
 use nom::combinator::rest;
 use nom::combinator::verify;
-use nom::multi::many1;
 use nom::multi::many1_count;
 use nom::multi::many_till;
 use nom::sequence::tuple;
@@ -30,17 +28,15 @@ use super::org_source::BracketDepth;
 use super::org_source::OrgSource;
 use super::plain_link::parse_file_and_application;
 use super::plain_link::protocol;
-use super::util::confine_context;
+use super::util::exit_matcher_parser;
 use super::util::get_consumed;
 use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
 use super::util::text_until_exit;
 use crate::context::parser_with_context;
-use crate::context::Context;
 use crate::context::ContextElement;
 use crate::context::ContextMatcher;
 use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
-use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
 use crate::error::MyError;
@@ -49,10 +45,7 @@ use crate::types::LinkType;
 use crate::types::Object;
 use crate::types::RegularLink;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn regular_link<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -63,10 +56,7 @@ pub(crate) fn regular_link<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn regular_link_without_description<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -91,10 +81,7 @@ fn regular_link_without_description<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn regular_link_with_description<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -130,10 +117,7 @@ struct PathReg<'s> {
     application: Option<Cow<'s, str>>,
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pathreg<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -152,10 +136,7 @@ fn pathreg<'b, 'g, 'r, 's>(
     Ok((remaining, path))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parse_path_reg<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -211,10 +192,7 @@ enum ParserState {
     Percent,
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn apply_link_templates<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -274,10 +252,7 @@ fn apply_link_templates<'b, 'g, 'r, 's>(
     Some(ret)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn file_path_reg<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -380,10 +355,7 @@ fn code_ref_path_reg<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, PathReg<'s>
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn protocol_path_reg<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -420,10 +392,7 @@ fn fuzzy_path_reg<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, PathReg<'s>> {
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn description<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -433,28 +402,18 @@ fn description<'b, 'g, 'r, 's>(
         exit_matcher: &description_end,
     });
     let parser_context = context.with_additional_node(&parser_context);
-    let initial_context = ContextElement::document_context();
-    let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
-
-    let (remaining, children) = map_parser(
-        verify(
-            parser_with_context!(text_until_exit)(&parser_context),
-            |text| text.len() > 0,
+    let (remaining, (children, _exit_contents)) = verify(
+        many_till(
+            parser_with_context!(regular_link_description_set_object)(&parser_context),
+            parser_with_context!(exit_matcher_parser)(&parser_context),
         ),
-        confine_context(|i| {
-            all_consuming(many1(parser_with_context!(
-                regular_link_description_set_object
-            )(&initial_context)))(i)
-        }),
+        |(children, _exit_contents)| !children.is_empty(),
     )(input)?;
 
     Ok((remaining, children))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn description_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -476,10 +435,7 @@ fn path_reg_end(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn impl_path_reg_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/section.rs

@@ -24,10 +24,7 @@ use crate::parser::util::maybe_consume_trailing_whitespace_if_not_exiting;
 use crate::types::Element;
 use crate::types::Section;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn zeroth_section<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -85,10 +82,7 @@ pub(crate) fn zeroth_section<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn section<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     mut input: OrgSource<'s>,
@@ -141,10 +135,7 @@ pub(crate) fn section<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn section_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/statistics_cookie.rs

@@ -12,7 +12,7 @@ use crate::context::RefContext;
 use crate::error::Res;
 use crate::types::StatisticsCookie;
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn statistics_cookie<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -23,7 +23,7 @@ pub(crate) fn statistics_cookie<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn percent_statistics_cookie<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -44,7 +44,7 @@ fn percent_statistics_cookie<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug", skip(context)))]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/subscript_and_superscript.rs

@@ -46,10 +46,7 @@ pub(crate) fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<O
     Ok((input, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn subscript<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -69,10 +66,7 @@ pub(crate) fn subscript<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn superscript<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -104,10 +98,7 @@ enum ScriptBody<'s> {
     WithBraces(Vec<Object<'s>>),
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_body<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -129,10 +120,7 @@ fn script_body<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_asterisk<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -140,10 +128,7 @@ fn script_asterisk<'b, 'g, 'r, 's>(
     tag("*")(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_alphanum<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -172,10 +157,7 @@ fn end_script_alphanum_character<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>,
     Ok((remaining, final_char))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_with_braces<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -203,10 +185,7 @@ fn script_with_braces_end(starting_brace_depth: BracketDepth) -> impl ContextMat
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _script_with_braces_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -226,10 +205,7 @@ fn _script_with_braces_end<'b, 'g, 'r, 's>(
     tag("}")(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_with_parenthesis<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/table.rs

@@ -36,10 +36,7 @@ use crate::types::TableRow;
 /// Parse an org-mode-style table
 ///
 /// This is not the table.el style.
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn org_mode_table<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -91,10 +88,7 @@ pub(crate) fn detect_table<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
     Ok((input, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn table_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -103,10 +97,7 @@ fn table_end<'b, 'g, 'r, 's>(
     recognize(tuple((space0, not(tag("|")))))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_row<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -117,10 +108,7 @@ fn org_mode_table_row<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -137,10 +125,7 @@ fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -160,10 +145,7 @@ fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_cell<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -196,10 +178,7 @@ fn org_mode_table_cell<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_cell_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/target.rs

@@ -20,10 +20,7 @@ use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Target;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn target<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -64,10 +61,7 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn target_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/text_markup.rs

@@ -1,6 +1,7 @@
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::anychar;
+use nom::character::complete::line_ending;
 use nom::character::complete::multispace1;
 use nom::character::complete::one_of;
 use nom::character::complete::space0;
@@ -19,7 +20,6 @@ use super::org_source::OrgSource;
 use super::radio_link::RematchObject;
 use super::util::in_object_section;
 use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
-use super::util::org_line_ending;
 use super::util::start_of_line;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
@@ -42,10 +42,7 @@ use crate::types::StrikeThrough;
 use crate::types::Underline;
 use crate::types::Verbatim;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn text_markup<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -63,10 +60,7 @@ pub(crate) fn text_markup<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn bold<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -82,10 +76,7 @@ fn bold<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn italic<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -101,10 +92,7 @@ fn italic<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn underline<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -120,10 +108,7 @@ fn underline<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn strike_through<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -139,10 +124,7 @@ fn strike_through<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn verbatim<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -158,10 +140,7 @@ fn verbatim<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn code<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -187,10 +166,7 @@ fn text_markup_object<'c>(
     move |context, input: OrgSource<'_>| _text_markup_object(context, input, marker_symbol)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -253,10 +229,7 @@ fn text_markup_string<'c>(
     move |context, input: OrgSource<'_>| _text_markup_string(context, input, marker_symbol)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -308,10 +281,7 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
     Ok((remaining, contents))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -336,16 +306,12 @@ fn pre<'b, 'g, 'r, 's>(
     Ok((input, ()))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn post<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
-    let (remaining, _) =
-        alt((recognize(one_of(" \r\n\t-.,;:!?')}[\"\\")), org_line_ending))(input)?;
+    let (remaining, _) = alt((recognize(one_of(" \r\n\t-.,;:!?')}[\"\\")), line_ending))(input)?;
     Ok((remaining, ()))
 }
 
@@ -358,10 +324,7 @@ fn text_markup_end<'c>(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _text_markup_end<'b, 'g, 'r, 's, 'c>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -383,10 +346,7 @@ fn _text_markup_end<'b, 'g, 'r, 's, 'c>(
 }
 
 impl<'x> RematchObject<'x> for Bold<'x> {
-    #[cfg_attr(
-        feature = "tracing",
-        tracing::instrument(ret, level = "debug", skip(_context))
-    )]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'b, 'g, 'r, 's>(
         &'x self,
         _context: RefContext<'b, 'g, 'r, 's>,
@@ -406,10 +366,7 @@ impl<'x> RematchObject<'x> for Bold<'x> {
 }
 
 impl<'x> RematchObject<'x> for Italic<'x> {
-    #[cfg_attr(
-        feature = "tracing",
-        tracing::instrument(ret, level = "debug", skip(_context))
-    )]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'b, 'g, 'r, 's>(
         &'x self,
         _context: RefContext<'b, 'g, 'r, 's>,
@@ -429,10 +386,7 @@ impl<'x> RematchObject<'x> for Italic<'x> {
 }
 
 impl<'x> RematchObject<'x> for Underline<'x> {
-    #[cfg_attr(
-        feature = "tracing",
-        tracing::instrument(ret, level = "debug", skip(_context))
-    )]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'b, 'g, 'r, 's>(
         &'x self,
         _context: RefContext<'b, 'g, 'r, 's>,
@@ -452,10 +406,7 @@ impl<'x> RematchObject<'x> for Underline<'x> {
 }
 
 impl<'x> RematchObject<'x> for StrikeThrough<'x> {
-    #[cfg_attr(
-        feature = "tracing",
-        tracing::instrument(ret, level = "debug", skip(_context))
-    )]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'b, 'g, 'r, 's>(
         &'x self,
         _context: RefContext<'b, 'g, 'r, 's>,
@@ -474,10 +425,7 @@ impl<'x> RematchObject<'x> for StrikeThrough<'x> {
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _rematch_text_markup_object<'b, 'g, 'r, 's, 'x>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/timestamp.rs

@@ -37,10 +37,7 @@ use crate::types::WarningDelay;
 use crate::types::WarningDelayType;
 use crate::types::Year;
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -58,10 +55,7 @@ pub(crate) fn timestamp<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn diary_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -89,10 +83,7 @@ fn diary_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn sexp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -114,10 +105,7 @@ fn sexp<'b, 'g, 'r, 's>(
     Ok((remaining, body))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn sexp_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -125,10 +113,7 @@ fn sexp_end<'b, 'g, 'r, 's>(
     alt((tag(")>"), recognize(one_of(">\n"))))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -179,10 +164,7 @@ fn active_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn inactive_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -233,10 +215,7 @@ pub(crate) fn inactive_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_date_range_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -268,10 +247,7 @@ fn active_date_range_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_time_range_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -322,10 +298,7 @@ fn active_time_range_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn inactive_date_range_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -358,10 +331,7 @@ pub(crate) fn inactive_date_range_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn inactive_time_range_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -412,10 +382,7 @@ pub(crate) fn inactive_time_range_timestamp<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn date<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -448,10 +415,7 @@ fn date<'b, 'g, 'r, 's>(
     Ok((remaining, date))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dayname<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -473,10 +437,7 @@ fn dayname<'b, 'g, 'r, 's>(
     Ok((remaining, body))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dayname_end<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -493,10 +454,7 @@ const fn time<'c>(
     move |context, input| _time(context, input, allow_rest)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _time<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -524,10 +482,7 @@ fn _time<'b, 'g, 'r, 's>(
     Ok((remaining, time))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn time_rest<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -540,10 +495,7 @@ fn time_rest<'b, 'g, 'r, 's>(
     Ok((remaining, body))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_time_rest_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -558,10 +510,7 @@ fn active_time_rest_end<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_time_rest_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -576,10 +525,7 @@ fn inactive_time_rest_end<'b, 'g, 'r, 's>(
     ))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn time_range_rest_end<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -593,10 +539,7 @@ fn time_range_rest_end<'b, 'g, 'r, 's>(
     exit_contents
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn repeater<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -631,10 +574,7 @@ fn repeater<'b, 'g, 'r, 's>(
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn warning_delay<'b, 'g, 'r, 's>(
     _context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,

src/parser/util.rs

@@ -1,5 +1,3 @@
-use std::fmt::Debug;
-
 use nom::branch::alt;
 use nom::character::complete::anychar;
 use nom::character::complete::line_ending;
@@ -91,10 +89,7 @@ fn element_trailing_whitespace<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, O
     alt((eof, recognize(many0(blank_line))))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -110,10 +105,7 @@ pub(crate) fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r
     Ok((remaining, None))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -126,10 +118,7 @@ pub(crate) fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -186,10 +175,7 @@ pub(crate) fn non_whitespace_character(input: OrgSource<'_>) -> Res<OrgSource<'_
 }
 
 /// Check that we are at the start of a line
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn exit_matcher_parser<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -197,10 +183,7 @@ pub(crate) fn exit_matcher_parser<'b, 'g, 'r, 's>(
     peek(|i| context.check_exit_matcher(i))(input)
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn text_until_exit<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
@@ -318,28 +301,3 @@ pub(crate) fn get_has_affiliated_keyword<'b, 'g, 'r, 's>(
     }
     None
 }
-
-/// Reset the input OrgSource as if it was starting a fresh document.
-///
-/// This is important for making start-of-document, end-of-document, and other context-dependent tests succeed.
-pub(crate) fn confine_context<'s, O: Debug, I: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, O>>(
-    inner: I,
-) -> impl Fn(OrgSource<'s>) -> Res<OrgSource<'s>, O> {
-    move |input| impl_confine_context(input, &inner)
-}
-
-/// Reset the input OrgSource as if it was starting a fresh document.
-///
-/// This is important for making start-of-document, end-of-document, and other context-dependent tests succeed.
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(inner))
-)]
-fn impl_confine_context<'s, O: Debug, I: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, O>>(
-    input: OrgSource<'s>,
-    inner: I,
-) -> Res<OrgSource<'s>, O> {
-    let raw_str = Into::<&str>::into(input);
-    let back_to_org_source = Into::<OrgSource<'_>>::into(raw_str);
-    inner(back_to_org_source)
-}

src/types/mod.rs

@@ -69,7 +69,6 @@ pub use object::DayOfMonthInner;
 pub use object::Entity;
 pub use object::ExportSnippet;
 pub use object::FootnoteReference;
-pub use object::FootnoteReferenceType;
 pub use object::Hour;
 pub use object::HourInner;
 pub use object::InlineBabelCall;

src/types/object.rs

@@ -200,18 +200,11 @@ pub struct FootnoteReference<'s> {
 #[derive(Debug, PartialEq)]
 pub struct Citation<'s> {
     pub source: &'s str,
-    pub style: Option<&'s str>,
-    pub prefix: Vec<Object<'s>>,
-    pub suffix: Vec<Object<'s>>,
-    pub children: Vec<CitationReference<'s>>,
 }
 
 #[derive(Debug, PartialEq)]
 pub struct CitationReference<'s> {
     pub source: &'s str,
-    pub key: &'s str,
-    pub prefix: Vec<Object<'s>>,
-    pub suffix: Vec<Object<'s>>,
 }
 
 #[derive(Debug, PartialEq)]
@@ -771,19 +764,3 @@ impl<'s> OrgMacro<'s> {
             .map(|arg| coalesce_whitespace_escaped('\\', |c| ",".contains(c))(*arg))
     }
 }
-
-#[derive(Debug, PartialEq)]
-pub enum FootnoteReferenceType {
-    Standard,
-    Inline,
-}
-
-impl<'s> FootnoteReference<'s> {
-    pub fn get_type(&self) -> FootnoteReferenceType {
-        if self.definition.is_empty() {
-            FootnoteReferenceType::Standard
-        } else {
-            FootnoteReferenceType::Inline
-        }
-    }
-}