Merge branch 'foreign_document_literate_build_emacs'

This is to remove the ambiguity between calling iter on the specific structs like Document and calling iter on an AstNode by having an explicitly-named function to create the iterator.

Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "organic"
-version = "0.1.11"
+version = "0.1.12"
 authors = ["Tom Alexander <tom@fizz.buzz>"]
 description = "An org-mode parser."
 edition = "2021"
@@ -59,6 +59,7 @@ default = []
 compare = ["tokio/process", "tokio/macros"]
 foreign_document_test = ["compare", "dep:futures", "tokio/sync", "dep:walkdir", "tokio/process"]
 tracing = ["dep:opentelemetry", "dep:opentelemetry-otlp", "dep:opentelemetry-semantic-conventions", "dep:tokio", "dep:tracing", "dep:tracing-opentelemetry", "dep:tracing-subscriber"]
+event_count = []
 
 # Optimized build for any sort of release.
 [profile.release-lto]

Makefile

@@ -45,10 +45,6 @@ dockerclippy:
 clippy:
 > cargo clippy --no-deps --all-targets --all-features -- -D warnings
 
-.PHONY: clippyfix
-clippyfix:
-> cargo clippy --fix --lib -p organic --all-features
-
 .PHONY: test
 test:
 > cargo test --no-default-features --features compare --no-fail-fast --lib --test test_loader -- --test-threads $(TESTJOBS)

build.rs

@@ -66,10 +66,6 @@ fn write_test(test_file: &mut File, test: &walkdir::DirEntry) {
 }
 
 #[cfg(feature = "compare")]
-fn is_expect_fail(name: &str) -> Option<&str> {
+fn is_expect_fail(_name: &str) -> Option<&str> {
-    match name {
+    None
-        "greater_element_drawer_drawer_with_headline_inside" => Some("Apparently lines with :end: become their own paragraph. This odd behavior needs to be investigated more."),
-        "element_container_priority_footnote_definition_dynamic_block" => Some("Apparently broken begin lines become their own paragraph."),
-        _ => None,
-    }
 }

docker/organic_clippy/Makefile

@@ -25,13 +25,13 @@ ifdef REMOTE_REPO
 else
 	@echo "REMOTE_REPO not defined, not removing from remote repo."
 endif
-	docker volume rm cargo-cache
+	docker volume rm rust-cache cargo-cache
 
 # NOTE: This target will write to folders underneath the git-root
 .PHONY: run
 run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry $(IMAGE_NAME)
+	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)
 
 .PHONY: shell
 shell: build
-	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry $(IMAGE_NAME)
+	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)

docker/organic_test/Dockerfile

@@ -93,6 +93,12 @@ ARG WORG_PATH=/foreign_documents/worg
 ARG WORG_REPO=https://git.sr.ht/~bzg/worg
 RUN mkdir -p $WORG_PATH && git -C $WORG_PATH init --initial-branch=main && git -C $WORG_PATH remote add origin $WORG_REPO && git -C $WORG_PATH fetch origin $WORG_VERSION && git -C $WORG_PATH checkout FETCH_HEAD
 
+ARG LITERATE_BUILD_EMACS_VERSION=e3ac1afe1e40af601be7af12c1d13d96308ab209
+ARG LITERATE_BUILD_EMACS_PATH=/foreign_documents/literate_build_emacs
+ARG LITERATE_BUILD_EMACS_REPO=https://gitlab.com/spudlyo/orgdemo2.git
+RUN mkdir -p $LITERATE_BUILD_EMACS_PATH && git -C $LITERATE_BUILD_EMACS_PATH init --initial-branch=main && git -C $LITERATE_BUILD_EMACS_PATH remote add origin $LITERATE_BUILD_EMACS_REPO && git -C $LITERATE_BUILD_EMACS_PATH fetch origin $LITERATE_BUILD_EMACS_VERSION && git -C $LITERATE_BUILD_EMACS_PATH checkout FETCH_HEAD
+# unused/aws.org contains invalid paths for setupfile which causes both upstream org-mode and Organic to error out.
+RUN rm $LITERATE_BUILD_EMACS_PATH/unused/aws.org
 
 FROM tester as foreign-document-test
 RUN apk add --no-cache bash coreutils
@@ -100,6 +106,7 @@ RUN mkdir /foreign_documents
 COPY --from=foreign-document-gather /foreign_documents/howardabrams /foreign_documents/howardabrams
 COPY --from=foreign-document-gather /foreign_documents/doomemacs /foreign_documents/doomemacs
 COPY --from=foreign-document-gather /foreign_documents/worg /foreign_documents/worg
+COPY --from=foreign-document-gather /foreign_documents/literate_build_emacs /foreign_documents/literate_build_emacs
 COPY --from=build-org-mode /root/org-mode /foreign_documents/org-mode
 COPY --from=build-emacs /root/emacs /foreign_documents/emacs
 ENTRYPOINT ["cargo", "run", "--bin", "foreign_document_test", "--features", "compare,foreign_document_test", "--profile", "release-lto"]

org_mode_samples/affiliated_keyword/empty_caption.org

@@ -0,0 +1,5 @@
+#+caption:
+#+caption: *foo*
+#+caption[bar]:
+#+begin_src bash
+#+end_src

org_mode_samples/bullshitium/fake_paragraph/broken_end.org

@@ -0,0 +1,3 @@
+foo
+:end:
+bar

org_mode_samples/bullshitium/fake_paragraph/broken_end_isolated.org

@@ -0,0 +1,2 @@
+foo
+:end:

org_mode_samples/object/target/simple.org

@@ -1,3 +0,0 @@
-foo <<bar>> baz
-
-lorem << ipsum >> dolar

