Rename template to content

2 files changed, 19 insertions, 30 deletions

diff --git a/src/parse/incremental.rs b/src/parse/incremental.rs
index 759b3a68..468f344e 100644
--- a/src/parse/incremental.rs
+++ b/src/parse/incremental.rs
@@ -4,8 +4,7 @@ use std::sync::Arc;
 use crate::syntax::{Green, GreenNode, NodeKind};
 
 use super::{
-    is_newline, parse, reparse_block, reparse_markup_elements, reparse_template,
-    TokenMode,
+    is_newline, parse, reparse_block, reparse_content, reparse_markup_elements, TokenMode,
 };
 
 /// Allows partial refreshs of the [`Green`] node tree.
@@ -43,7 +42,7 @@ impl Reparser<'_> {
         mut offset: usize,
         outermost: bool,
     ) -> Option<Range<usize>> {
-        let child_mode = green.kind().mode().unwrap_or(TokenMode::Code);
+        let child_mode = green.kind().only_in_mode().unwrap_or(TokenMode::Code);
         let original_count = green.children().len();
 
         let mut search = SearchState::default();
@@ -137,7 +136,7 @@ impl Reparser<'_> {
             let superseded_span = pos.offset .. pos.offset + prev_len;
             let func: Option<ReparseMode> = match child.kind() {
                 NodeKind::CodeBlock => Some(ReparseMode::Code),
-                NodeKind::TemplateBlock => Some(ReparseMode::Template),
+                NodeKind::ContentBlock => Some(ReparseMode::Content),
                 _ => None,
             };
 
@@ -168,7 +167,7 @@ impl Reparser<'_> {
 
             if start.offset == self.replace_range.start
                 || ahead_kind.only_at_start()
-                || ahead_kind.mode() != Some(TokenMode::Markup)
+                || ahead_kind.only_in_mode() != Some(TokenMode::Markup)
             {
                 start = ahead;
                 at_start = ahead_at_start;
@@ -216,7 +215,7 @@ impl Reparser<'_> {
                 &self.src[newborn_span.start ..],
                 newborn_span.len(),
             ),
-            ReparseMode::Template => reparse_template(
+            ReparseMode::Content => reparse_content(
                 &prefix,
                 &self.src[newborn_span.start ..],
                 newborn_span.len(),
@@ -294,23 +293,13 @@ impl SearchState {
 enum ReparseMode {
     /// Reparse a code block, including its braces.
     Code,
-    /// Reparse a template block, including its square brackets.
-    Template,
+    /// Reparse a content block, including its square brackets.
+    Content,
     /// Reparse elements of the markup. The variant carries whether the node is
     /// `at_start` and the minimum indent of the containing markup node.
     MarkupElements(bool, usize),
 }
 
-impl NodeKind {
-    /// Whether this node has to appear at the start of a line.
-    pub fn only_at_start(&self) -> bool {
-        match self {
-            Self::Heading | Self::Enum | Self::List => true,
-            _ => false,
-        }
-    }
-}
-
 #[cfg(test)]
 #[rustfmt::skip]
 mod tests {
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 833a5b33..f07fefce 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -52,10 +52,10 @@ pub fn reparse_block(
     Some((vec![first], terminated, 1))
 }
 
-/// Reparse a template literal.
+/// Reparse a content block.
 ///
 /// Returns `Some` if all of the input was consumed.
-pub fn reparse_template(
+pub fn reparse_content(
     prefix: &str,
     src: &str,
     end_pos: usize,
@@ -65,7 +65,7 @@ pub fn reparse_template(
         return None;
     }
 
-    template(&mut p);
+    content(&mut p);
 
     let (mut green, terminated) = p.consume()?;
     let first = green.remove(0);
@@ -152,7 +152,7 @@ pub fn reparse_markup_elements(
 /// Parse markup.
 ///
 /// If `at_start` is true, things like headings that may only appear at the
-/// beginning of a line or template are initially allowed.
+/// beginning of a line or content block are initially allowed.
 fn markup(p: &mut Parser, mut at_start: bool) {
     p.perform(NodeKind::Markup(0), |p| {
         while !p.eof() {
@@ -235,9 +235,9 @@ fn markup_node(p: &mut Parser, at_start: &mut bool) {
         | NodeKind::Import
         | NodeKind::Include => markup_expr(p),
 
-        // Block and template.
+        // Code and content block.
         NodeKind::LeftBrace => block(p),
-        NodeKind::LeftBracket => template(p),
+        NodeKind::LeftBracket => content(p),
 
         NodeKind::Error(_, _) => p.eat(),
         _ => p.unexpected(),
@@ -424,7 +424,7 @@ fn primary(p: &mut Parser, atomic: bool) -> ParseResult {
         // Structures.
         Some(NodeKind::LeftParen) => parenthesized(p, atomic),
         Some(NodeKind::LeftBrace) => Ok(block(p)),
-        Some(NodeKind::LeftBracket) => Ok(template(p)),
+        Some(NodeKind::LeftBracket) => Ok(content(p)),
 
         // Keywords.
         Some(NodeKind::Let) => let_expr(p),
@@ -679,9 +679,9 @@ fn block(p: &mut Parser) {
     });
 }
 
-// Parse a template block: `[...]`.
-fn template(p: &mut Parser) {
-    p.perform(NodeKind::TemplateBlock, |p| {
+// Parse a content block: `[...]`.
+fn content(p: &mut Parser) {
+    p.perform(NodeKind::ContentBlock, |p| {
         p.start_group(Group::Bracket);
         markup(p, true);
         p.end_group();
@@ -712,7 +712,7 @@ fn args(p: &mut Parser, direct: bool, brackets: bool) -> ParseResult {
         }
 
         while brackets && p.peek_direct() == Some(&NodeKind::LeftBracket) {
-            template(p);
+            content(p);
         }
     });
 
@@ -922,7 +922,7 @@ fn return_expr(p: &mut Parser) -> ParseResult {
 /// Parse a control flow body.
 fn body(p: &mut Parser) -> ParseResult {
     match p.peek() {
-        Some(NodeKind::LeftBracket) => Ok(template(p)),
+        Some(NodeKind::LeftBracket) => Ok(content(p)),
         Some(NodeKind::LeftBrace) => Ok(block(p)),
         _ => {
             p.expected("body");