Derive Default for Syntax{Node,Element}Children

Author: antonylsg

src/api.rs

@@ -431,7 +431,7 @@ impl<L: Language> SyntaxElement<L> {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct SyntaxNodeChildren<L: Language> {
     raw: cursor::SyntaxNodeChildren,
     _p: PhantomData<L>,
@@ -450,7 +450,7 @@ impl<L: Language> SyntaxNodeChildren<L> {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct SyntaxElementChildren<L: Language> {
     raw: cursor::SyntaxElementChildren,
     _p: PhantomData<L>,

src/cursor.rs

@@ -1353,47 +1353,32 @@ impl From<SyntaxToken> for SyntaxElement {
 
 // region: iterators
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct SyntaxNodeChildren {
-    parent: SyntaxNode,
     next: Option<SyntaxNode>,
-    next_initialized: bool,
 }
 
 impl SyntaxNodeChildren {
     fn new(parent: SyntaxNode) -> SyntaxNodeChildren {
-        SyntaxNodeChildren { parent, next: None, next_initialized: false }
+        SyntaxNodeChildren { next: parent.first_child() }
     }
 
     pub fn by_kind<F: Fn(SyntaxKind) -> bool>(self, matcher: F) -> SyntaxNodeChildrenByKind<F> {
-        if !self.next_initialized {
-            SyntaxNodeChildrenByKind { next: self.parent.first_child_by_kind(&matcher), matcher }
-        } else {
-            SyntaxNodeChildrenByKind {
-                next: self.next.and_then(|node| {
-                    if matcher(node.kind()) {
-                        Some(node)
-                    } else {
-                        node.next_sibling_by_kind(&matcher)
-                    }
-                }),
-                matcher,
-            }
+        SyntaxNodeChildrenByKind {
+            next: self.next.and_then(|node| {
+                if matcher(node.kind()) { Some(node) } else { node.next_sibling_by_kind(&matcher) }
+            }),
+            matcher,
         }
     }
 }
 
 impl Iterator for SyntaxNodeChildren {
     type Item = SyntaxNode;
     fn next(&mut self) -> Option<SyntaxNode> {
-        if !self.next_initialized {
-            self.next = self.parent.first_child();
-            self.next_initialized = true;
-        } else {
-            self.next = self.next.take().and_then(|next| next.to_next_sibling());
-        }
-
-        self.next.clone()
+        let curr = self.next.take()?;
+        self.next = curr.next_sibling();
+        Some(curr)
     }
 }
 
@@ -1406,56 +1391,42 @@ pub struct SyntaxNodeChildrenByKind<F: Fn(SyntaxKind) -> bool> {
 impl<F: Fn(SyntaxKind) -> bool> Iterator for SyntaxNodeChildrenByKind<F> {
     type Item = SyntaxNode;
     fn next(&mut self) -> Option<SyntaxNode> {
-        self.next.take().inspect(|next| {
-            self.next = next.next_sibling_by_kind(&self.matcher);
-        })
+        let curr = self.next.take()?;
+        self.next = curr.next_sibling_by_kind(&self.matcher);
+        Some(curr)
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct SyntaxElementChildren {
-    parent: SyntaxNode,
     next: Option<SyntaxElement>,
-    next_initialized: bool,
 }
 
 impl SyntaxElementChildren {
     fn new(parent: SyntaxNode) -> SyntaxElementChildren {
-        SyntaxElementChildren { parent, next: None, next_initialized: false }
+        SyntaxElementChildren { next: parent.first_child_or_token() }
     }
 
     pub fn by_kind<F: Fn(SyntaxKind) -> bool>(self, matcher: F) -> SyntaxElementChildrenByKind<F> {
-        if !self.next_initialized {
-            SyntaxElementChildrenByKind {
-                next: self.parent.first_child_or_token_by_kind(&matcher),
-                matcher,
-            }
-        } else {
-            SyntaxElementChildrenByKind {
-                next: self.next.and_then(|node| {
-                    if matcher(node.kind()) {
-                        Some(node)
-                    } else {
-                        node.next_sibling_or_token_by_kind(&matcher)
-                    }
-                }),
-                matcher,
-            }
+        SyntaxElementChildrenByKind {
+            next: self.next.and_then(|node| {
+                if matcher(node.kind()) {
+                    Some(node)
+                } else {
+                    node.next_sibling_or_token_by_kind(&matcher)
+                }
+            }),
+            matcher,
         }
     }
 }
 
 impl Iterator for SyntaxElementChildren {
     type Item = SyntaxElement;
     fn next(&mut self) -> Option<SyntaxElement> {
-        if !self.next_initialized {
-            self.next = self.parent.first_child_or_token();
-            self.next_initialized = true;
-        } else {
-            self.next = self.next.take().and_then(|next| next.to_next_sibling_or_token());
-        }
-
-        self.next.clone()
+        let curr = self.next.take()?;
+        self.next = curr.next_sibling_or_token();
+        Some(curr)
     }
 }
 
@@ -1468,9 +1439,9 @@ pub struct SyntaxElementChildrenByKind<F: Fn(SyntaxKind) -> bool> {
 impl<F: Fn(SyntaxKind) -> bool> Iterator for SyntaxElementChildrenByKind<F> {
     type Item = SyntaxElement;
     fn next(&mut self) -> Option<SyntaxElement> {
-        self.next.take().inspect(|next| {
-            self.next = next.next_sibling_or_token_by_kind(&self.matcher);
-        })
+        let curr = self.next.take()?;
+        self.next = curr.next_sibling_or_token_by_kind(&self.matcher);
+        Some(curr)
     }
 }