scripts/dump_ast.bash

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+#
+# Dump the AST of an org-mode document from emacs
+set -euo pipefail
+IFS=$'\n\t'
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+REALPATH=$(command -v uu-realpath || command -v realpath)
+MAKE=$(command -v gmake || command -v make)
+
+############## Setup #########################
+
+function die {
+    local status_code="$1"
+    shift
+    (>&2 echo "${@}")
+    exit "$status_code"
+}
+
+function log {
+    (>&2 echo "${@}")
+}
+
+############## Program #########################
+
+function main {
+    if [ $# -eq 0 ]; then
+        dump_ast_stdin "${@}"
+    else
+        dump_ast_file "${@}"
+    fi
+}
+
+function dump_ast_stdin {
+    # Until we can find a good way to encode stdin as an elisp string in bash, I cannot operate on stdin.
+    die 1 "This script only works on files."
+}
+
+function dump_ast_file {
+    local target_file mounted_file elisp_script
+    target_file=$($REALPATH "$1")
+    mounted_file="/input${target_file}"
+    elisp_script=$(cat <<EOF
+(progn
+     (erase-buffer)
+     (require 'org)
+     (defun org-table-align () t)
+     (find-file-read-only "${mounted_file}")
+     (org-mode)
+     (message "%s" (pp-to-string (org-element-parse-buffer)))
+)
+EOF
+          )
+    exec docker run --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro" --entrypoint "" organic-test emacs -q --no-site-file --no-splash --batch --eval "$elisp_script"
+}
+
+
+main "${@}"

scripts/perf.bash

@@ -14,7 +14,7 @@ function main {
         additional_flags+=(--profile "$PROFILE")
     fi
     (cd "$DIR/../" && cargo build --no-default-features "${additional_flags[@]}")
-    perf record --freq=2000 --call-graph dwarf --output="$DIR/../perf.data" "$DIR/../target/${PROFILE}/parse" "${@}"
+    perf record --freq=70000 --call-graph dwarf --output="$DIR/../perf.data" "$DIR/../target/${PROFILE}/parse" "${@}"
 
     # Convert to a format firefox will read
     # flags to consider --show-info

src/bin_foreign_document_test.rs

@@ -53,6 +53,9 @@ async fn main_body() -> Result<ExitCode, Box<dyn std::error::Error>> {
     let layer = layer.chain(compare_group("doomemacs", || {
         compare_all_org_document("/foreign_documents/doomemacs")
     }));
+    let layer = layer.chain(compare_group("literate_build_emacs", || {
+        compare_all_org_document("/foreign_documents/literate_build_emacs")
+    }));
 
     let running_tests: Vec<_> = layer.map(|c| tokio::spawn(c.run_test())).collect();
     let mut any_failed = false;

src/compare/compare_field.rs

@@ -1,3 +1,5 @@
+use std::borrow::Borrow;
+use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::str::FromStr;
@@ -262,11 +264,11 @@ pub(crate) fn compare_property_set_of_quoted_string<
         .iter()
         .map(|e| e.as_atom())
         .collect::<Result<Vec<_>, _>>()?;
-    let value: Vec<String> = value
+    let value: Vec<Cow<'_, str>> = value
         .into_iter()
         .map(unquote)
         .collect::<Result<Vec<_>, _>>()?;
-    let value: BTreeSet<&str> = value.iter().map(|e| e.as_str()).collect();
+    let value: BTreeSet<&str> = value.iter().map(|e| e.borrow()).collect();
     let mismatched: Vec<_> = value.symmetric_difference(&rust_value).copied().collect();
     if !mismatched.is_empty() {
         let this_status = DiffStatus::Bad;
@@ -546,6 +548,21 @@ where
     let mut full_status: Vec<DiffEntry<'b, 's>> = Vec::with_capacity(outer_rust_list.len());
 
     for (kw_e, kw_r) in outer_emacs_list.iter().zip(outer_rust_list) {
+        match (kw_e.as_atom(), kw_r) {
+            (Ok("nil"), (None, mandatory_value)) if mandatory_value.is_empty() => {
+                // If its an empty keyword then it becomes nil in the elisp.
+                continue;
+            }
+            (Ok("nil"), _) => {
+                let this_status = DiffStatus::Bad;
+                let message = Some(format!(
+                    "{} mismatch (emacs != rust) {:?} != {:?}",
+                    emacs_field, kw_e, kw_r
+                ));
+                return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+            }
+            _ => {}
+        }
         let kw_e = kw_e.as_list()?;
         let child_status_length = kw_r.1.len() + kw_r.0.as_ref().map(|opt| opt.len()).unwrap_or(0);
         let mut child_status: Vec<DiffEntry<'b, 's>> = Vec::with_capacity(child_status_length);
@@ -554,6 +571,17 @@ where
             let mut kw_e = kw_e.iter();
             // First element is a list representing the mandatory value.
             if let Some(val_e) = kw_e.next() {
+                match (val_e.as_atom(), kw_r) {
+                    (Ok("nil"), (_, mandatory_value)) if mandatory_value.is_empty() => {}
+                    (Ok("nil"), _) => {
+                        let this_status = DiffStatus::Bad;
+                        let message = Some(format!(
+                            "{} mismatch (emacs != rust) {:?} != {:?}",
+                            emacs_field, kw_e, kw_r
+                        ));
+                        return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+                    }
+                    _ => {
                         let el = val_e.as_list()?;
                         if el.len() != kw_r.1.len() {
                             let this_status = DiffStatus::Bad;
@@ -566,6 +594,8 @@ where
                         for (e, r) in el.iter().zip(kw_r.1.iter()) {
                             child_status.push(compare_ast_node(source, e, r.into())?);
                         }
+                    }
+                };
             } else {
                 let this_status = DiffStatus::Bad;
                 let message = Some(format!(
@@ -653,7 +683,7 @@ pub(crate) fn compare_property_number_lines<
         (Some(number_lines), Some(rust_number_lines)) => {
             let token_list = number_lines.as_list()?;
             let number_type = token_list
-                .get(0)
+                .first()
                 .map(Token::as_atom)
                 .map_or(Ok(None), |r| r.map(Some))?
                 .ok_or(":number-lines should have a type.")?;

src/compare/diff.rs

@@ -128,7 +128,7 @@ pub struct DiffResult<'b, 's> {
     emacs_token: &'b Token<'s>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub(crate) enum DiffStatus {
     Good,
     Bad,
@@ -164,7 +164,7 @@ impl<'b, 's> DiffEntry<'b, 's> {
 
     fn is_immediately_bad(&self) -> bool {
         match self {
-            DiffEntry::DiffResult(diff) => diff.status == DiffStatus::Bad,
+            DiffEntry::DiffResult(diff) => matches!(diff.status, DiffStatus::Bad),
             DiffEntry::DiffLayer(_) => false,
         }
     }
@@ -1576,7 +1576,7 @@ fn compare_example_block<'b, 's>(
         [],
         (
             EmacsField::Required(":value"),
-            |r| Some(r.contents.as_str()),
+            |r| Some(&r.contents),
             compare_property_quoted_string
         ),
         (
@@ -1654,7 +1654,7 @@ fn compare_export_block<'b, 's>(
         ),
         (
             EmacsField::Required(":value"),
-            |r| Some(r.contents.as_str()),
+            |r| Some(&r.contents),
             compare_property_quoted_string
         )
     ) {
@@ -1702,7 +1702,7 @@ fn compare_src_block<'b, 's>(
         ),
         (
             EmacsField::Required(":value"),
-            |r| Some(r.contents.as_str()),
+            |r| Some(&r.contents),
             compare_property_quoted_string
         ),
         (
@@ -2153,7 +2153,7 @@ fn compare_plain_text<'b, 's>(
     let text = emacs.as_text()?;
     let start_ind: usize = text
         .properties
-        .get(0)
+        .first()
         .expect("Should have start index.")
         .as_atom()?
         .parse()?;

src/compare/sexp.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashMap;
 
 use nom::branch::alt;
@@ -36,12 +37,6 @@ pub struct TextWithProperties<'s> {
     pub(crate) properties: Vec<Token<'s>>,
 }
 
-enum ParseState {
-    Normal,
-    Escape,
-    Octal(Vec<u8>),
-}
-
 impl<'s> Token<'s> {
     pub(crate) fn as_vector<'p>(
         &'p self,
@@ -117,8 +112,27 @@ fn get_consumed<'s>(input: &'s str, remaining: &'s str) -> &'s str {
     &input[..offset]
 }
 
-pub(crate) fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
+#[derive(Debug)]
-    let mut out: Vec<u8> = Vec::with_capacity(text.len());
+enum UnquoteState {
+    Normal,
+    Escape,
+    HasEscape {
+        out: Vec<u8>,
+    },
+    HasEscapeEscape {
+        out: Vec<u8>,
+    },
+    Octal {
+        octal_begin_offset: usize,
+        octal: Vec<u8>,
+    },
+    HasEscapeOctal {
+        out: Vec<u8>,
+        octal: Vec<u8>,
+    },
+}
+
+pub(crate) fn unquote(text: &str) -> Result<Cow<'_, str>, Box<dyn std::error::Error>> {
     if !text.starts_with('"') {
         return Err("Quoted text does not start with quote.".into());
     }
@@ -126,54 +140,143 @@ pub(crate) fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>>
         return Err("Quoted text does not end with quote.".into());
     }
     let interior_text = &text[1..(text.len() - 1)];
-    let mut state = ParseState::Normal;
+    let mut state = UnquoteState::Normal;
-    for current_char in interior_text.bytes() {
+    for (offset, current_char) in interior_text.bytes().enumerate() {
         // Check to see if octal finished
         state = match (state, current_char) {
-            (ParseState::Octal(octal), b'0'..=b'7') if octal.len() < MAX_OCTAL_LENGTH => {
+            (
-                ParseState::Octal(octal)
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    octal,
+                },
+                b'0'..=b'7',
+            ) if octal.len() < MAX_OCTAL_LENGTH => UnquoteState::Octal {
+                octal_begin_offset,
+                octal,
+            },
+            (
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    octal,
+                },
+                _,
+            ) => {
+                let octal_number_string = String::from_utf8(octal)?;
+                let decoded_byte = u8::from_str_radix(&octal_number_string, 8)?;
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                out.extend_from_slice(&interior_text.as_bytes()[..octal_begin_offset]);
+                out.push(decoded_byte);
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Octal(octal), _) => {
+            (UnquoteState::HasEscapeOctal { out, octal }, b'0'..=b'7')
+                if octal.len() < MAX_OCTAL_LENGTH =>
+            {
+                UnquoteState::HasEscapeOctal { out, octal }
+            }
+            (UnquoteState::HasEscapeOctal { mut out, octal }, _) => {
                 let octal_number_string = String::from_utf8(octal)?;
                 let decoded_byte = u8::from_str_radix(&octal_number_string, 8)?;
                 out.push(decoded_byte);
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
             (state, _) => state,
         };
 
         state = match (state, current_char) {
-            (ParseState::Normal, b'\\') => ParseState::Escape,
+            (UnquoteState::Normal, b'\\') => UnquoteState::Escape,
-            (ParseState::Normal, _) => {
+            (UnquoteState::Normal, _) => UnquoteState::Normal,
+            (UnquoteState::HasEscape { out }, b'\\') => UnquoteState::HasEscapeEscape { out },
+            (UnquoteState::HasEscape { mut out }, _) => {
                 out.push(current_char);
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'n') => {
+            (UnquoteState::Escape, b'n') => {
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                // Subtract 1 from offset to account for backslash.
+                out.extend_from_slice(&interior_text.as_bytes()[..(offset - 1)]);
                 out.push(b'\n');
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'\\') => {
+            (UnquoteState::HasEscapeEscape { mut out }, b'n') => {
+                out.push(b'\n');
+                UnquoteState::HasEscape { out }
+            }
+            (UnquoteState::Escape, b'\\') => {
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                // Subtract 1 from offset to account for backslash.
+                out.extend_from_slice(&interior_text.as_bytes()[..(offset - 1)]);
                 out.push(b'\\');
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'"') => {
+            (UnquoteState::HasEscapeEscape { mut out }, b'\\') => {
+                out.push(b'\\');
+                UnquoteState::HasEscape { out }
+            }
+            (UnquoteState::Escape, b'"') => {
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                // Subtract 1 from offset to account for backslash.
+                out.extend_from_slice(&interior_text.as_bytes()[..(offset - 1)]);
                 out.push(b'"');
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'0'..=b'7') => {
+            (UnquoteState::HasEscapeEscape { mut out }, b'"') => {
+                out.push(b'"');
+                UnquoteState::HasEscape { out }
+            }
+            (UnquoteState::Escape, b'0'..=b'7') => {
                 let mut octal = Vec::with_capacity(MAX_OCTAL_LENGTH);
                 octal.push(current_char);
-                ParseState::Octal(octal)
+                // Substract 1 from offset to account for backslash
+                UnquoteState::Octal {
+                    octal_begin_offset: offset - 1,
+                    octal,
                 }
-            (ParseState::Octal(mut octal), b'0'..=b'7') => {
+            }
+            (UnquoteState::HasEscapeEscape { out }, b'0'..=b'7') => {
+                let mut octal = Vec::with_capacity(MAX_OCTAL_LENGTH);
                 octal.push(current_char);
-                ParseState::Octal(octal)
+                // Substract 1 from offset to account for backslash
+                UnquoteState::HasEscapeOctal { out, octal }
             }
-            _ => panic!("Invalid state unquoting string."),
+            (
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    mut octal,
+                },
+                b'0'..=b'7',
+            ) => {
+                octal.push(current_char);
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    octal,
+                }
+            }
+            (UnquoteState::HasEscapeOctal { out, mut octal }, b'0'..=b'7') => {
+                octal.push(current_char);
+                UnquoteState::HasEscapeOctal { out, octal }
+            }
+            (state, _) => panic!(
+                "Invalid state unquoting string: {:?} | {} | {:?}",
+                state, offset, interior_text
+            ),
         };
     }
 
-    Ok(String::from_utf8(out)?)
+    match state {
+        UnquoteState::Normal | UnquoteState::Escape | UnquoteState::Octal { .. } => {
+            Ok(Cow::Borrowed(interior_text))
+        }
+        UnquoteState::HasEscape { out } => Ok(Cow::Owned(String::from_utf8(out)?)),
+        UnquoteState::HasEscapeEscape { mut out } => {
+            out.push(b'\\');
+            Ok(Cow::Owned(String::from_utf8(out)?))
+        }
+        UnquoteState::HasEscapeOctal { mut out, octal } => {
+            out.push(b'\\');
+            out.extend(octal);
+            Ok(Cow::Owned(String::from_utf8(out)?))
+        }
+    }
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/compare/util.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::str::FromStr;
 
 use super::compare_field::compare_property_list_of_quoted_string;
@@ -206,10 +207,10 @@ pub(crate) fn get_property_unquoted_atom<'s>(
 /// Get a named property containing an quoted string from the emacs token.
 ///
 /// Returns None if key is not found.
-pub(crate) fn get_property_quoted_string(
+pub(crate) fn get_property_quoted_string<'s>(
-    emacs: &Token<'_>,
+    emacs: &Token<'s>,
     key: &str,
-) -> Result<Option<String>, Box<dyn std::error::Error>> {
+) -> Result<Option<Cow<'s, str>>, Box<dyn std::error::Error>> {
     get_property(emacs, key)?
         .map(Token::as_atom)
         .map_or(Ok(None), |r| r.map(Some))?

src/context/constants.rs

@@ -1,15 +1,27 @@
 use super::global_settings::EntityDefinition;
 
-pub(crate) const DEFAULT_ORG_ELEMENT_PARSED_KEYWORDS: [&str; 1] = ["CAPTION"];
+/// Keywords that contain the standard set of objects (excluding footnote references).
+///
+/// Corresponds to org-element-parsed-keywords elisp variable.
+pub(crate) const ORG_ELEMENT_PARSED_KEYWORDS: [&str; 1] = ["CAPTION"];
 
-pub(crate) const DEFAULT_ORG_ELEMENT_DUAL_KEYWORDS: [&str; 2] = ["CAPTION", "RESULTS"];
+/// Keywords that can have a secondary value in square brackets.
+///
+/// Corresponds to org-element-dual-keywords elisp variable.
+pub(crate) const ORG_ELEMENT_DUAL_KEYWORDS: [&str; 2] = ["CAPTION", "RESULTS"];
 
-pub(crate) const DEFAULT_ORG_ELEMENT_AFFILIATED_KEYWORDS: [&str; 13] = [
+/// Keywords that can be affiliated with an element.
+///
+/// Corresponds to org-element-affiliated-keywords elisp variable.
+pub(crate) const ORG_ELEMENT_AFFILIATED_KEYWORDS: [&str; 13] = [
     "CAPTION", "DATA", "HEADER", "HEADERS", "LABEL", "NAME", "PLOT", "RESNAME", "RESULT",
     "RESULTS", "SOURCE", "SRCNAME", "TBLNAME",
 ];
 
-pub(crate) const DEFAULT_ORG_ELEMENT_KEYWORD_TRANSLATION_ALIST: [(&str, &str); 8] = [
+/// Mapping of keyword names.
+///
+/// Corresponds to org-element-keyword-translation-alist elisp variable.
+pub(crate) const ORG_ELEMENT_KEYWORD_TRANSLATION_ALIST: [(&str, &str); 8] = [
     ("DATA", "NAME"),
     ("LABEL", "NAME"),
     ("RESNAME", "NAME"),

src/context/context.rs

@@ -9,11 +9,9 @@ use super::list::List;
 use super::DynContextMatcher;
 use super::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::OrgSource;
 
-#[derive(Debug)]
 pub(crate) enum ContextElement<'r, 's> {
     /// Stores a parser that indicates that children should exit upon matching an exit matcher.
     ExitMatcherNode(ExitMatcherNode<'r>),
@@ -35,15 +33,6 @@ pub(crate) struct ExitMatcherNode<'r> {
     pub(crate) class: ExitClass,
 }
 
-impl<'r> std::fmt::Debug for ExitMatcherNode<'r> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut formatter = f.debug_struct("ExitMatcherNode");
-        formatter.field("class", &self.class.to_string());
-        formatter.finish()
-    }
-}
-
-#[derive(Debug)]
 pub(crate) struct Context<'g, 'r, 's> {
     global_settings: &'g GlobalSettings<'g, 's>,
     tree: List<'r, &'r ContextElement<'r, 's>>,
@@ -108,7 +97,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
     pub(crate) fn check_exit_matcher(
         &'r self,
         i: OrgSource<'s>,
-    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError<OrgSource<'s>>> {
+    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError> {
         let mut current_class_filter = ExitClass::Gamma;
         for current_node in self.iter_context() {
             let context_element = current_node.get_data();
@@ -123,7 +112,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
             }
         }
         // TODO: Make this a specific error instead of just a generic MyError
-        return Err(nom::Err::Error(CustomError::MyError(MyError("NoExit"))));
+        return Err(nom::Err::Error(CustomError::Static("NoExit")));
     }
 
     /// Indicates if elements should consume the whitespace after them.

src/context/exiting.rs

@@ -1,13 +1,7 @@
-#[derive(Debug, Copy, Clone)]
+#[derive(Copy, Clone)]
 pub(crate) enum ExitClass {
     Document = 1,
     Alpha = 2,
     Beta = 3,
     Gamma = 4,
 }
-
-impl std::fmt::Display for ExitClass {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}

src/context/file_access_interface.rs

@@ -1,17 +1,16 @@
-use std::fmt::Debug;
 use std::path::PathBuf;
 
 #[cfg(any(feature = "compare", feature = "foreign_document_test"))]
-pub trait FileAccessInterface: Sync + Debug {
+pub trait FileAccessInterface: Sync {
     fn read_file(&self, path: &str) -> Result<String, std::io::Error>;
 }
 
 #[cfg(not(any(feature = "compare", feature = "foreign_document_test")))]
-pub trait FileAccessInterface: Debug {
+pub trait FileAccessInterface {
     fn read_file(&self, path: &str) -> Result<String, std::io::Error>;
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct LocalFileAccessInterface {
     pub working_directory: Option<PathBuf>,
 }

src/context/global_settings.rs

@@ -5,16 +5,12 @@ use super::constants::DEFAULT_ORG_ENTITIES;
 use super::constants::DEFAULT_ORG_LINK_PARAMETERS;
 use super::FileAccessInterface;
 use super::LocalFileAccessInterface;
-use crate::context::constants::DEFAULT_ORG_ELEMENT_AFFILIATED_KEYWORDS;
-use crate::context::constants::DEFAULT_ORG_ELEMENT_DUAL_KEYWORDS;
-use crate::context::constants::DEFAULT_ORG_ELEMENT_KEYWORD_TRANSLATION_ALIST;
-use crate::context::constants::DEFAULT_ORG_ELEMENT_PARSED_KEYWORDS;
 use crate::types::IndentationLevel;
 use crate::types::Object;
 
 // TODO: Ultimately, I think we'll need most of this: https://orgmode.org/manual/In_002dbuffer-Settings.html
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct GlobalSettings<'g, 's> {
     pub radio_targets: Vec<&'g Vec<Object<'s>>>,
     pub file_access: &'g dyn FileAccessInterface,
@@ -58,26 +54,6 @@ pub struct GlobalSettings<'g, 's> {
     ///
     /// Corresponds to org-entities elisp variable.
     pub entities: &'g [EntityDefinition<'s>],
-
-    /// Keywords that contain the standard set of objects (excluding footnote references).
-    ///
-    /// Corresponds to org-element-parsed-keywords elisp variable.
-    pub element_parsed_keywords: &'g [&'s str],
-
-    /// Keywords that can have a secondary value in square brackets.
-    ///
-    /// Corresponds to org-element-dual-keywords elisp variable.
-    pub element_dual_keywords: &'g [&'s str],
-
-    /// Keywords that can be affiliated with an element.
-    ///
-    /// Corresponds to org-element-affiliated-keywords elisp variable.
-    pub element_affiliated_keywords: &'g [&'s str],
-
-    /// Mapping of keyword names.
-    ///
-    /// Corresponds to org-element-keyword-translation-alist elisp variable.
-    pub element_keyword_translation_alist: &'g [(&'s str, &'s str)],
 }
 
 pub const DEFAULT_TAB_WIDTH: IndentationLevel = 8;
@@ -112,10 +88,6 @@ impl<'g, 's> GlobalSettings<'g, 's> {
             link_parameters: &DEFAULT_ORG_LINK_PARAMETERS,
             link_templates: BTreeMap::new(),
             entities: &DEFAULT_ORG_ENTITIES,
-            element_parsed_keywords: &DEFAULT_ORG_ELEMENT_PARSED_KEYWORDS,
-            element_dual_keywords: &DEFAULT_ORG_ELEMENT_DUAL_KEYWORDS,
-            element_affiliated_keywords: &DEFAULT_ORG_ELEMENT_AFFILIATED_KEYWORDS,
-            element_keyword_translation_alist: &DEFAULT_ORG_ELEMENT_KEYWORD_TRANSLATION_ALIST,
         }
     }
 }
@@ -126,7 +98,7 @@ impl<'g, 's> Default for GlobalSettings<'g, 's> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Clone, PartialEq, Default)]
 pub enum HeadlineLevelFilter {
     Odd,
 

src/context/mod.rs

@@ -1,7 +1,7 @@
 use crate::error::Res;
 use crate::parser::OrgSource;
 
-mod constants;
+pub(crate) mod constants;
 #[allow(clippy::module_inception)]
 mod context;
 mod exiting;

src/error/error.rs

@@ -2,22 +2,18 @@ use nom::error::ErrorKind;
 use nom::error::ParseError;
 use nom::IResult;
 
-pub(crate) type Res<T, U> = IResult<T, U, CustomError<T>>;
+pub(crate) type Res<T, U> = IResult<T, U, CustomError>;
 
 #[derive(Debug)]
-pub enum CustomError<I> {
+pub enum CustomError {
-    MyError(MyError<&'static str>),
+    Static(&'static str),
-    Nom(I, ErrorKind),
     IO(std::io::Error),
-    BoxedError(Box<dyn std::error::Error>),
+    Parser(ErrorKind),
 }
 
-#[derive(Debug)]
+impl<I: std::fmt::Debug> ParseError<I> for CustomError {
-pub struct MyError<I>(pub(crate) I);
+    fn from_error_kind(_input: I, kind: ErrorKind) -> Self {
-
+        CustomError::Parser(kind)
-impl<I> ParseError<I> for CustomError<I> {
-    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
-        CustomError::Nom(input, kind)
     }
 
     fn append(_input: I, _kind: ErrorKind, /*mut*/ other: Self) -> Self {
@@ -26,20 +22,14 @@ impl<I> ParseError<I> for CustomError<I> {
     }
 }
 
-impl<I> From<std::io::Error> for CustomError<I> {
+impl From<std::io::Error> for CustomError {
     fn from(value: std::io::Error) -> Self {
         CustomError::IO(value)
     }
 }
 
-impl<I> From<&'static str> for CustomError<I> {
+impl From<&'static str> for CustomError {
     fn from(value: &'static str) -> Self {
-        CustomError::MyError(MyError(value))
+        CustomError::Static(value)
-    }
-}
-
-impl<I> From<Box<dyn std::error::Error>> for CustomError<I> {
-    fn from(value: Box<dyn std::error::Error>) -> Self {
-        CustomError::BoxedError(value)
     }
 }

src/error/mod.rs

@@ -1,5 +1,4 @@
 #[allow(clippy::module_inception)]
 mod error;
 pub(crate) use error::CustomError;
-pub(crate) use error::MyError;
 pub(crate) use error::Res;

src/event_count/database.rs

@@ -0,0 +1,43 @@
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+use super::EventType;
+use crate::parser::OrgSource;
+
+#[derive(Debug, Eq, Hash, PartialEq)]
+struct EventKey {
+    event_type: EventType,
+    byte_offset: usize,
+}
+
+pub(crate) type EventCount = usize;
+
+static GLOBAL_DATA: Mutex<Option<HashMap<EventKey, EventCount>>> = Mutex::new(None);
+
+pub(crate) fn record_event(event_type: EventType, input: OrgSource<'_>) {
+    let mut db = GLOBAL_DATA.lock().unwrap();
+    let db = db.get_or_insert_with(HashMap::new);
+    let key = EventKey {
+        event_type,
+        byte_offset: input.get_byte_offset(),
+    };
+    *db.entry(key).or_insert(0) += 1;
+}
+
+pub fn report(original_document: &str) {
+    let mut db = GLOBAL_DATA.lock().unwrap();
+    let db = db.get_or_insert_with(HashMap::new);
+    let mut results: Vec<_> = db.iter().map(|(k, v)| (k, v)).collect();
+    results.sort_by_key(|(_k, v)| *v);
+    // This would put the most common at the top, but that is a pain when there is already a lot of output from the parser.
+    // results.sort_by(|(_ak, av), (_bk, bv)| bv.cmp(av));
+    for (key, count) in results {
+        println!(
+            "{:?} {} character offset: {}    byte offset: {}",
+            key.event_type,
+            count,
+            original_document[..key.byte_offset].chars().count() + 1,
+            key.byte_offset
+        )
+    }
+}

src/event_count/event_type.rs

@@ -0,0 +1,4 @@
+#[derive(Debug, Eq, Hash, PartialEq)]
+pub(crate) enum EventType {
+    ElementStart,
+}

src/event_count/mod.rs

@@ -0,0 +1,6 @@
+mod database;
+mod event_type;
+
+pub(crate) use database::record_event;
+pub use database::report;
+pub(crate) use event_type::EventType;

src/iter/all_ast_node_iter.rs

@@ -90,12 +90,11 @@ impl<'r, 's> Iterator for AllAstNodeIter<'r, 's> {
     }
 }
 
-impl<'r, 's> IntoIterator for AstNode<'r, 's> {
+impl<'r, 's> AstNode<'r, 's> {
-    type Item = AstNode<'r, 's>;
+    /// Iterate all AST nodes.
-
+    ///
-    type IntoIter = AllAstNodeIter<'r, 's>;
+    /// This is different from the iter/into_iter functions which iterate a single level of the children. This iterates the entire tree including returning the root node itself.
-
+    pub fn iter_all_ast_nodes(self) -> AllAstNodeIter<'r, 's> {
-    fn into_iter(self) -> Self::IntoIter {
         AllAstNodeIter {
             root: Some(self),
             queue: VecDeque::new(),

src/lib.rs

@@ -13,6 +13,8 @@ pub mod compare;
 
 mod context;
 mod error;
+#[cfg(feature = "event_count")]
+pub mod event_count;
 mod iter;
 pub mod parser;
 pub mod types;

src/main.rs

@@ -54,8 +54,11 @@ fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
 }
 
 fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
-    let rust_parsed = parse(org_contents.as_ref())?;
+    let org_contents = org_contents.as_ref();
+    let rust_parsed = parse(org_contents)?;
     println!("{:#?}", rust_parsed);
+    #[cfg(feature = "event_count")]
+    organic::event_count::report(org_contents);
     Ok(())
 }
 
@@ -75,5 +78,7 @@ fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::err
     };
     let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
     println!("{:#?}", rust_parsed);
+    #[cfg(feature = "event_count")]
+    organic::event_count::report(org_contents);
     Ok(())
 }

src/parser/affiliated_keyword.rs

@@ -14,17 +14,46 @@ use nom::multi::many0;
 use nom::multi::many_till;
 use nom::sequence::tuple;
 
+use super::keyword::affiliated_keyword;
 use super::object_parser::standard_set_object;
 use super::util::confine_context;
+use super::OrgSource;
 use crate::context::bind_context;
+use crate::context::constants::ORG_ELEMENT_DUAL_KEYWORDS;
+use crate::context::constants::ORG_ELEMENT_KEYWORD_TRANSLATION_ALIST;
+use crate::context::constants::ORG_ELEMENT_PARSED_KEYWORDS;
 use crate::context::Context;
 use crate::context::ContextElement;
 use crate::context::GlobalSettings;
 use crate::context::List;
+use crate::error::Res;
 use crate::types::AffiliatedKeywordValue;
 use crate::types::AffiliatedKeywords;
 use crate::types::Keyword;
 
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+pub(crate) fn affiliated_keywords<'s>(
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Vec<Keyword<'s>>> {
+    let mut ret = Vec::new();
+    let mut remaining = input;
+
+    loop {
+        let result = affiliated_keyword(remaining);
+        match result {
+            Ok((remain, kw)) => {
+                remaining = remain;
+                ret.push(kw);
+            }
+            Err(_) => {
+                break;
+            }
+        }
+    }
+
+    Ok((remaining, ret))
+}
+
 pub(crate) fn parse_affiliated_keywords<'g, 's, AK>(
     global_settings: &'g GlobalSettings<'g, 's>,
     input: AK,
@@ -34,8 +63,8 @@ where
 {
     let mut ret = BTreeMap::new();
     for kw in input {
-        let translated_name = translate_name(global_settings, kw.key);
+        let translated_name = translate_name(kw.key);
-        let keyword_type = identify_keyword_type(global_settings, translated_name.as_str());
+        let keyword_type = identify_keyword_type(translated_name.as_str());
         match keyword_type {
             AffiliatedKeywordType::SingleString => {
                 ret.insert(
@@ -120,12 +149,12 @@ where
     AffiliatedKeywords { keywords: ret }
 }
 
-fn translate_name<'g, 's>(global_settings: &'g GlobalSettings<'g, 's>, name: &'s str) -> String {
+fn translate_name(name: &str) -> String {
     let name_until_optval = name
         .split_once('[')
         .map(|(before, _after)| before)
         .unwrap_or(name);
-    for (src, dst) in global_settings.element_keyword_translation_alist {
+    for (src, dst) in ORG_ELEMENT_KEYWORD_TRANSLATION_ALIST {
         if name_until_optval.eq_ignore_ascii_case(src) {
             return dst.to_lowercase();
         }
@@ -140,20 +169,15 @@ enum AffiliatedKeywordType {
     ObjectTree,
 }
 
-fn identify_keyword_type<'g, 's>(
+fn identify_keyword_type(name: &str) -> AffiliatedKeywordType {
-    global_settings: &'g GlobalSettings<'g, 's>,
-    name: &'s str,
-) -> AffiliatedKeywordType {
     let is_multiple = ["CAPTION", "HEADER"]
         .into_iter()
         .any(|candidate| name.eq_ignore_ascii_case(candidate))
         || name.to_lowercase().starts_with("attr_");
-    let is_parsed = global_settings
+    let is_parsed = ORG_ELEMENT_PARSED_KEYWORDS
-        .element_parsed_keywords
         .iter()
         .any(|candidate| name.eq_ignore_ascii_case(candidate));
-    let can_have_optval = global_settings
+    let can_have_optval = ORG_ELEMENT_DUAL_KEYWORDS
-        .element_dual_keywords
         .iter()
         .any(|candidate| name.eq_ignore_ascii_case(candidate));
     match (is_multiple, is_parsed, can_have_optval) {

src/parser/babel_call.rs

@@ -21,7 +21,6 @@ use super::OrgSource;
 use crate::context::Matcher;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::parser::util::org_line_ending;
@@ -217,9 +216,7 @@ fn impl_balanced_bracket<
         }
 
         if fail_parser(remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static("Fail parser matched.")));
-                "Fail parser matched.",
-            ))));
         }
 
         let (remain, _) = anychar(remaining)?;
@@ -228,7 +225,7 @@ fn impl_balanced_bracket<
     let contents_end = remaining;
 
     let (remaining, _) = end_parser(remaining)?;
-    let contents = if contents_start != contents_end {
+    let contents = if Into::<&str>::into(contents_start) != Into::<&str>::into(contents_end) {
         Some(contents_start.get_until(contents_end))
     } else {
         None
@@ -247,7 +244,7 @@ mod tests {
         let input = OrgSource::new("()");
         let (remaining, call) = opt(babel_call_call)(input)?;
         assert_eq!(Into::<&str>::into(remaining), "()");
-        assert_eq!(call, None);
+        assert!(call.is_none());
         Ok(())
     }
 }

src/parser/bullshitium.rs

@@ -0,0 +1,157 @@
+use nom::branch::alt;
+use nom::bytes::complete::tag_no_case;
+use nom::character::complete::anychar;
+use nom::character::complete::space0;
+use nom::multi::many_till;
+use nom::sequence::tuple;
+
+use super::paragraph::paragraph;
+use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
+use super::util::org_line_ending;
+use super::util::start_of_line;
+use super::OrgSource;
+use crate::context::bind_context;
+use crate::context::RefContext;
+use crate::error::CustomError;
+use crate::error::Res;
+use crate::parser::macros::element;
+use crate::types::Object;
+use crate::types::Paragraph;
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+pub(crate) fn bullshitium<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Paragraph<'s>> {
+    alt((
+        bind_context!(broken_end, context),
+        bind_context!(broken_dynamic_block, context),
+    ))(input)
+}
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+pub(crate) fn detect_bullshitium<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, ()> {
+    element!(detect_broken_end, context, input);
+    element!(detect_broken_dynamic_block, context, input);
+    Err(nom::Err::Error(CustomError::Static("No bullshitium.")))
+}
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+pub(crate) fn broken_end<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Paragraph<'s>> {
+    start_of_line(input)?;
+    let (remaining, _) = space0(input)?;
+    let (remaining, _) = tag_no_case(":end:")(remaining)?;
+    let (lead_in_remaining, _) = tuple((space0, org_line_ending))(remaining)?;
+    if let Ok((remaining, mut paragraph)) =
+        paragraph(std::iter::empty(), lead_in_remaining, context, input)
+    {
+        match paragraph.children.first_mut() {
+            Some(Object::PlainText(plain_text)) => {
+                plain_text.source = input.get_until_end_of_str(plain_text.source).into();
+            }
+            Some(obj) => {
+                panic!("Unhandled first object type inside bullshitium {:?}", obj);
+            }
+            None => {
+                unreachable!("Paragraph must have children.");
+            }
+        };
+        Ok((remaining, paragraph))
+    } else {
+        let (remaining, _trailing_ws) =
+            maybe_consume_trailing_whitespace_if_not_exiting(context, lead_in_remaining)?;
+
+        Ok((
+            remaining,
+            Paragraph::of_text(
+                input.get_until(remaining).into(),
+                input.get_until(lead_in_remaining).into(),
+            ),
+        ))
+    }
+}
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(_context))
+)]
+pub(crate) fn detect_broken_end<'b, 'g, 'r, 's>(
+    _context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, ()> {
+    start_of_line(input)?;
+    let (remaining, _) = space0(input)?;
+    let (remaining, _) = tag_no_case(":end:")(remaining)?;
+    let (_remaining, _) = tuple((space0, org_line_ending))(remaining)?;
+    Ok((input, ()))
+}
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+pub(crate) fn broken_dynamic_block<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Paragraph<'s>> {
+    start_of_line(input)?;
+    let (remaining, _) = space0(input)?;
+    let (remaining, _) = tag_no_case("#+BEGIN:")(remaining)?;
+    let (lead_in_remaining, _) = many_till(anychar, org_line_ending)(remaining)?;
+    if let Ok((remaining, mut paragraph)) =
+        paragraph(std::iter::empty(), lead_in_remaining, context, input)
+    {
+        match paragraph.children.first_mut() {
+            Some(Object::PlainText(plain_text)) => {
+                plain_text.source = input.get_until_end_of_str(plain_text.source).into();
+            }
+            Some(obj) => {
+                panic!("Unhandled first object type inside bullshitium {:?}", obj);
+            }
+            None => {
+                unreachable!("Paragraph must have children.");
+            }
+        };
+        Ok((remaining, paragraph))
+    } else {
+        let (remaining, _trailing_ws) =
+            maybe_consume_trailing_whitespace_if_not_exiting(context, lead_in_remaining)?;
+
+        Ok((
+            remaining,
+            Paragraph::of_text(
+                input.get_until(remaining).into(),
+                input.get_until(lead_in_remaining).into(),
+            ),
+        ))
+    }
+}
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(_context))
+)]
+pub(crate) fn detect_broken_dynamic_block<'b, 'g, 'r, 's>(
+    _context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, ()> {
+    start_of_line(input)?;
+    let (remaining, _) = space0(input)?;
+    let (_remaining, _) = tag_no_case("#+BEGIN:")(remaining)?;
+    Ok((input, ()))
+}

src/parser/citation.rs

@@ -137,7 +137,7 @@ fn _global_prefix_end<'b, 'g, 'r, 's>(
         unreachable!("Exceeded citation global prefix bracket depth.")
     }
     if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }
@@ -191,7 +191,7 @@ fn _global_suffix_end<'b, 'g, 'r, 's>(
         unreachable!("Exceeded citation global suffix bracket depth.")
     }
     if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }
@@ -210,12 +210,12 @@ 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;
+    use crate::types::StandardProperties;
 
     #[test]
-    fn citation_simple() {
+    fn citation_simple() -> Result<(), Box<dyn std::error::Error>> {
         let input = OrgSource::new("[cite:@foo]");
         let global_settings = GlobalSettings::default();
         let initial_context = ContextElement::document_context();
@@ -232,23 +232,31 @@ mod tests {
             "[cite:@foo]"
         );
         assert_eq!(first_paragraph.children.len(), 1);
-        assert_eq!(
+
-            first_paragraph
+        match first_paragraph
             .children
-                .get(0)
+            .first()
-                .expect("Len already asserted to be 1"),
+            .expect("Len already asserted to be 1.")
-            &Object::Citation(Citation {
+        {
-                source: "[cite:@foo]",
+            Object::Citation(inner) => {
-                style: None,
+                assert_eq!(inner.get_source(), "[cite:@foo]");
-                prefix: vec![],
+                assert_eq!(inner.children.len(), 1);
-                suffix: vec![],
+                assert!(inner.prefix.is_empty());
-                children: vec![CitationReference {
+                assert!(inner.suffix.is_empty());
-                    source: "@foo",
+                assert!(inner.style.is_none());
-                    key: "foo",
+                let citation_reference = inner
-                    prefix: vec![],
+                    .children
-                    suffix: vec![]
+                    .first()
-                }]
+                    .expect("Len already asserted to be 1.");
-            })
+                assert_eq!(citation_reference.get_source(), "@foo");
-        );
+                assert_eq!(citation_reference.key, "foo");
+                assert!(citation_reference.prefix.is_empty());
+                assert!(citation_reference.suffix.is_empty());
+            }
+            _ => {
+                return Err("Child should be a citation.".into());
+            }
+        };
+        Ok(())
     }
 }

src/parser/citation_reference.rs

@@ -20,7 +20,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::minimal_set_object;
 use crate::parser::util::exit_matcher_parser;
@@ -151,7 +150,7 @@ fn _key_prefix_end<'b, 'g, 'r, 's>(
         unreachable!("Exceeded citation key prefix bracket depth.")
     }
     if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }
@@ -181,7 +180,7 @@ fn _key_suffix_end<'b, 'g, 'r, 's>(
         unreachable!("Exceeded citation key suffix bracket depth.")
     }
     if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }
@@ -199,9 +198,7 @@ where
         let pre_bracket_depth = input.get_bracket_depth();
         let (remaining, output) = inner(input)?;
         if remaining.get_bracket_depth() - pre_bracket_depth != 0 {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static("UnbalancedBrackets")));
-                "UnbalancedBrackets",
-            ))));
         }
         Ok((remaining, output))
     }

src/parser/comment.rs

@@ -19,7 +19,6 @@ use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::immediate_in_section;
@@ -35,9 +34,9 @@ pub(crate) fn comment<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Comment<'s>> {
     if immediate_in_section(context, "comment") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
-        ))));
+        )));
     }
     let parser_context = ContextElement::Context("comment");
     let parser_context = context.with_additional_node(&parser_context);

src/parser/document.rs

@@ -19,9 +19,7 @@ use crate::context::GlobalSettings;
 use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
-use crate::parser::org_source::convert_error;
 use crate::parser::util::blank_line;
 use crate::types::AstNode;
 use crate::types::Document;
@@ -103,7 +101,7 @@ pub fn parse_file_with_settings<'g, 's, P: AsRef<Path>>(
 /// This will not prevent additional settings from being learned during parsing, for example when encountering a "#+TODO".
 #[allow(dead_code)]
 fn document<'s>(context: RefContext<'_, '_, '_, 's>, input: &'s str) -> Res<&'s str, Document<'s>> {
-    let (remaining, doc) = document_org_source(context, input.into()).map_err(convert_error)?;
+    let (remaining, doc) = document_org_source(context, input.into())?;
     Ok((Into::<&str>::into(remaining), doc))
 }
 
@@ -127,27 +125,16 @@ fn document_org_source<'b, 'g, 'r, 's>(
                 .get_global_settings()
                 .file_access
                 .read_file(setup_file)
-                .map_err(|err| nom::Err::<CustomError<OrgSource<'_>>>::Failure(err.into()))
+                .map_err(|err| nom::Err::<CustomError>::Failure(err.into()))
         })
         .collect::<Result<Vec<_>, _>>()?;
     for setup_file in setup_files.iter().map(String::as_str) {
-        let (_, setup_file_settings) =
+        let (_, setup_file_settings) = scan_for_in_buffer_settings(setup_file.into())?;
-            scan_for_in_buffer_settings(setup_file.into()).map_err(|err| {
-                eprintln!("{}", err);
-                nom::Err::Error(CustomError::MyError(MyError(
-                    "TODO: make this take an owned string so I can dump err.to_string() into it.",
-                )))
-            })?;
         final_settings.extend(setup_file_settings);
     }
     final_settings.extend(document_settings);
     let new_settings = apply_in_buffer_settings(final_settings, context.get_global_settings())
-        .map_err(|err| {
+        .map_err(nom::Err::Error)?;
-            eprintln!("{}", err);
-            nom::Err::Error(CustomError::MyError(MyError(
-                "TODO: make this take an owned string so I can dump err.to_string() into it.",
-            )))
-        })?;
     let new_context = context.with_global_settings(&new_settings);
     let context = &new_context;
 
@@ -156,7 +143,7 @@ fn document_org_source<'b, 'g, 'r, 's>(
     {
         // If there are radio targets in this document then we need to parse the entire document again with the knowledge of the radio targets.
         let all_radio_targets: Vec<&Vec<Object<'_>>> = Into::<AstNode>::into(&document)
-            .into_iter()
+            .iter_all_ast_nodes()
             .filter_map(|ast_node| {
                 if let AstNode::RadioTarget(ast_node) = ast_node {
                     Some(ast_node)
@@ -172,15 +159,13 @@ fn document_org_source<'b, 'g, 'r, 's>(
             let parser_context = context.with_global_settings(&new_global_settings);
             let (remaining, mut document) = _document(&parser_context, input)
                 .map(|(rem, out)| (Into::<&str>::into(rem), out))?;
-            apply_post_parse_in_buffer_settings(&mut document)
+            apply_post_parse_in_buffer_settings(&mut document);
-                .map_err(|err| nom::Err::<CustomError<OrgSource<'_>>>::Failure(err.into()))?;
             return Ok((remaining.into(), document));
         }
     }
 
     // Find final in-buffer settings that do not impact parsing
-    apply_post_parse_in_buffer_settings(&mut document)
+    apply_post_parse_in_buffer_settings(&mut document);
-        .map_err(|err| nom::Err::<CustomError<OrgSource<'_>>>::Failure(err.into()))?;
 
     Ok((remaining.into(), document))
 }
@@ -210,3 +195,17 @@ fn _document<'b, 'g, 'r, 's>(
         },
     ))
 }
+
+#[cfg(test)]
+mod tests {
+    use test::Bencher;
+
+    use super::*;
+
+    #[bench]
+    fn bench_full_document(b: &mut Bencher) {
+        let input = include_str!("../../org_mode_samples/element_container_priority/README.org");
+
+        b.iter(|| assert!(parse(input).is_ok()));
+    }
+}

src/parser/drawer.rs

@@ -19,7 +19,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@@ -32,7 +31,6 @@ use crate::types::Drawer;
 use crate::types::Element;
 use crate::types::Keyword;
 use crate::types::Paragraph;
-use crate::types::SetSource;
 
 #[cfg_attr(
     feature = "tracing",
@@ -48,9 +46,9 @@ where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
     if immediate_in_section(context, "drawer") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
-        ))));
+        )));
     }
     start_of_line(remaining)?;
     let (remaining, _leading_whitespace) = space0(remaining)?;
