Simplify node mode management

src/parse/mod.rs

@@ -772,6 +772,6 @@ fn comment(p: &mut Parser) -> ParseResult {
             p.eat();
             Ok(())
         }
-        _ => Err(()),
+        _ => Err(ParseError),
     }
 }

src/source.rs

@@ -286,22 +286,15 @@ impl SourceFile {
             .extend(newlines(&self.src[start ..]).map(|idx| start + idx));
 
         // Update the root node.
-        let insertion_span = Span::new(self.id, replace.start, replace.end);
-        let source = self.src().to_string();
-        if Rc::make_mut(&mut self.root).incremental(&source, insertion_span, with.len()) {
+        let span = Span::new(self.id, replace.start, replace.end);
+        if Rc::make_mut(&mut self.root).incremental(&self.src, span, with.len()) {
             self.was_incremental = true;
         } else {
-            self.root = parse(self.src());
+            self.root = parse(&self.src);
             self.was_incremental = false;
         }
     }
 
-    /// Forces a non-incremental reparsing of the source file.
-    fn force_reparse(&mut self) {
-        self.root = parse(self.src());
-        self.was_incremental = false;
-    }
-
     /// Provide highlighting categories for the given range of the source file.
     pub fn highlight<F>(&self, range: Range<usize>, mut f: F)
     where
@@ -499,8 +492,7 @@ mod tests {
             if incr {
                 assert!(source.was_incremental);
                 let incr_tree = source.root.clone();
-                source.force_reparse();
-                assert_eq!(source.root, incr_tree);
+                assert_eq!(parse(source.src()), incr_tree);
             } else {
                 assert!(!source.was_incremental);
             }

src/syntax/mod.rs

@@ -94,7 +94,7 @@ impl Green {
         replace: Span,
         replacement_len: usize,
         offset: usize,
-        parent_mode: NodeMode,
+        parent_mode: TokenMode,
         outermost: bool,
     ) -> bool {
         match self {
@@ -221,7 +221,7 @@ impl GreenNode {
             return false;
         }
 
-        self.incremental_int(src, replace, replacement_len, 0, NodeMode::Markup, true)
+        self.incremental_int(src, replace, replacement_len, 0, TokenMode::Markup, true)
     }
 
     fn incremental_int(
@@ -230,11 +230,11 @@ impl GreenNode {
         replace: Span,
         replacement_len: usize,
         mut offset: usize,
-        parent_mode: NodeMode,
+        parent_mode: TokenMode,
         outermost: bool,
     ) -> bool {
         let kind = self.kind().clone();
-        let mode = kind.mode().apply(parent_mode);
+        let mode = kind.mode().contextualize(parent_mode);
         eprintln!("in {:?} (mode {:?})", kind, mode);
 
         let mut loop_result = None;
@@ -266,15 +266,11 @@ impl GreenNode {
 
                 // This didn't work, so we try to replace the child at this
                 // level.
-                let (function, policy) = match child
-                    .kind()
-                    .reparsing_function(mode.child_mode().as_token_mode())
-                {
-                    Ok(p) => p,
-                    _ => {
-                        return false;
-                    }
-                };
+                let (function, policy) =
+                    match child.kind().reparsing_function(kind.mode().child_mode()) {
+                        Ok(p) => p,
+                        _ => return false,
+                    };
                 loop_result =
                     Some((i, child_span, i == last && outermost, function, policy));
                 break;
@@ -320,8 +316,7 @@ impl GreenNode {
             eprintln!("function failed");
             return false;
         };
-        let child_mode =
-            self.children[child_idx].kind().mode().child_mode().as_token_mode();
+        let child_mode = self.children[child_idx].kind().mode().child_mode();
         eprintln!("child mode {:?}", child_mode);
 
         // Check if the children / child has the right type.
@@ -365,7 +360,7 @@ impl GreenNode {
         }
 
         // Check if the neighbor invariants are still true.
-        if mode.as_token_mode() == TokenMode::Markup {
+        if mode == TokenMode::Markup {
             if child_idx > 0 {
                 if self.children[child_idx - 1].kind().incremental_safety()
                     == IncrementalSafety::EnsureRightWhitespace
@@ -1023,10 +1018,10 @@ impl NodeKind {
             return Err(policy);
         }
 
-        let mode = self.mode();
-        let is_code = mode == NodeMode::Universal && parent_mode == TokenMode::Code
-            || mode == NodeMode::Code;
-        if mode == NodeMode::Code && policy == IncrementalSafety::UnsafeLayer {
+        let contextualized = self.mode().contextualize(parent_mode);
+        let is_code = contextualized == TokenMode::Code;
+
+        if is_code && policy == IncrementalSafety::UnsafeLayer {
             return Err(policy);
         }
 
@@ -1047,12 +1042,9 @@ impl NodeKind {
             return Ok((parser, policy));
         }
 
-        let parser: fn(&str, bool) -> _ = match mode {
-            NodeMode::Markup if self == &Self::Markup => parse_markup,
-            NodeMode::Markup => parse_markup_elements,
-            NodeMode::Universal if parent_mode == TokenMode::Markup => {
-                parse_markup_elements
-            }
+        let parser: fn(&str, bool) -> _ = match contextualized {
+            TokenMode::Markup if self == &Self::Markup => parse_markup,
+            TokenMode::Markup => parse_markup_elements,
             _ => return Err(policy),
         };
 
@@ -1403,28 +1395,20 @@ pub enum NodeMode {
 
 impl NodeMode {
     /// Returns a new mode considering the parent node.
-    pub fn apply(&self, old: Self) -> Self {
+    pub fn contextualize(&self, old: TokenMode) -> TokenMode {
         match self {
-            Self::Markup => Self::Markup,
-            Self::Code => Self::Code,
-            Self::Universal if old != Self::Markup => Self::Code,
-            Self::Universal => Self::Universal,
-        }
-    }
-
-    /// Return the corresponding token mode.
-    pub fn as_token_mode(&self) -> TokenMode {
-        match self {
-            Self::Markup | Self::Universal => TokenMode::Markup,
+            Self::Markup => TokenMode::Markup,
             Self::Code => TokenMode::Code,
+            Self::Universal if old != TokenMode::Markup => TokenMode::Code,
+            Self::Universal => TokenMode::Markup,
         }
     }
 
     /// The mode of the children of this node.
-    pub fn child_mode(&self) -> Self {
+    pub fn child_mode(&self) -> TokenMode {
         match self {
-            Self::Markup => Self::Markup,
-            Self::Code | Self::Universal => Self::Code,
+            Self::Markup => TokenMode::Markup,
+            Self::Code | Self::Universal => TokenMode::Code,
         }
     }
 }