5 files changed, 13 insertions, 15 deletions
diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
index 169b0276..d70c4ae4 100644
--- a/src/syntax/ast.rs
+++ b/src/syntax/ast.rs
@@ -720,7 +720,7 @@ impl Ident {
         self.0.text().trim_start_matches('#')
     }
 
-    /// Take out the container identifier.
+    /// Take out the contained identifier.
     pub fn take(self) -> EcoString {
         let text = self.0.into_text();
         match text.strip_prefix('#') {
diff --git a/src/syntax/node.rs b/src/syntax/node.rs
index 3465f73f..038d13bc 100644
--- a/src/syntax/node.rs
+++ b/src/syntax/node.rs
@@ -861,14 +861,12 @@ mod tests {
         // Find "text".
         let node = LinkedNode::new(source.root()).leaf_at(7).unwrap();
         assert_eq!(node.offset(), 5);
-        assert_eq!(node.len(), 4);
-        assert_eq!(node.kind(), SyntaxKind::Ident);
+        assert_eq!(node.text(), "text");
 
         // Go back to "#set". Skips the space.
         let prev = node.prev_sibling().unwrap();
         assert_eq!(prev.offset(), 0);
-        assert_eq!(prev.len(), 4);
-        assert_eq!(prev.kind(), SyntaxKind::Set);
+        assert_eq!(prev.text(), "#set");
     }
 
     #[test]
@@ -876,15 +874,15 @@ mod tests {
         let source = Source::detached("#set fun(12pt, red)");
         let leaf = LinkedNode::new(source.root()).leaf_at(6).unwrap();
         let prev = leaf.prev_leaf().unwrap();
-        assert_eq!(leaf.kind(), SyntaxKind::Ident);
-        assert_eq!(prev.kind(), SyntaxKind::Set);
+        assert_eq!(leaf.text(), "fun");
+        assert_eq!(prev.text(), "#set");
 
         let source = Source::detached("#let x = 10");
         let leaf = LinkedNode::new(source.root()).leaf_at(9).unwrap();
         let prev = leaf.prev_leaf().unwrap();
         let next = leaf.next_leaf().unwrap();
-        assert_eq!(prev.kind(), SyntaxKind::Eq);
-        assert_eq!(leaf.kind(), SyntaxKind::Space);
-        assert_eq!(next.kind(), SyntaxKind::Int);
+        assert_eq!(prev.text(), "=");
+        assert_eq!(leaf.text(), " ");
+        assert_eq!(next.text(), "10");
     }
 }
diff --git a/src/syntax/parser.rs b/src/syntax/parser.rs
index 0e1b52b1..a379500c 100644
--- a/src/syntax/parser.rs
+++ b/src/syntax/parser.rs
@@ -54,7 +54,7 @@ pub(super) fn reparse_markup(
     at_start: &mut bool,
     mut stop: impl FnMut(SyntaxKind) -> bool,
 ) -> Option<Vec<SyntaxNode>> {
-    let mut p = Parser::new(&text, range.start, LexMode::Markup);
+    let mut p = Parser::new(text, range.start, LexMode::Markup);
     while !p.eof() && !stop(p.current) && p.current_start() < range.end {
         if p.newline() {
             *at_start = true;
@@ -512,7 +512,7 @@ fn block(p: &mut Parser) {
 }
 
 pub(super) fn reparse_block(text: &str, range: Range<usize>) -> Option<SyntaxNode> {
-    let mut p = Parser::new(&text, range.start, LexMode::Code);
+    let mut p = Parser::new(text, range.start, LexMode::Code);
     assert!(p.at(SyntaxKind::LeftBracket) || p.at(SyntaxKind::LeftBrace));
     block(&mut p);
     (p.balanced && p.prev_end() == range.end)
@@ -630,7 +630,7 @@ fn item(p: &mut Parser, keyed: bool) -> SyntaxKind {
         Some(SyntaxKind::Ident) => SyntaxKind::Named,
         Some(SyntaxKind::Str) if keyed => SyntaxKind::Keyed,
         _ => {
-            for child in p.post_process(m).next() {
+            for child in p.post_process(m) {
                 if child.kind() == SyntaxKind::Colon {
                     break;
                 }
diff --git a/src/syntax/reparser.rs b/src/syntax/reparser.rs
index 9404055d..40ac2422 100644
--- a/src/syntax/reparser.rs
+++ b/src/syntax/reparser.rs
@@ -96,7 +96,7 @@ fn try_reparse(
     // contained in things like headings or lists because too much can go wrong
     // with indent and line breaks.
     if node.kind() == SyntaxKind::Markup
-        && (parent_kind == None || parent_kind == Some(SyntaxKind::ContentBlock))
+        && (parent_kind.is_none() || parent_kind == Some(SyntaxKind::ContentBlock))
         && !overlap.is_empty()
     {
         // Add one node of slack in both directions.
diff --git a/src/syntax/source.rs b/src/syntax/source.rs
index 472e8c6c..63509dc8 100644
--- a/src/syntax/source.rs
+++ b/src/syntax/source.rs
@@ -291,7 +291,7 @@ struct Line {
 /// Create a line vector.
 fn lines(text: &str) -> Vec<Line> {
     std::iter::once(Line { byte_idx: 0, utf16_idx: 0 })
-        .chain(lines_from(0, 0, &text))
+        .chain(lines_from(0, 0, text))
         .collect()
 }