@@ -82,9 +80,8 @@ where
     ))(remaining)
     {
         Ok((remain, (_not_immediate_exit, first_line, (_trailing_whitespace, _exit_contents)))) => {
-            let mut element = Element::Paragraph(Paragraph::of_text(first_line.into()));
             let source = get_consumed(remaining, remain);
-            element.set_source(source.into());
+            let element = Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()));
             (remain, vec![element])
         }
         Err(_) => {

src/parser/dynamic_block.rs

@@ -26,7 +26,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@@ -38,7 +37,6 @@ use crate::types::DynamicBlock;
 use crate::types::Element;
 use crate::types::Keyword;
 use crate::types::Paragraph;
-use crate::types::SetSource;
 
 #[cfg_attr(
     feature = "tracing",
@@ -54,9 +52,9 @@ where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
     if immediate_in_section(context, "dynamic block") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
-        ))));
+        )));
     }
 
     start_of_line(remaining)?;
@@ -89,9 +87,7 @@ where
     ))))(remaining)?;
     let leading_blank_lines =
         leading_blank_lines.map(|(source, (first_line, _remaining_lines))| {
-            let mut element = Element::Paragraph(Paragraph::of_text(first_line.into()));
+            Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()))
-            element.set_source(source.into());
-            element
         });
     let (remaining, (mut children, _exit_contents)) =
         many_till(element_matcher, exit_matcher)(remaining)?;

