Add affiliated keyword matching to the detect_* functions.

src/parser/diary_sexp.rs

@@ -20,8 +20,7 @@ pub(crate) fn diary_sexp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, DiarySexp<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     let (remaining, _clock) = tag("%%(")(input)?;
     let (remaining, _contents) = is_not("\r\n")(remaining)?;
@@ -39,6 +38,7 @@ pub(crate) fn diary_sexp<'b, 'g, 'r, 's>(
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn detect_diary_sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+    let (input, _) = many0(affiliated_keyword)(input)?;
     tuple((start_of_line, tag("%%(")))(input)?;
     Ok((input, ()))
 }

src/parser/drawer.rs

@@ -43,8 +43,7 @@ pub(crate) fn drawer<'b, 'g, 'r, 's>(
             "Cannot nest objects of the same element".into(),
         ))));
     }
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     let (remaining, _leading_whitespace) = space0(input)?;
     let (remaining, (_open_colon, drawer_name, _close_colon, _new_line)) = tuple((

src/parser/dynamic_block.rs

@@ -48,8 +48,7 @@ pub(crate) fn dynamic_block<'b, 'g, 'r, 's>(
             "Cannot nest objects of the same element".into(),
         ))));
     }
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
 
     start_of_line(input)?;
     let (remaining, _leading_whitespace) = space0(input)?;

src/parser/element_parser.rs

@@ -71,7 +71,6 @@ fn _element<'b, 'g, 'r, 's>(
     let fixed_width_area_matcher = parser_with_context!(fixed_width_area)(context);
     let horizontal_rule_matcher = parser_with_context!(horizontal_rule)(context);
     let keyword_matcher = parser_with_context!(keyword)(context);
-    let affiliated_keyword_matcher = parser_with_context!(affiliated_keyword)(context);
     let babel_keyword_matcher = parser_with_context!(babel_call_keyword)(context);
     let paragraph_matcher = parser_with_context!(paragraph)(context);
     let latex_environment_matcher = parser_with_context!(latex_environment)(context);
@@ -105,11 +104,11 @@ fn _element<'b, 'g, 'r, 's>(
                     the_ok @ Ok(_) => the_ok,
                     Err(_) => {
                         // TODO: Because this function expects a single element, if there are multiple affiliated keywords before an element that cannot have affiliated keywords, we end up re-parsing the affiliated keywords many times.
-                        map(affiliated_keyword_matcher, Element::Keyword)(input)
+                        map(affiliated_keyword, Element::Keyword)(input)
                     }
                 }
             } else {
-                map(affiliated_keyword_matcher, Element::Keyword)(input)
+                map(affiliated_keyword, Element::Keyword)(input)
             }
         }
     }?;

src/parser/fixed_width_area.rs

@@ -27,8 +27,7 @@ pub(crate) fn fixed_width_area<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, FixedWidthArea<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     let fixed_width_area_line_matcher = parser_with_context!(fixed_width_area_line)(context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(context);
     let (remaining, _first_line) = fixed_width_area_line_matcher(input)?;
@@ -63,6 +62,7 @@ fn fixed_width_area_line<'b, 'g, 'r, 's>(
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn detect_fixed_width_area<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+    let (input, _) = many0(affiliated_keyword)(input)?;
     tuple((
         start_of_line,
         space0,

src/parser/footnote_definition.rs

@@ -42,8 +42,7 @@ pub(crate) fn footnote_definition<'b, 'g, 'r, 's>(
             "Cannot nest objects of the same element".into(),
         ))));
     }
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     // Cannot be indented.
     let (remaining, (_, lbl, _, _, _)) = tuple((
@@ -123,6 +122,7 @@ fn footnote_definition_end<'b, 'g, 'r, 's>(
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn detect_footnote_definition<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+    let (input, _) = many0(affiliated_keyword)(input)?;
     tuple((start_of_line, tag_no_case("[fn:"), label, tag("]")))(input)?;
     Ok((input, ()))
 }

src/parser/greater_block.rs

@@ -46,8 +46,7 @@ pub(crate) fn greater_block<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Element<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     let (remaining, _leading_whitespace) = space0(input)?;
     let (remaining, (_begin, name)) = tuple((

src/parser/horizontal_rule.rs

@@ -22,8 +22,7 @@ pub(crate) fn horizontal_rule<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, HorizontalRule<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     let (remaining, rule) = recognize(tuple((
         space0,

src/parser/keyword.rs

@@ -93,16 +93,12 @@ pub(crate) fn keyword<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Keyword<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     filtered_keyword(regular_keyword_key)(input)
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub(crate) fn affiliated_keyword<'b, 'g, 'r, 's>(
-    _context: RefContext<'b, 'g, 'r, 's>,
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, Keyword<'s>> {
+pub(crate) fn affiliated_keyword<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Keyword<'s>> {
     filtered_keyword(affiliated_key)(input)
 }
 
@@ -111,8 +107,7 @@ pub(crate) fn babel_call_keyword<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, BabelCall<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     let (remaining, kw) = filtered_keyword(babel_call_key)(input)?;
     Ok((
         remaining,

src/parser/latex_environment.rs

@@ -31,8 +31,7 @@ pub(crate) fn latex_environment<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, LatexEnvironment<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     let (remaining, _leading_whitespace) = space0(input)?;
     let (remaining, (_opening, name, _open_close_brace, _ws, _line_ending)) = tuple((

src/parser/paragraph.rs

@@ -28,8 +28,7 @@ pub(crate) fn paragraph<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Paragraph<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
 
     let parser_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
         class: ExitClass::Gamma,

src/parser/plain_list.rs

@@ -54,6 +54,7 @@ pub(crate) fn detect_plain_list<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
+    let (input, _) = many0(affiliated_keyword)(input)?;
     if verify(
         tuple((
             start_of_line,
@@ -79,8 +80,7 @@ pub(crate) fn plain_list<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PlainList<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
 
     let contexts = [
         ContextElement::Context("plain list"),

src/parser/table.rs

@@ -39,8 +39,7 @@ pub(crate) fn org_mode_table<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Table<'s>> {
-    let (input, affiliated_keywords) =
-        many0(parser_with_context!(affiliated_keyword)(context))(input)?;
+    let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     start_of_line(input)?;
     peek(tuple((space0, tag("|"))))(input)?;
 
@@ -80,6 +79,7 @@ pub(crate) fn org_mode_table<'b, 'g, 'r, 's>(
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn detect_table<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+    let (input, _) = many0(affiliated_keyword)(input)?;
     tuple((start_of_line, space0, tag("|")))(input)?;
     Ok((input, ()))
 }