src/parser/element_parser.rs

@@ -1,5 +1,3 @@
-use nom::multi::many0;
-
 use super::babel_call::babel_call;
 use super::clock::clock;
 use super::comment::comment;
@@ -14,7 +12,6 @@ use super::footnote_definition::detect_footnote_definition;
 use super::footnote_definition::footnote_definition;
 use super::greater_block::greater_block;
 use super::horizontal_rule::horizontal_rule;
-use super::keyword::affiliated_keyword;
 use super::keyword::keyword;
 use super::latex_environment::latex_environment;
 use super::lesser_block::comment_block;
@@ -27,11 +24,16 @@ use super::paragraph::paragraph;
 use super::plain_list::detect_plain_list;
 use super::plain_list::plain_list;
 use super::table::detect_table;
-use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
+#[cfg(feature = "event_count")]
+use crate::event_count::record_event;
+#[cfg(feature = "event_count")]
+use crate::event_count::EventType;
+use crate::parser::affiliated_keyword::affiliated_keywords;
+use crate::parser::bullshitium::bullshitium;
+use crate::parser::bullshitium::detect_bullshitium;
 use crate::parser::macros::ak_element;
 use crate::parser::macros::element;
 use crate::parser::table::org_mode_table;
@@ -55,8 +57,9 @@ fn _element<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
     can_be_paragraph: bool,
 ) -> Res<OrgSource<'s>, Element<'s>> {
-    let (post_affiliated_keywords_input, affiliated_keywords) =
+    #[cfg(feature = "event_count")]
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    record_event(EventType::ElementStart, input);
+    let (post_affiliated_keywords_input, affiliated_keywords) = affiliated_keywords(input)?;
 
     let mut affiliated_keywords = affiliated_keywords.into_iter();
 
@@ -240,6 +243,9 @@ fn _element<'b, 'g, 'r, 's>(
     );
 
     if can_be_paragraph {
+        // Fake paragraphs
+        element!(bullshitium, context, input, Element::Paragraph);
+
         // Paragraph without affiliated keyword
         ak_element!(
             paragraph,
@@ -251,9 +257,7 @@ fn _element<'b, 'g, 'r, 's>(
         );
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("No element.")))
-        "No element.",
-    ))))
 }
 
 pub(crate) const fn detect_element(
@@ -272,8 +276,7 @@ fn _detect_element<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
     can_be_paragraph: bool,
 ) -> Res<OrgSource<'s>, ()> {
-    let (post_affiliated_keywords_input, affiliated_keywords) =
+    let (post_affiliated_keywords_input, affiliated_keywords) = affiliated_keywords(input)?;
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
 
     let mut affiliated_keywords = affiliated_keywords.into_iter();
 
@@ -319,11 +322,14 @@ fn _detect_element<'b, 'g, 'r, 's>(
         input
     );
 
+    // Fake paragraphs
+    if !can_be_paragraph {
+        element!(detect_bullshitium, context, input);
+    }
+
     if _element(context, input, can_be_paragraph).is_ok() {
         return Ok((input, ()));
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("No element detected.")))
-        "No element detected.",
-    ))))
 }

src/parser/entity.rs

@@ -1,11 +1,11 @@
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::satisfy;
+use nom::combinator::cond;
 use nom::combinator::eof;
 use nom::combinator::map;
 use nom::combinator::peek;
 use nom::combinator::recognize;
-use nom::combinator::verify;
 use nom::sequence::tuple;
 
 use super::org_source::OrgSource;
@@ -13,7 +13,6 @@ use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
 use crate::context::EntityDefinition;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Entity;
@@ -58,18 +57,21 @@ fn name<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, (&'g EntityDefinition<'s>, OrgSource<'s>, bool)> {
     for entity in context.get_global_settings().entities {
         let result = tuple((
-            tag::<_, _, CustomError<_>>(entity.name),
+            tag::<_, _, CustomError>(entity.name),
+            cond(
+                !entity.name.ends_with(' '),
                 alt((
-                verify(map(tag("{}"), |_| true), |_| !entity.name.ends_with(' ')),
+                    map(tag("{}"), |_| true),
                     map(peek(recognize(entity_end)), |_| false),
                 )),
+            ),
         ))(input);
         if let Ok((remaining, (ent, use_brackets))) = result {
-            return Ok((remaining, (entity, ent, use_brackets)));
+            return Ok((remaining, (entity, ent, use_brackets.unwrap_or(false))));
         }
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError("NoEntity"))))
+    Err(nom::Err::Error(CustomError::Static("NoEntity")))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/parser/footnote_definition.rs

@@ -22,7 +22,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@@ -48,9 +47,9 @@ where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
     if immediate_in_section(context, "footnote definition") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
-        ))));
+        )));
     }
     start_of_line(remaining)?;
     // Cannot be indented.

src/parser/footnote_reference.rs

@@ -20,7 +20,6 @@ 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;
@@ -176,9 +175,9 @@ fn _footnote_definition_end<'b, 'g, 'r, 's>(
     let current_depth = input.get_bracket_depth() - starting_bracket_depth;
     if current_depth > 0 {
         // Its impossible for the next character to end the footnote reference definition if we're any amount of brackets deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "NoFootnoteReferenceDefinitionEnd",
-        ))));
+        )));
     }
     if current_depth < 0 {
         // This shouldn't be possible because if depth is 0 then a closing bracket should end the footnote definition.

src/parser/greater_block.rs

@@ -28,7 +28,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@@ -40,7 +39,6 @@ use crate::types::Element;
 use crate::types::Keyword;
 use crate::types::Paragraph;
 use crate::types::QuoteBlock;
-use crate::types::SetSource;
 use crate::types::SpecialBlock;
 
 #[cfg_attr(
@@ -232,9 +230,9 @@ fn greater_block_body<'c, 'b, 'g, 'r, 's>(
     context_name: &'c str,
 ) -> Res<OrgSource<'s>, (&'s str, Vec<Element<'s>>)> {
     if in_section(context, context_name) {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
-        ))));
+        )));
     }
     let exit_with_name = greater_block_end(name);
     let (remaining, _nl) = tuple((space0, line_ending))(input)?;
@@ -258,9 +256,7 @@ fn greater_block_body<'c, 'b, 'g, 'r, 's>(
     ))))(remaining)?;
     let leading_blank_lines =
         leading_blank_lines.map(|(source, (first_line, _remaining_lines))| {
-            let mut element = Element::Paragraph(Paragraph::of_text(first_line.into()));
+            Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()))
-            element.set_source(source.into());
-            element
         });
     let (remaining, (mut children, _exit_contents)) =
         many_till(element_matcher, exit_matcher)(remaining)?;

src/parser/headline.rs

@@ -18,18 +18,18 @@ use nom::sequence::tuple;
 
 use super::org_source::OrgSource;
 use super::section::section;
+use super::util::exit_matcher_parser;
 use super::util::get_consumed;
 use super::util::org_line_ending;
 use super::util::org_space;
 use super::util::org_space_or_line_ending;
 use super::util::start_of_line;
-use crate::context::parser_with_context;
+use crate::context::bind_context;
 use crate::context::ContextElement;
 use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::standard_set_object;
 use crate::parser::util::blank_line;
@@ -62,10 +62,10 @@ fn _heading<'b, 'g, 'r, 's>(
     let mut scheduled = None;
     let mut deadline = None;
     let mut closed = None;
-    not(|i| context.check_exit_matcher(i))(input)?;
+    not(bind_context!(exit_matcher_parser, context))(input)?;
     let (remaining, pre_headline) = headline(context, input, parent_star_count)?;
-    let section_matcher = parser_with_context!(section)(context);
+    let section_matcher = bind_context!(section, context);
-    let heading_matcher = parser_with_context!(heading(pre_headline.star_count))(context);
+    let heading_matcher = bind_context!(heading(pre_headline.star_count), context);
     let (remaining, maybe_section) =
         opt(map(section_matcher, DocumentElement::Section))(remaining)?;
     let (remaining, _ws) = opt(tuple((start_of_line, many0(blank_line))))(remaining)?;
@@ -155,7 +155,7 @@ fn headline<'b, 'g, 'r, 's>(
     let (remaining, (_, (headline_level, star_count, _), _)) = tuple((
         start_of_line,
         verify(
-            parser_with_context!(headline_level)(&parser_context),
+            bind_context!(headline_level, &parser_context),
             |(_, count, _)| *count > parent_star_count,
         ),
         peek(org_space),
@@ -163,7 +163,7 @@ fn headline<'b, 'g, 'r, 's>(
 
     let (remaining, maybe_todo_keyword) = opt(tuple((
         space1,
-        parser_with_context!(heading_keyword)(&parser_context),
+        bind_context!(heading_keyword, &parser_context),
         peek(org_space_or_line_ending),
     )))(remaining)?;
 
@@ -177,9 +177,7 @@ fn headline<'b, 'g, 'r, 's>(
 
     let (remaining, maybe_title) = opt(tuple((
         space1,
-        consumed(many1(parser_with_context!(standard_set_object)(
+        consumed(many1(bind_context!(standard_set_object, &parser_context))),
-            &parser_context,
-        ))),
     )))(remaining)?;
 
     let (remaining, maybe_tags) = opt(tuple((space0, tags)))(remaining)?;
@@ -260,7 +258,7 @@ fn heading_keyword<'b, 'g, 'r, 's>(
             .iter()
             .map(String::as_str)
         {
-            let result = tag::<_, _, CustomError<_>>(todo_keyword)(input);
+            let result = tag::<_, _, CustomError>(todo_keyword)(input);
             if let Ok((remaining, ent)) = result {
                 return Ok((remaining, (TodoKeywordType::Todo, ent)));
             }
@@ -270,14 +268,12 @@ fn heading_keyword<'b, 'g, 'r, 's>(
             .iter()
             .map(String::as_str)
         {
-            let result = tag::<_, _, CustomError<_>>(todo_keyword)(input);
+            let result = tag::<_, _, CustomError>(todo_keyword)(input);
             if let Ok((remaining, ent)) = result {
                 return Ok((remaining, (TodoKeywordType::Done, ent)));
             }
         }
-        Err(nom::Err::Error(CustomError::MyError(MyError(
+        Err(nom::Err::Error(CustomError::Static("NoTodoKeyword")))
-            "NoTodoKeyword",
-        ))))
     }
 }
 
@@ -288,9 +284,9 @@ fn priority_cookie(input: OrgSource<'_>) -> Res<OrgSource<'_>, PriorityCookie> {
         tag("]"),
     ))(input)?;
     let cookie = PriorityCookie::try_from(priority_character).map_err(|_| {
-        nom::Err::Error(CustomError::MyError(MyError(
+        nom::Err::Error(CustomError::Static(
             "Failed to cast priority cookie to number.",
-        )))
+        ))
     })?;
     Ok((remaining, cookie))
 }

src/parser/in_buffer_settings.rs

@@ -35,7 +35,7 @@ pub(crate) fn scan_for_in_buffer_settings<'s>(
     let mut remaining = input;
     loop {
         // Skip text until possible in_buffer_setting
-        let start_of_pound = take_until::<_, _, CustomError<_>>("#+")(remaining);
+        let start_of_pound = take_until::<_, _, CustomError>("#+")(remaining);
         let start_of_pound = if let Ok((start_of_pound, _)) = start_of_pound {
             start_of_pound
         } else {
@@ -47,7 +47,7 @@ pub(crate) fn scan_for_in_buffer_settings<'s>(
         let (remain, maybe_kw) = match filtered_keyword(in_buffer_settings_key)(start_of_line) {
             Ok((remain, kw)) => (remain, Some(kw)),
             Err(_) => {
-                let end_of_line = take_until::<_, _, CustomError<_>>("\n")(start_of_pound);
+                let end_of_line = take_until::<_, _, CustomError>("\n")(start_of_pound);
                 if let Ok((end_of_line, _)) = end_of_line {
                     (end_of_line, None)
                 } else {
@@ -84,11 +84,14 @@ 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(level = "debug", skip(original_settings))
+)]
 pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
     keywords: Vec<Keyword<'sf>>,
     original_settings: &'g GlobalSettings<'g, 's>,
-) -> Result<GlobalSettings<'g, 's>, String> {
+) -> Result<GlobalSettings<'g, 's>, CustomError> {
     let mut new_settings = original_settings.clone();
 
     // Todo Keywords
@@ -98,7 +101,11 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
             || kw.key.eq_ignore_ascii_case("typ_todo")
     }) {
         let (_, (in_progress_words, complete_words)) =
-            todo_keywords(kw.value).map_err(|err| err.to_string())?;
+            todo_keywords(kw.value).map_err(|err| match err {
+                nom::Err::Incomplete(_) => panic!("This parser does not support streaming."),
+                nom::Err::Error(e) => e,
+                nom::Err::Failure(e) => e,
+            })?;
         new_settings
             .in_progress_todo_keywords
             .extend(in_progress_words.into_iter().map(str::to_string));
@@ -112,9 +119,14 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
         .iter()
         .filter(|kw| kw.key.eq_ignore_ascii_case("startup"))
     {
-        let (_remaining, settings) =
+        let (_remaining, settings) = separated_list0(space1::<&str, CustomError>, is_not(" \t"))(
-            separated_list0(space1::<&str, nom::error::Error<_>>, is_not(" \t"))(kw.value)
+            kw.value,
-                .map_err(|err: nom::Err<_>| err.to_string())?;
+        )
+        .map_err(|err: nom::Err<_>| match err {
+            nom::Err::Incomplete(_) => panic!("This parser does not support streaming."),
+            nom::Err::Error(e) => e,
+            nom::Err::Failure(e) => e,
+        })?;
         if settings.contains(&"odd") {
             new_settings.odd_levels_only = HeadlineLevelFilter::Odd;
         }
@@ -128,7 +140,11 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
         .iter()
         .filter(|kw| kw.key.eq_ignore_ascii_case("link"))
     {
-        let (_, (link_key, link_value)) = link_template(kw.value).map_err(|e| e.to_string())?;
+        let (_, (link_key, link_value)) = link_template(kw.value).map_err(|err| match err {
+            nom::Err::Incomplete(_) => panic!("This parser does not support streaming."),
+            nom::Err::Error(e) => e,
+            nom::Err::Failure(e) => e,
+        })?;
         new_settings
             .link_templates
             .insert(link_key.to_owned(), link_value.to_owned());
@@ -139,11 +155,9 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
 
 /// Apply in-buffer settings that do not impact parsing and therefore can be applied after parsing.
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub(crate) fn apply_post_parse_in_buffer_settings<'g, 's, 'sf>(
+pub(crate) fn apply_post_parse_in_buffer_settings<'g, 's, 'sf>(document: &mut Document<'s>) {
-    document: &mut Document<'s>,
-) -> Result<(), &'static str> {
     document.category = Into::<AstNode>::into(&*document)
-        .into_iter()
+        .iter_all_ast_nodes()
         .filter_map(|ast_node| {
             if let AstNode::Keyword(ast_node) = ast_node {
                 if ast_node.key.eq_ignore_ascii_case("category") {
@@ -154,7 +168,6 @@ pub(crate) fn apply_post_parse_in_buffer_settings<'g, 's, 'sf>(
         })
         .last()
         .map(|kw| kw.value.to_owned());
-    Ok(())
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/parser/inline_babel_call.rs

@@ -19,7 +19,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@@ -131,9 +130,7 @@ fn _header_end<'b, 'g, 'r, 's>(
     let current_depth = input.get_bracket_depth() - starting_bracket_depth;
     if current_depth > 0 {
         // Its impossible for the next character to end the header if we're any amount of bracket deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static("NoHeaderEnd")));
-            "NoHeaderEnd",
-        ))));
     }
     if current_depth < 0 {
         // This shouldn't be possible because if depth is 0 then a closing bracket should end the header.
@@ -183,9 +180,7 @@ fn _argument_end<'b, 'g, 'r, 's>(
     let current_depth = input.get_parenthesis_depth() - starting_parenthesis_depth;
     if current_depth > 0 {
         // Its impossible for the next character to end the argument if we're any amount of parenthesis deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static("NoArgumentEnd")));
-            "NoArgumentEnd",
-        ))));
     }
     if current_depth < 0 {
         // This shouldn't be possible because if depth is 0 then a closing parenthesis should end the argument.

src/parser/inline_source_block.rs

@@ -21,7 +21,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@@ -125,9 +124,7 @@ fn _header_end<'b, 'g, 'r, 's>(
     let current_depth = input.get_bracket_depth() - starting_bracket_depth;
     if current_depth > 0 {
         // Its impossible for the next character to end the header if we're any amount of bracket deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static("NoHeaderEnd")));
-            "NoHeaderEnd",
-        ))));
     }
     if current_depth < 0 {
         // This shouldn't be possible because if depth is 0 then a closing bracket should end the header.
@@ -187,7 +184,7 @@ fn _body_end<'b, 'g, 'r, 's>(
     let current_depth = input.get_brace_depth() - starting_brace_depth;
     if current_depth > 0 {
         // Its impossible for the next character to end the body if we're any amount of brace deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError("NoBodyEnd"))));
+        return Err(nom::Err::Error(CustomError::Static("NoBodyEnd")));
     }
     if current_depth < 0 {
         // This shouldn't be possible because if depth is 0 then a closing brace should end the body.

src/parser/keyword.rs

@@ -4,11 +4,9 @@ use nom::bytes::complete::tag;
 use nom::bytes::complete::tag_no_case;
 use nom::bytes::complete::take_while1;
 use nom::character::complete::anychar;
-use nom::character::complete::line_ending;
 use nom::character::complete::one_of;
 use nom::character::complete::space0;
 use nom::combinator::consumed;
-use nom::combinator::eof;
 use nom::combinator::map;
 use nom::combinator::not;
 use nom::combinator::peek;
@@ -22,10 +20,11 @@ use super::org_source::BracketDepth;
 use super::org_source::OrgSource;
 use super::util::get_consumed;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
-use crate::context::parser_with_context;
+use super::util::org_line_ending;
+use crate::context::constants::ORG_ELEMENT_AFFILIATED_KEYWORDS;
+use crate::context::constants::ORG_ELEMENT_DUAL_KEYWORDS;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::macros::element;
 use crate::parser::util::start_of_line;
@@ -50,11 +49,8 @@ fn _filtered_keyword<'s, F: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
     // TODO: When key is a member of org-element-parsed-keywords, value can contain the standard set objects, excluding footnote references.
     let (remaining, (consumed_input, (_, _, parsed_key, _))) =
         consumed(tuple((space0, tag("#+"), key_parser, tag(":"))))(input)?;
-    if let Ok((remaining, _)) = tuple((
+    let (remaining, _ws) = space0(remaining)?;
-        space0::<OrgSource<'_>, CustomError<OrgSource<'_>>>,
+    if let Ok((remaining, _)) = org_line_ending(remaining) {
-        alt((line_ending, eof)),
-    ))(remaining)
-    {
         return Ok((
             remaining,
             Keyword {
@@ -65,12 +61,9 @@ fn _filtered_keyword<'s, F: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
             },
         ));
     }
-    let (remaining, _ws) = space0(remaining)?;
+    let (remaining, parsed_value) =
-    let (remaining, parsed_value) = recognize(many_till(
+        recognize(many_till(anychar, peek(tuple((space0, org_line_ending)))))(remaining)?;
-        anychar,
+    let (remaining, _ws) = tuple((space0, org_line_ending))(remaining)?;
-        peek(tuple((space0, alt((line_ending, eof))))),
-    ))(remaining)?;
-    let (remaining, _ws) = tuple((space0, alt((line_ending, eof))))(remaining)?;
     Ok((
         remaining,
         Keyword {
@@ -106,11 +99,8 @@ where
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub(crate) fn affiliated_keyword<'b, 'g, 'r, 's>(
+pub(crate) fn affiliated_keyword<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Keyword<'s>> {
-    context: RefContext<'b, 'g, 'r, 's>,
+    filtered_keyword(affiliated_key)(input)
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, Keyword<'s>> {
-    filtered_keyword(parser_with_context!(affiliated_key)(context))(input)
 }
 
 #[cfg_attr(
@@ -145,29 +135,18 @@ fn regular_keyword_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn affiliated_key<'b, 'g, 'r, 's>(
+fn affiliated_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    context: RefContext<'b, 'g, 'r, 's>,
+    element!(dual_affiliated_key, input);
-    input: OrgSource<'s>,
+    element!(plain_affiliated_key, input);
-) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    element!(dual_affiliated_key, context, input);
-    element!(plain_affiliated_key, context, input);
     element!(export_keyword, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("No affiliated key.")))
-        "No affiliated key.",
-    ))))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn plain_affiliated_key<'b, 'g, 'r, 's>(
+fn plain_affiliated_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    context: RefContext<'b, 'g, 'r, 's>,
+    for keyword in ORG_ELEMENT_AFFILIATED_KEYWORDS {
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    for keyword in context.get_global_settings().element_affiliated_keywords {
         let result = map(
-            tuple((
+            tuple((tag_no_case::<_, _, CustomError>(keyword), peek(tag(":")))),
-                tag_no_case::<_, _, CustomError<_>>(*keyword),
-                peek(tag(":")),
-            )),
             |(key, _)| key,
         )(input);
         if let Ok((remaining, ent)) = result {
@@ -175,19 +154,14 @@ fn plain_affiliated_key<'b, 'g, 'r, 's>(
         }
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("NoKeywordKey")))
-        "NoKeywordKey",
-    ))))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn dual_affiliated_key<'b, 'g, 'r, 's>(
+fn dual_affiliated_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    context: RefContext<'b, 'g, 'r, 's>,
+    for keyword in ORG_ELEMENT_DUAL_KEYWORDS {
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    for keyword in context.get_global_settings().element_dual_keywords {
         let result = recognize(tuple((
-            tag_no_case::<_, _, CustomError<_>>(*keyword),
+            tag_no_case::<_, _, CustomError>(keyword),
             tag("["),
             optval,
             tag("]"),
@@ -198,9 +172,7 @@ fn dual_affiliated_key<'b, 'g, 'r, 's>(
         }
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("NoKeywordKey")))
-        "NoKeywordKey",
-    ))))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@@ -228,7 +200,7 @@ fn _optval_end<'s>(
         unreachable!("Exceeded optval bracket depth.")
     }
     if current_depth == 0 {
-        let close_bracket = tag::<_, _, CustomError<_>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }
@@ -249,19 +221,12 @@ mod tests {
     use test::Bencher;
 
     use super::*;
-    use crate::context::Context;
-    use crate::context::ContextElement;
-    use crate::context::GlobalSettings;
-    use crate::context::List;
     use crate::parser::OrgSource;
 
     #[bench]
     fn bench_affiliated_keyword(b: &mut Bencher) {
         let input = OrgSource::new("#+CAPTION[*foo*]: bar *baz*");
-        let global_settings = GlobalSettings::default();
-        let initial_context = ContextElement::document_context();
-        let initial_context = Context::new(&global_settings, List::new(&initial_context));
 
-        b.iter(|| assert!(affiliated_keyword(&initial_context, input).is_ok()));
+        b.iter(|| assert!(affiliated_keyword(input).is_ok()));
     }
 }

src/parser/latex_fragment.rs

@@ -17,7 +17,6 @@ use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@@ -209,9 +208,9 @@ fn pre<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, ()> {
     let preceding_character = input.get_preceding_character();
     if let Some('$') = preceding_character {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Not a valid pre character for dollar char fragment.",
-        ))));
+        )));
     }
     Ok((input, ()))
 }
@@ -283,9 +282,9 @@ fn close_border<'b, 'g, 'r, 's>(
     match preceding_character {
         Some(c) if !c.is_whitespace() && !".,;$".contains(c) => Ok((input, ())),
         _ => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Not a valid pre character for dollar char fragment.",
-            ))));
+            )));
         }
     }
 }

src/parser/lesser_block.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use nom::branch::alt;
 use nom::bytes::complete::is_not;
 use nom::bytes::complete::tag;
@@ -27,7 +29,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::standard_set_object;
 use crate::parser::util::blank_line;
@@ -604,7 +605,7 @@ fn _example_src_switches<'s>(
         }
     }
     if !matched_a_word {
-        return Err(nom::Err::Error(CustomError::MyError(MyError("No words."))));
+        return Err(nom::Err::Error(CustomError::Static("No words.")));
     }
     let remaining = last_match_remaining;
 
@@ -652,6 +653,11 @@ fn switch_word<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     ))(input)
 }
 
+enum ContentState {
+    Normal,
+    Modified(String),
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
@@ -659,8 +665,8 @@ fn switch_word<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
 pub(crate) fn content<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, String> {
+) -> Res<OrgSource<'s>, Cow<'s, str>> {
-    let mut ret = String::new();
+    let mut state = ContentState::Normal;
     let mut remaining = input;
     let exit_matcher_parser = parser_with_context!(exit_matcher_parser)(context);
     loop {
@@ -670,13 +676,28 @@ pub(crate) fn content<'b, 'g, 'r, 's>(
 
         let (remain, (pre_escape_whitespace, line)) = content_line(remaining)?;
         if let Some(val) = pre_escape_whitespace {
+            if let ContentState::Modified(ref mut ret) = state {
                 ret.push_str(Into::<&str>::into(val));
+            } else {
+                let mut ret = String::new();
+                ret.push_str(Into::<&str>::into(input.get_until(remaining)));
+                ret.push_str(Into::<&str>::into(val));
+                state = ContentState::Modified(ret);
             }
+        }
+        if let ContentState::Modified(ref mut ret) = state {
             ret.push_str(line.into());
+        }
         remaining = remain;
     }
 
-    Ok((remaining, ret))
+    match state {
+        ContentState::Normal => Ok((
+            remaining,
+            Cow::Borrowed(Into::<&str>::into(input.get_until(remaining))),
+        )),
+        ContentState::Modified(ret) => Ok((remaining, Cow::Owned(ret))),
+    }
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/parser/line_break.rs

@@ -7,7 +7,6 @@ use nom::multi::many0;
 use super::org_source::OrgSource;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::LineBreak;
@@ -45,9 +44,9 @@ fn pre<'b, 'g, 'r, 's>(
     match preceding_character {
         // If None, we are at the start of the file
         None | Some('\\') => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Not a valid pre character for line break.",
-            ))));
+            )));
         }
         _ => {}
     };
@@ -55,9 +54,9 @@ fn pre<'b, 'g, 'r, 's>(
     let current_line = input.text_since_line_break();
     let is_non_empty_line = current_line.chars().any(|c| !c.is_whitespace());
     if !is_non_empty_line {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Not a valid pre line for line break.",
-        ))));
+        )));
     }
 
     Ok((input, ()))

src/parser/mod.rs

@@ -1,6 +1,7 @@
 mod affiliated_keyword;
 mod angle_link;
 mod babel_call;
+mod bullshitium;
 mod citation;
 mod citation_reference;
 mod clock;

src/parser/object_parser.rs

@@ -4,7 +4,6 @@ use super::regular_link::regular_link;
 use super::subscript_and_superscript::detect_subscript_or_superscript;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::angle_link::angle_link;
 use crate::parser::citation::citation;
@@ -43,7 +42,7 @@ pub(crate) fn standard_set_object<'b, 'g, 'r, 's>(
         input,
         Object::PlainText
     );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -61,7 +60,7 @@ pub(crate) fn minimal_set_object<'b, 'g, 'r, 's>(
         input,
         Object::PlainText
     );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -103,7 +102,7 @@ fn standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     element!(angle_link, context, input, Object::AngleLink);
     element!(org_macro, context, input, Object::OrgMacro);
 
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -119,7 +118,7 @@ fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     element!(entity, context, input, Object::Entity);
     element!(latex_fragment, context, input, Object::LatexFragment);
     element!(text_markup, context, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -137,9 +136,7 @@ pub(crate) fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
         return Ok((input, ()));
     }
 
-    return Err(nom::Err::Error(CustomError::MyError(MyError(
+    return Err(nom::Err::Error(CustomError::Static("No object detected.")));
-        "No object detected.",
-    ))));
 }
 
 #[cfg_attr(
@@ -157,9 +154,7 @@ fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
         return Ok((input, ()));
     }
 
-    return Err(nom::Err::Error(CustomError::MyError(MyError(
+    return Err(nom::Err::Error(CustomError::Static("No object detected.")));
-        "No object detected.",
-    ))));
 }
 
 #[cfg_attr(
@@ -182,7 +177,7 @@ pub(crate) fn regular_link_description_set_object<'b, 'g, 'r, 's>(
         input,
         Object::PlainText
     );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -205,7 +200,7 @@ fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     element!(inline_babel_call, context, input, Object::InlineBabelCall);
     element!(org_macro, context, input, Object::OrgMacro);
     element!(minimal_set_object_sans_plain_text, context, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -223,9 +218,7 @@ fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
         return Ok((input, ()));
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("No object detected.")))
-        "No object detected.",
-    ))))
 }
 
 #[cfg_attr(
@@ -243,7 +236,7 @@ pub(crate) fn table_cell_set_object<'b, 'g, 'r, 's>(
         input,
         Object::PlainText
     );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -271,7 +264,7 @@ fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
     element!(target, context, input, Object::Target);
     element!(timestamp, context, input, Object::Timestamp);
     element!(minimal_set_object_sans_plain_text, context, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }
 
 #[cfg_attr(
@@ -289,7 +282,5 @@ fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
         return Ok((input, ()));
     }
 
-    return Err(nom::Err::Error(CustomError::MyError(MyError(
+    return Err(nom::Err::Error(CustomError::Static("No object detected.")));
-        "No object detected.",
-    ))));
 }

src/parser/org_macro.rs

@@ -96,7 +96,7 @@ fn org_macro_arg<'b, 'g, 'r, 's>(
     loop {
         not(parser_with_context!(exit_matcher_parser)(context))(remaining)?;
         not(peek(tag("}}}")))(remaining)?;
-        if peek(tuple((space0::<OrgSource<'_>, CustomError<_>>, tag(")"))))(remaining).is_ok() {
+        if peek(tuple((space0::<_, CustomError>, tag(")"))))(remaining).is_ok() {
             break;
         }
 
@@ -108,7 +108,7 @@ fn org_macro_arg<'b, 'g, 'r, 's>(
         }
         if next_char == '\\' {
             escaping = true;
-            if peek(tag::<_, _, CustomError<_>>(")"))(new_remaining).is_ok() {
+            if peek(tag::<_, _, CustomError>(")"))(new_remaining).is_ok() {
                 // Special case for backslash at the end of a macro
                 remaining = new_remaining;
                 break;

src/parser/org_source.rs

@@ -10,12 +10,9 @@ use nom::InputTakeAtPosition;
 use nom::Offset;
 use nom::Slice;
 
-use crate::error::CustomError;
-use crate::error::MyError;
-
 pub(crate) type BracketDepth = i16;
 
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Copy, Clone)]
 pub(crate) struct OrgSource<'s> {
     full_source: &'s str,
     start: usize,
@@ -85,6 +82,15 @@ impl<'s> OrgSource<'s> {
         self.slice(..(other.end - self.start))
     }
 
+    pub(crate) fn get_until_end_of_str(&self, other: &'s str) -> OrgSource<'s> {
+        let full_source_start = self.full_source.as_ptr() as usize;
+        let other_start = other.as_ptr() as usize - full_source_start;
+        let other_end = other_start + other.len();
+        debug_assert!(other_start >= self.start);
+        debug_assert!(other_end <= self.end);
+        self.slice(..(other_end - self.start))
+    }
+
     pub(crate) fn get_start_of_line(&self) -> OrgSource<'s> {
         let skipped_text = self.text_since_line_break();
         let mut bracket_depth = self.bracket_depth;
@@ -385,33 +391,6 @@ impl<'n, 's> FindSubstring<&'n str> for OrgSource<'s> {
     }
 }
 
-pub(crate) fn convert_error<'a, I: Into<CustomError<&'a str>>>(
-    err: nom::Err<I>,
-) -> nom::Err<CustomError<&'a str>> {
-    match err {
-        nom::Err::Incomplete(needed) => nom::Err::Incomplete(needed),
-        nom::Err::Error(err) => nom::Err::Error(err.into()),
-        nom::Err::Failure(err) => nom::Err::Failure(err.into()),
-    }
-}
-
-impl<'s> From<CustomError<OrgSource<'s>>> for CustomError<&'s str> {
-    fn from(value: CustomError<OrgSource<'s>>) -> Self {
-        match value {
-            CustomError::MyError(err) => CustomError::MyError(err),
-            CustomError::Nom(input, error_kind) => CustomError::Nom(input.into(), error_kind),
-            CustomError::IO(err) => CustomError::IO(err),
-            CustomError::BoxedError(err) => CustomError::BoxedError(err),
-        }
-    }
-}
-
-impl<'s> From<MyError<OrgSource<'s>>> for MyError<&'s str> {
-    fn from(value: MyError<OrgSource<'s>>) -> Self {
-        MyError(value.0.into())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/parser/plain_link.rs

@@ -36,7 +36,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::Matcher;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@@ -95,9 +94,9 @@ fn pre<'b, 'g, 'r, 's>(
         Some(x) if !WORD_CONSTITUENT_CHARACTERS.contains(x) => {}
         Some(_) => {
             // Not at start of line, cannot be a heading
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Not a valid pre character for plain link.",
-            ))));
+            )));
         }
     };
     Ok((input, ()))
@@ -262,15 +261,13 @@ pub(crate) fn protocol<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
     for link_parameter in context.get_global_settings().link_parameters {
-        let result = tag_no_case::<_, _, CustomError<_>>(*link_parameter)(input);
+        let result = tag_no_case::<_, _, CustomError>(*link_parameter)(input);
         if let Ok((remaining, ent)) = result {
             return Ok((remaining, ent));
         }
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("NoLinkProtocol")))
-        "NoLinkProtocol",
-    ))))
 }
 
 #[cfg_attr(
@@ -327,8 +324,7 @@ fn impl_path_plain_end<'b, 'g, 'r, 's>(
     }
 
     if current_depth == 0 {
-        let close_parenthesis =
+        let close_parenthesis = tag::<_, _, CustomError>(")")(remaining);
-            tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>(")")(remaining);
         if close_parenthesis.is_ok() {
             return close_parenthesis;
         }
@@ -342,9 +338,7 @@ fn impl_path_plain_end<'b, 'g, 'r, 's>(
         }
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("No path plain end")))
-        "No path plain end",
-    ))))
 }
 
 #[cfg_attr(
@@ -420,18 +414,18 @@ fn _path_plain_parenthesis_end<'s>(
         unreachable!("Exceeded plain link parenthesis depth.")
     }
     if current_depth == 0 {
-        let close_parenthesis = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>(")")(input);
+        let close_parenthesis = tag::<_, _, CustomError>(")")(input);
         if close_parenthesis.is_ok() {
             return close_parenthesis;
         }
     }
     if current_depth == 1 {
-        let open_parenthesis = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("(")(input);
+        let open_parenthesis = tag::<_, _, CustomError>("(")(input);
         if open_parenthesis.is_ok() {
             return open_parenthesis;
         }
     }
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static(
         "No closing parenthesis",
-    ))))
+    )))
 }

src/parser/plain_list.rs

@@ -3,6 +3,7 @@ use nom::bytes::complete::tag;
 use nom::character::complete::anychar;
 use nom::character::complete::digit1;
 use nom::character::complete::line_ending;
+use nom::character::complete::multispace1;
 use nom::character::complete::one_of;
 use nom::character::complete::space0;
 use nom::character::complete::space1;
@@ -17,6 +18,7 @@ use nom::multi::many0;
 use nom::multi::many1;
 use nom::multi::many_till;
 use nom::sequence::tuple;
+use nom::InputTake;
 
 use super::affiliated_keyword::parse_affiliated_keywords;
 use super::element_parser::element;
@@ -25,6 +27,7 @@ use super::org_source::OrgSource;
 use super::util::include_input;
 use super::util::indentation_level;
 use super::util::non_whitespace_character;
+use crate::context::bind_context;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::ContextMatcher;
@@ -32,7 +35,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::blank_line;
 use crate::parser::util::exit_matcher_parser;
@@ -78,9 +80,47 @@ where
     {
         return Ok((input, ()));
     }
-    return Err(nom::Err::Error(CustomError::MyError(MyError(
+    return Err(nom::Err::Error(CustomError::Static("No element detected.")));
-        "No element detected.",
+}
-    ))));
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+pub(crate) fn detect_not_plain_list_item_indent<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, (u16, OrgSource<'s>)> {
+    if let Ok((_remaining, (_, indent, _))) = tuple((
+        start_of_line,
+        parser_with_context!(indentation_level)(context),
+        not(tuple((
+            parser_with_context!(bullet)(context),
+            alt((space1, line_ending, eof)),
+        ))),
+    ))(input)
+    {
+        return Ok((input, indent));
+    }
+
+    // Headlines are not plain list items.
+    if let Ok((_remaining, (_, indent, _))) = verify(
+        tuple((
+            start_of_line,
+            parser_with_context!(indentation_level)(context),
+            tuple((
+                parser_with_context!(bullet)(context),
+                alt((space1, line_ending, eof)),
+            )),
+        )),
+        |(_, (depth, _), ((_, bullet), _))| {
+            *depth == 0 && Into::<&str>::into(bullet).starts_with('*')
+        },
+    )(input)
+    {
+        return Ok((input, indent));
+    }
+    return Err(nom::Err::Error(CustomError::Static("No element detected.")));
 }
 
 #[cfg_attr(
@@ -123,7 +163,7 @@ where
     // While #3 is the most slow, it also seems to cleanest and involves the least manual mutation of already-parsed objects so I am going with #3 for now, but we should revisit #1 or #2 when the parser is more developed.
 
     loop {
-        let list_item = parser_with_context!(plain_list_item)(&parser_context)(remaining);
+        let list_item = plain_list_item(&parser_context, remaining);
         match (&first_item_list_type, &list_item) {
             (None, Ok((_remain, (list_type, _item)))) => {
                 let _ = first_item_list_type.insert(*list_type);
@@ -143,25 +183,17 @@ where
             }
         };
 
-        let maybe_exit = parser_with_context!(exit_matcher_parser)(&parser_context)(remaining);
+        let maybe_exit = exit_matcher_parser(&parser_context, remaining);
         if maybe_exit.is_ok() {
             break;
         }
     }
 
-    let (final_child_start, _final_item_first_parse) = match children.pop() {
+    if children.is_empty() {
-        Some(final_child) => final_child,
+        return Err(nom::Err::Error(CustomError::Static(
-        None => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
             "Plain lists require at least one element.",
-            ))));
+        )));
     }
-    };
-    let final_item_context = ContextElement::ConsumeTrailingWhitespace(false);
-    let final_item_context = parser_context.with_additional_node(&final_item_context);
-    let (remaining, (_, reparsed_final_item)) =
-        parser_with_context!(plain_list_item)(&final_item_context)(final_child_start)?;
-    children.push((final_child_start, reparsed_final_item));
 
     let (remaining, _trailing_ws) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
@@ -190,10 +222,10 @@ fn plain_list_item<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, (PlainListType, PlainListItem<'s>)> {
     start_of_line(input)?;
     let (remaining, (indent_level, _leading_whitespace)) = indentation_level(context, input)?;
-    let (remaining, (bullet_type, bull)) = verify(
+    let (remaining, (bullet_type, bull)) =
-        parser_with_context!(bullet)(context),
+        verify(bind_context!(bullet, context), |(_bullet_type, bull)| {
-        |(_bullet_type, bull)| !Into::<&str>::into(bull).starts_with('*') || indent_level > 0,
+            !Into::<&str>::into(bull).starts_with('*') || indent_level > 0
-    )(remaining)?;
+        })(remaining)?;
 
     let (remaining, maybe_counter_set) =
         opt(tuple((space1, tag("[@"), counter_set_value, tag("]"))))(remaining)?;
@@ -202,7 +234,7 @@ fn plain_list_item<'b, 'g, 'r, 's>(
     let (remaining, maybe_checkbox) = opt(tuple((space1, item_checkbox)))(remaining)?;
 
     let (remaining, maybe_tag) = if let BulletType::Unordered = bullet_type {
-        opt(tuple((space1, parser_with_context!(item_tag)(context))))(remaining)?
+        opt(tuple((space1, bind_context!(item_tag, context))))(remaining)?
     } else {
         (remaining, None)
     };
@@ -214,6 +246,12 @@ fn plain_list_item<'b, 'g, 'r, 's>(
     };
 
     let exit_matcher = plain_list_item_end(indent_level);
+    let final_item_whitespace_cutoff = final_item_whitespace_cutoff(indent_level);
+    let final_whitespace_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
+        class: ExitClass::Beta,
+        exit_matcher: &final_item_whitespace_cutoff,
+    });
+    let final_whitespace_context = context.with_additional_node(&final_whitespace_context);
     let contexts = [
         ContextElement::ConsumeTrailingWhitespace(true),
         ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -221,17 +259,21 @@ fn plain_list_item<'b, 'g, 'r, 's>(
             exit_matcher: &exit_matcher,
         }),
     ];
-    let parser_context = context.with_additional_node(&contexts[0]);
+    let parser_context = final_whitespace_context.with_additional_node(&contexts[0]);
     let parser_context = parser_context.with_additional_node(&contexts[1]);
 
-    let maybe_contentless_item: Res<OrgSource<'_>, ()> = peek(parser_with_context!(
+    let maybe_contentless_item: Res<OrgSource<'_>, ()> =
-        detect_contentless_item_contents
+        detect_contentless_item_contents(&parser_context, remaining);
-    )(&parser_context))(remaining);
     if let Ok((_rem, _ws)) = maybe_contentless_item {
-        let (remaining, _trailing_ws) = if context.should_consume_trailing_whitespace() {
+        let (remaining, _trailing_ws) = if tuple((
-            recognize(alt((recognize(many1(blank_line)), eof)))(remaining)?
+            blank_line,
-        } else {
+            bind_context!(final_item_whitespace_cutoff, context),
+        ))(remaining)
+        .is_ok()
+        {
             recognize(alt((blank_line, eof)))(remaining)?
+        } else {
+            recognize(alt((recognize(many1(blank_line)), eof)))(remaining)?
         };
         let source = get_consumed(input, remaining);
         return Ok((
@@ -259,26 +301,14 @@ fn plain_list_item<'b, 'g, 'r, 's>(
         .filter(|b| *b == b'\n')
         .count();
 
-    let (mut remaining, (mut children, _exit_contents)) = many_till(
+    let (remaining, (children, _exit_contents)) = many_till(
-        include_input(parser_with_context!(element(true))(&parser_context)),
+        include_input(bind_context!(element(true), &parser_context)),
-        parser_with_context!(exit_matcher_parser)(&parser_context),
+        bind_context!(exit_matcher_parser, &parser_context),
     )(remaining)?;
 
-    if !children.is_empty() && !context.should_consume_trailing_whitespace() {
+    // We have to use the parser_context here to include the whitespace cut-off
-        let final_item_context = ContextElement::ConsumeTrailingWhitespace(false);
-        let final_item_context = parser_context.with_additional_node(&final_item_context);
-        let (final_child_start, _original_final_child) = children
-            .pop()
-            .expect("if-statement already checked that children was non-empty.");
-        let (remain, reparsed_final_element) = include_input(parser_with_context!(element(true))(
-            &final_item_context,
-        ))(final_child_start)?;
-        remaining = remain;
-        children.push(reparsed_final_element);
-    }
-
     let (remaining, _trailing_ws) =
-        maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
+        maybe_consume_trailing_whitespace_if_not_exiting(&final_whitespace_context, remaining)?;
 
     let source = get_consumed(input, remaining);
     return Ok((
@@ -325,7 +355,7 @@ fn bullet<'b, 'g, 'r, 's>(
             map(tag("+"), |bull| (BulletType::Unordered, bull)),
             map(
                 recognize(tuple((
-                    parser_with_context!(counter)(context),
+                    bind_context!(counter, context),
                     alt((tag("."), tag(")"))),
                 ))),
                 |bull| (BulletType::Ordered, bull),
@@ -380,6 +410,52 @@ fn counter_set_value<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, PlainListIt
     ))(input)
 }
 
+const fn final_item_whitespace_cutoff(indent_level: IndentationLevel) -> impl ContextMatcher {
+    move |context, input: OrgSource<'_>| {
+        impl_final_item_whitespace_cutoff(context, input, indent_level)
+    }
+}
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+fn impl_final_item_whitespace_cutoff<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+    indent_level: IndentationLevel,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
+    start_of_line(input)?;
+    // element!(plain_list_end, context, input);
+
+    if let Ok((_remaining, _)) = verify(
+        tuple((
+            opt(blank_line),
+            bind_context!(indentation_level, context),
+            not(multispace1),
+        )),
+        |(_, (depth, _stars), _not_whitespace)| *depth < indent_level,
+    )(input)
+    {
+        return Ok((input, input.take(0)));
+    }
+
+    if let Ok((_remaining, _)) = tuple((
+        opt(blank_line),
+        verify(
+            bind_context!(detect_not_plain_list_item_indent, context),
+            |(depth, _)| *depth == indent_level,
+        ),
+    ))(input)
+    {
+        return Ok((input, input.take(0)));
+    }
+
+    Err(nom::Err::Error(CustomError::Static(
+        "No whitespace cut-off.",
+    )))
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(_context))
@@ -415,7 +491,7 @@ fn _plain_list_item_end<'b, 'g, 'r, 's>(
     start_of_line(input)?;
     recognize(tuple((
         opt(blank_line),
-        parser_with_context!(line_indented_lte_matcher)(context),
+        bind_context!(line_indented_lte_matcher, context),
     )))(input)
 }
 
@@ -434,7 +510,7 @@ fn _line_indented_lte<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
     let matched = recognize(verify(
         tuple((
-            parser_with_context!(indentation_level)(context),
+            bind_context!(indentation_level, context),
             non_whitespace_character,
         )),
         // It is fine that we get the indent level using the number of bytes rather than the number of characters because nom's space0 only matches space and tab (0x20 and 0x09)
@@ -460,8 +536,8 @@ fn item_tag<'b, 'g, 'r, 's>(
     let (remaining, (children, _exit_contents)) = verify(
         many_till(
             // TODO: Should this be using a different set like the minimal set?
-            parser_with_context!(standard_set_object)(&parser_context),
+            bind_context!(standard_set_object, &parser_context),
-            parser_with_context!(exit_matcher_parser)(&parser_context),
+            bind_context!(exit_matcher_parser, &parser_context),
         ),
         |(children, _exit_contents)| !children.is_empty(),
     )(input)?;
@@ -511,7 +587,7 @@ fn item_tag_post_gap<'b, 'g, 'r, 's>(
                 alt((
                     peek(recognize(not(blank_line))),
                     peek(recognize(tuple((many0(blank_line), eof)))),
-                    parser_with_context!(exit_matcher_parser)(context),
+                    bind_context!(exit_matcher_parser, context),
                 )),
             ),
         ))),
@@ -541,7 +617,7 @@ fn detect_contentless_item_contents<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, ()> {
     let (remaining, _) = recognize(many_till(
         blank_line,
-        parser_with_context!(exit_matcher_parser)(context),
+        bind_context!(exit_matcher_parser, context),
     ))(input)?;
     Ok((remaining, ()))
 }

src/parser/plain_text.rs

@@ -20,7 +20,6 @@ use super::util::org_space_or_line_ending;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::types::Object;
 use crate::types::PlainText;
@@ -92,7 +91,7 @@ impl<'x> RematchObject<'x> for PlainText<'x> {
                 break;
             }
 
-            let is_not_whitespace = is_not::<&str, &str, CustomError<_>>(" \t\r\n")(goal);
+            let is_not_whitespace = is_not::<_, _, CustomError>(" \t\r\n")(goal);
             if let Ok((new_goal, payload)) = is_not_whitespace {
                 let (new_remaining, _) = tuple((
                     tag_no_case(payload),
@@ -108,7 +107,7 @@ impl<'x> RematchObject<'x> for PlainText<'x> {
             }
 
             let is_whitespace = recognize(many1(alt((
-                recognize(one_of::<&str, &str, CustomError<_>>(" \t")),
+                recognize(one_of::<_, _, CustomError>(" \t")),
                 line_ending,
             ))))(goal);
             if let Ok((new_goal, _)) = is_whitespace {
@@ -118,9 +117,9 @@ impl<'x> RematchObject<'x> for PlainText<'x> {
                 continue;
             }
 
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Target does not match.",
-            ))));
+            )));
         }
 
         let source = get_consumed(input, remaining);

src/parser/property_drawer.rs

@@ -21,7 +21,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::parser::util::immediate_in_section;
@@ -39,9 +38,9 @@ pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PropertyDrawer<'s>> {
     if immediate_in_section(context, "property-drawer") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
-        ))));
+        )));
     }
     let (
         remaining,

src/parser/radio_link.rs

@@ -21,7 +21,6 @@ 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::util::get_consumed;
 use crate::types::Object;
@@ -52,9 +51,7 @@ pub(crate) fn radio_link<'b, 'g, 'r, 's>(
             ));
         }
     }
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("NoRadioLink")))
-        "NoRadioLink",
-    ))))
 }
 
 #[cfg_attr(
@@ -98,9 +95,9 @@ pub(crate) fn rematch_target<'x, 'b, 'g, 'r, 's>(
                 new_matches.push(new_match);
             }
             _ => {
-                return Err(nom::Err::Error(CustomError::MyError(MyError(
+                return Err(nom::Err::Error(CustomError::Static(
                     "OnlyMinimalSetObjectsAllowed",
-                ))));
+                )));
             }
         };
     }
@@ -182,7 +179,7 @@ mod tests {
     use crate::types::PlainText;
 
     #[test]
-    fn plain_text_radio_target() {
+    fn plain_text_radio_target() -> Result<(), Box<dyn std::error::Error>> {
         let input = OrgSource::new("foo bar baz");
         let radio_target_match = vec![Object::PlainText(PlainText { source: "bar" })];
         let global_settings = GlobalSettings {
@@ -203,21 +200,31 @@ mod tests {
             "foo bar baz"
         );
         assert_eq!(first_paragraph.children.len(), 3);
-        assert_eq!(
+        match first_paragraph
-            first_paragraph
             .children
             .get(1)
-                .expect("Len already asserted to be 3"),
+            .expect("Len already asserted to be 3.")
-            &Object::RadioLink(RadioLink {
+        {
-                source: "bar ",
+            Object::RadioLink(inner) => {
-                children: vec![Object::PlainText(PlainText { source: "bar" })],
+                assert_eq!(inner.get_standard_properties().get_source(), "bar ");
-                path: "bar"
+                assert_eq!(inner.path, "bar");
-            })
+                assert_eq!(inner.children.len(), 1);
-        );
+                let child = inner
+                    .children
+                    .first()
+                    .expect("Length already asserted to be 1.");
+                assert!(matches!(child, Object::PlainText(_)));
+                assert_eq!(child.get_standard_properties().get_source(), "bar");
+            }
+            _ => {
+                return Err("Child should be a radio link.".into());
+            }
+        };
+        Ok(())
     }
 
     #[test]
-    fn bold_radio_target() {
+    fn bold_radio_target() -> Result<(), Box<dyn std::error::Error>> {
         let input = OrgSource::new("foo *bar* baz");
         let radio_target_match = vec![Object::Bold(Bold {
             source: "*bar*",
@@ -242,19 +249,26 @@ mod tests {
             "foo *bar* baz"
         );
         assert_eq!(first_paragraph.children.len(), 3);
-        assert_eq!(
+        match first_paragraph
-            first_paragraph
             .children
             .get(1)
-                .expect("Len already asserted to be 3"),
+            .expect("Len already asserted to be 3.")
-            &Object::RadioLink(RadioLink {
+        {
-                source: "*bar* ",
+            Object::RadioLink(inner) => {
-                children: vec![Object::Bold(Bold {
+                assert_eq!(inner.get_standard_properties().get_source(), "*bar* ");
-                    source: "*bar* ",
+                assert_eq!(inner.path, "*bar* ");
-                    children: vec![Object::PlainText(PlainText { source: "bar" })]
+                assert_eq!(inner.children.len(), 1);
-                })],
+                let child = inner
-                path: "*bar* "
+                    .children
-            })
+                    .first()
-        );
+                    .expect("Length already asserted to be 1.");
+                assert!(matches!(child, Object::Bold(_)));
+                assert_eq!(child.get_standard_properties().get_source(), "*bar* ");
+            }
+            _ => {
+                return Err("Child should be a radio link.".into());
+            }
+        };
+        Ok(())
     }
 }

src/parser/regular_link.rs

@@ -43,7 +43,6 @@ 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::types::LinkType;
 use crate::types::Object;
@@ -163,11 +162,7 @@ fn parse_path_reg<'b, 'g, 'r, 's>(
             parser_with_context!(protocol_path_reg)(context),
             fuzzy_path_reg,
         ))(replaced_input)
-        .map_err(|_| {
+        .map_err(|_| nom::Err::Error(CustomError::Static("No pathreg match after replacement.")))?;
-            nom::Err::Error(CustomError::MyError(MyError(
-                "No pathreg match after replacement.",
-            )))
-        })?;
         let remaining = input.take(input.len());
         let link_type = match link.link_type {
             LinkType::Protocol(protocol) => LinkType::Protocol(protocol.into_owned().into()),
@@ -483,7 +478,5 @@ fn impl_path_reg_end<'b, 'g, 'r, 's>(
         }
     }
 
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("No path reg end")))
-        "No path reg end",
-    ))))
 }

src/parser/subscript_and_superscript.rs

@@ -26,7 +26,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::Matcher;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Object;
@@ -39,7 +38,7 @@ pub(crate) fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<O
     // This does not have to detect all valid subscript/superscript but all that it detects must be valid.
     let (remaining, _) = one_of("_^")(input)?;
     pre(input)?;
-    if tag::<_, _, CustomError<_>>("*")(remaining).is_ok() {
+    if tag::<_, _, CustomError>("*")(remaining).is_ok() {
         return Ok((input, ()));
     }
     let (remaining, _) = opt(one_of("+-"))(remaining)?;
@@ -232,9 +231,9 @@ fn _script_with_braces_end<'b, 'g, 'r, 's>(
     let current_depth = input.get_brace_depth() - starting_brace_depth;
     if current_depth > 0 {
         // Its impossible for the next character to end the subscript or superscript if we're any amount of braces deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Not a valid end for subscript or superscript.",
-        ))));
+        )));
     }
     if current_depth < 0 {
         // This shouldn't be possible because if depth is 0 then a closing brace should end the subscript or superscript.
@@ -282,12 +281,12 @@ fn _script_with_parenthesis_end<'s>(
         unreachable!("Exceeded citation key suffix bracket depth.")
     }
     if current_depth == 0 {
-        let close_parenthesis = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>(")")(input);
+        let close_parenthesis = tag::<_, _, CustomError>(")")(input);
         if close_parenthesis.is_ok() {
             return close_parenthesis;
         }
     }
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static(
         "No script parenthesis end.",
-    ))))
+    )))
 }

src/parser/target.rs

@@ -13,7 +13,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Target;
@@ -42,9 +41,9 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
         .get_preceding_character()
         .expect("We cannot be at the start of the file because we are inside a target.");
     if preceding_character.is_whitespace() {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Targets cannot end with whitespace.",
-        ))));
+        )));
     }
     let (remaining, _) = tag(">>")(remaining)?;
     let (remaining, _trailing_whitespace) =

src/parser/text_markup.rs

@@ -34,7 +34,6 @@ 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::radio_link::rematch_target;
 use crate::parser::util::exit_matcher_parser;
@@ -234,9 +233,9 @@ fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
         #[cfg(feature = "tracing")]
         let _enter = span.enter();
         if exit_matcher_parser(context, remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Parent exit matcher is triggering.",
-            ))));
+            )));
         }
     }
 
@@ -290,9 +289,9 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
         #[cfg(feature = "tracing")]
         let _enter = span.enter();
         if exit_matcher_parser(context, remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Parent exit matcher is triggering.",
-            ))));
+            )));
         }
     }
 
@@ -321,9 +320,9 @@ fn pre<'b, 'g, 'r, 's>(
         // If None, we are at the start of the file which is technically the beginning of a line.
         Some('-') | Some('(') | Some('{') | Some('\'') | Some('"') => {}
         Some(_) => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Not a valid pre character for text markup.",
-            ))));
+            )));
         }
         None => unreachable!(), // None is for start of file, which should already be handled by the start_of_line matcher above.
     };
@@ -360,9 +359,9 @@ fn _text_markup_end<'b, 'g, 'r, 's, 'c>(
     contents_start_offset: usize,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
     if input.get_byte_offset() == contents_start_offset {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Text markup cannot be empty",
-        ))));
+        )));
     }
     not(preceded_by_whitespace(false))(input)?;
     let (remaining, _marker) = terminated(
@@ -495,9 +494,9 @@ fn _rematch_text_markup_object<'b, 'g, 'r, 's, 'x>(
         #[cfg(feature = "tracing")]
         let _enter = span.enter();
         if exit_matcher_parser(context, remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                 "Parent exit matcher is triggering.",
-            ))));
+            )));
         }
     }
 

src/parser/util.rs

@@ -20,7 +20,6 @@ use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::types::IndentationLevel;
 
@@ -129,9 +128,7 @@ pub(crate) fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()>
     if input.is_at_start_of_line() {
         Ok((input, ()))
     } else {
-        Err(nom::Err::Error(CustomError::MyError(MyError(
+        Err(nom::Err::Error(CustomError::Static("Not at start of line")))
-            "Not at start of line",
-        ))))
     }
 }
 
@@ -152,9 +149,9 @@ fn _preceded_by_whitespace<'s>(
         .map(|c| c.is_whitespace() || c == '\u{200B}') // 200B = Zero-width space
         .unwrap_or(allow_start_of_file)
     {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
             "Must be preceded by a whitespace character.",
-        ))));
+        )));
     }
     Ok((input, ()))
 }
@@ -195,9 +192,7 @@ pub(crate) fn text_until_exit<'b, 'g, 'r, 's>(
 
 #[allow(dead_code)]
 fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static("Not implemented yet.")))
-        "Not implemented yet.",
-    ))))
 }
 
 #[allow(dead_code)]
@@ -205,9 +200,7 @@ fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
 /// Text from the current point until the next line break or end of file
 ///
 /// Useful for debugging.
-fn text_until_eol<'r, 's>(
+fn text_until_eol<'r, 's>(input: OrgSource<'s>) -> Result<&'s str, nom::Err<CustomError>> {
-    input: OrgSource<'s>,
-) -> Result<&'s str, nom::Err<CustomError<OrgSource<'s>>>> {
     let line = recognize(many_till(anychar, alt((line_ending, eof))))(input)
         .map(|(_remaining, line)| Into::<&str>::into(line))?;
     Ok(line.trim())
@@ -250,6 +243,10 @@ pub(crate) fn org_line_ending(input: OrgSource<'_>) -> Res<OrgSource<'_>, OrgSou
 }
 
 /// Match the whitespace at the beginning of a line and give it an indentation level.
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
 pub(crate) fn indentation_level<'s>(
     context: RefContext<'_, '_, '_, 's>,
     input: OrgSource<'s>,

src/types/element.rs

@@ -22,7 +22,6 @@ use super::CenterBlock;
 use super::Drawer;
 use super::GetStandardProperties;
 use super::QuoteBlock;
-use super::SetSource;
 use super::SpecialBlock;
 use super::StandardProperties;
 
@@ -55,38 +54,6 @@ pub enum Element<'s> {
     LatexEnvironment(LatexEnvironment<'s>),
 }
 
-impl<'s> SetSource<'s> for Element<'s> {
-    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-    fn set_source(&mut self, source: &'s str) {
-        match self {
-            Element::Paragraph(obj) => obj.source = source,
-            Element::PlainList(obj) => obj.source = source,
-            Element::CenterBlock(obj) => obj.source = source,
-            Element::QuoteBlock(obj) => obj.source = source,
-            Element::SpecialBlock(obj) => obj.source = source,
-            Element::DynamicBlock(obj) => obj.source = source,
-            Element::FootnoteDefinition(obj) => obj.source = source,
-            Element::Comment(obj) => obj.source = source,
-            Element::Drawer(obj) => obj.source = source,
-            Element::PropertyDrawer(obj) => obj.source = source,
-            Element::Table(obj) => obj.source = source,
-            Element::VerseBlock(obj) => obj.source = source,
-            Element::CommentBlock(obj) => obj.source = source,
-            Element::ExampleBlock(obj) => obj.source = source,
-            Element::ExportBlock(obj) => obj.source = source,
-            Element::SrcBlock(obj) => obj.source = source,
-            Element::Clock(obj) => obj.source = source,
-            Element::DiarySexp(obj) => obj.source = source,
-            Element::Planning(obj) => obj.source = source,
-            Element::FixedWidthArea(obj) => obj.source = source,
-            Element::HorizontalRule(obj) => obj.source = source,
-            Element::Keyword(obj) => obj.source = source,
-            Element::BabelCall(obj) => obj.source = source,
-            Element::LatexEnvironment(obj) => obj.source = source,
-        }
-    }
-}
-
 impl<'s> GetStandardProperties<'s> for Element<'s> {
     fn get_standard_properties<'b>(&'b self) -> &'b dyn StandardProperties<'s> {
         match self {

src/types/lesser_element.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use super::object::Object;
 use super::AffiliatedKeywords;
 use super::GetAffiliatedKeywords;
@@ -59,7 +61,7 @@ pub struct ExampleBlock<'s> {
     pub retain_labels: RetainLabels,
     pub use_labels: bool,
     pub label_format: Option<&'s str>,
-    pub contents: String,
+    pub contents: Cow<'s, str>,
 }
 
 #[derive(Debug)]
@@ -68,7 +70,7 @@ pub struct ExportBlock<'s> {
     pub affiliated_keywords: AffiliatedKeywords<'s>,
     pub export_type: Option<&'s str>,
     pub data: Option<&'s str>,
-    pub contents: String,
+    pub contents: Cow<'s, str>,
 }
 
 #[derive(Debug)]
@@ -83,7 +85,7 @@ pub struct SrcBlock<'s> {
     pub retain_labels: RetainLabels,
     pub use_labels: bool,
     pub label_format: Option<&'s str>,
-    pub contents: String,
+    pub contents: Cow<'s, str>,
 }
 
 #[derive(Debug)]
@@ -169,11 +171,11 @@ impl<'s> Paragraph<'s> {
     /// Generate a paragraph of the passed in text with no additional properties.
     ///
     /// This is used for elements that support an "empty" content like greater blocks.
-    pub(crate) fn of_text(input: &'s str) -> Self {
+    pub(crate) fn of_text(source: &'s str, body: &'s str) -> Self {
         Paragraph {
-            source: input,
+            source,
             affiliated_keywords: AffiliatedKeywords::default(),
-            children: vec![Object::PlainText(PlainText { source: input })],
+            children: vec![Object::PlainText(PlainText { source: body })],
         }
     }
 }

src/types/mod.rs

@@ -7,14 +7,13 @@ mod greater_element;
 mod lesser_element;
 mod macros;
 mod object;
-mod source;
 mod standard_properties;
 mod util;
 pub use affiliated_keyword::AffiliatedKeyword;
 pub use affiliated_keyword::AffiliatedKeywordValue;
 pub use affiliated_keyword::AffiliatedKeywords;
 pub use affiliated_keyword::GetAffiliatedKeywords;
-pub(crate) use ast_node::AstNode;
+pub use ast_node::AstNode;
 pub use document::Document;
 pub use document::DocumentElement;
 pub use document::Heading;
@@ -113,5 +112,4 @@ pub use object::WarningDelay;
 pub use object::WarningDelayType;
 pub use object::Year;
 pub use object::YearInner;
-pub(crate) use source::SetSource;
 pub use standard_properties::StandardProperties;

src/types/object.rs

@@ -9,8 +9,7 @@ use super::util::to_lowercase;
 use super::GetStandardProperties;
 use super::StandardProperties;
 
-// TODO: Why did we make Object implement PartialEq again? Was it just for tests?
+#[derive(Debug)]
-#[derive(Debug, PartialEq)]
 pub enum Object<'s> {
     Bold(Bold<'s>),
     Italic(Italic<'s>),
@@ -41,48 +40,48 @@ pub enum Object<'s> {
     Timestamp(Timestamp<'s>),
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Bold<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Italic<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Underline<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct StrikeThrough<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Code<'s> {
     pub source: &'s str,
     pub contents: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Verbatim<'s> {
     pub source: &'s str,
     pub contents: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct PlainText<'s> {
     pub source: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RegularLink<'s> {
     pub source: &'s str,
     pub link_type: LinkType<'s>,
@@ -105,21 +104,21 @@ pub struct RegularLink<'s> {
     pub application: Option<Cow<'s, str>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RadioTarget<'s> {
     pub source: &'s str,
     pub value: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RadioLink<'s> {
     pub source: &'s str,
     pub path: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct PlainLink<'s> {
     pub source: &'s str,
     pub link_type: LinkType<'s>,
@@ -129,7 +128,7 @@ pub struct PlainLink<'s> {
     pub application: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct AngleLink<'s> {
     pub source: &'s str,
     pub link_type: LinkType<'s>,
@@ -147,7 +146,7 @@ pub struct AngleLink<'s> {
     pub application: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct OrgMacro<'s> {
     pub source: &'s str,
 
@@ -164,7 +163,7 @@ pub struct OrgMacro<'s> {
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Entity<'s> {
     pub source: &'s str,
     pub name: &'s str,
@@ -177,27 +176,27 @@ pub struct Entity<'s> {
     pub use_brackets: bool,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct LatexFragment<'s> {
     pub source: &'s str,
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct ExportSnippet<'s> {
     pub source: &'s str,
     pub backend: &'s str,
     pub contents: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct FootnoteReference<'s> {
     pub source: &'s str,
     pub label: Option<&'s str>,
     pub definition: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Citation<'s> {
     pub source: &'s str,
     pub style: Option<&'s str>,
@@ -206,7 +205,7 @@ pub struct Citation<'s> {
     pub children: Vec<CitationReference<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct CitationReference<'s> {
     pub source: &'s str,
     pub key: &'s str,
@@ -214,7 +213,7 @@ pub struct CitationReference<'s> {
     pub suffix: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct InlineBabelCall<'s> {
     pub source: &'s str,
     pub value: &'s str,
@@ -224,7 +223,7 @@ pub struct InlineBabelCall<'s> {
     pub end_header: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct InlineSourceBlock<'s> {
     pub source: &'s str,
     pub language: &'s str,
@@ -232,31 +231,31 @@ pub struct InlineSourceBlock<'s> {
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct LineBreak<'s> {
     pub source: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Target<'s> {
     pub source: &'s str,
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct StatisticsCookie<'s> {
     pub source: &'s str,
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Subscript<'s> {
     pub source: &'s str,
     pub use_brackets: bool,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Superscript<'s> {
     pub source: &'s str,
     pub use_brackets: bool,
@@ -264,7 +263,7 @@ pub struct Superscript<'s> {
 }
 
 // TODO: Perhaps there is an optimization of converting to unix time we can do to shrink this struct. (ref: clippy::large_enum_variant on Element)
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Timestamp<'s> {
     pub source: &'s str,
     pub timestamp_type: TimestampType,
@@ -277,7 +276,7 @@ pub struct Timestamp<'s> {
     pub warning_delay: Option<WarningDelay>,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum TimestampType {
     Diary,
     Active,
@@ -286,7 +285,7 @@ pub enum TimestampType {
     InactiveRange,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum TimestampRangeType {
     None,
     DateRange,
@@ -299,19 +298,19 @@ pub type DayOfMonthInner = u8;
 pub type HourInner = u8;
 pub type MinuteInner = u8;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Year(YearInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Month(MonthInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct DayOfMonth(DayOfMonthInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Hour(HourInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Minute(MinuteInner);
 
 impl Year {
@@ -386,7 +385,7 @@ impl Minute {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Date<'s> {
     year: Year,
     month: Month,
@@ -444,7 +443,7 @@ impl<'s> Date<'s> {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Time<'s> {
     hour: Hour,
     minute: Minute,
@@ -478,20 +477,20 @@ impl<'s> Time<'s> {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum RepeaterType {
     Cumulative,
     CatchUp,
     Restart,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum WarningDelayType {
     All,
     First,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum TimeUnit {
     Hour,
     Day,
@@ -502,14 +501,14 @@ pub enum TimeUnit {
 
 pub type RepeaterWarningDelayValueType = u16;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Repeater {
     pub repeater_type: RepeaterType,
     pub value: RepeaterWarningDelayValueType,
     pub unit: TimeUnit,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct WarningDelay {
     pub warning_delay_type: WarningDelayType,
     pub value: RepeaterWarningDelayValueType,
@@ -718,7 +717,7 @@ impl<'s> Timestamp<'s> {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum LinkType<'s> {
     File,
     Protocol(Cow<'s, str>),
@@ -787,7 +786,7 @@ impl<'s> OrgMacro<'s> {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum FootnoteReferenceType {
     Standard,
     Inline,

src/types/source.rs

@@ -1,3 +0,0 @@
-pub(crate) trait SetSource<'s> {
-    fn set_source(&mut self, source: &'s str);
-}

src/types/util.rs

@@ -515,4 +515,25 @@ mod tests {
         assert!(matches!(output, Cow::Borrowed(_)));
         Ok(())
     }
+
+    #[test]
+    fn test_coalesce_whitespace_if_line_break() -> Result<(), Box<dyn std::error::Error>> {
+        assert_eq!(coalesce_whitespace_if_line_break("foo  bar"), "foo  bar");
+        assert_eq!(coalesce_whitespace_if_line_break("foo \n bar"), "foo bar");
+        Ok(())
+    }
+
+    #[test]
+    fn test_remove_whitespace_if_line_break() -> Result<(), Box<dyn std::error::Error>> {
+        assert_eq!(remove_whitespace_if_line_break("foo  bar"), "foo  bar");
+        assert_eq!(remove_whitespace_if_line_break("foo \n bar"), "foobar");
+        Ok(())
+    }
+
+    #[test]
+    fn test_remove_line_break() -> Result<(), Box<dyn std::error::Error>> {
+        assert_eq!(remove_line_break("foo  bar"), "foo  bar");
+        assert_eq!(remove_line_break("foo \n bar"), "foo  bar");
+        Ok(())
+    }
 }