From 6b8e95a2bc0b93d597d92efff0b2bf7a3a7a782d Mon Sep 17 00:00:00 2001
From: Jason Lee <huacnlee@gmail.com>
Date: Tue, 27 Dec 2022 22:41:48 +0800
Subject: [PATCH] Fix flat_pairs and pairs.next_back to use position.line_col

---
 pest/src/iterators/flat_pairs.rs | 54 +++++++++++++-------------------
 pest/src/iterators/pair.rs       | 14 ++++-----
 pest/src/iterators/pairs.rs      | 13 ++------
 3 files changed, 32 insertions(+), 49 deletions(-)

diff --git a/pest/src/iterators/flat_pairs.rs b/pest/src/iterators/flat_pairs.rs
index d268eadd..5c132e6e 100644
--- a/pest/src/iterators/flat_pairs.rs
+++ b/pest/src/iterators/flat_pairs.rs
@@ -12,7 +12,6 @@ use alloc::vec::Vec;
 use core::fmt;
 
 use super::pair::{self, Pair};
-use super::pairs::{Cursor, CursorPairs};
 use super::queueable_token::QueueableToken;
 use super::tokens::{self, Tokens};
 use crate::RuleType;
@@ -29,7 +28,6 @@ pub struct FlatPairs<'i, R> {
     input: &'i str,
     start: usize,
     end: usize,
-    cursor: Cursor,
 }
 
 /// # Safety
@@ -46,7 +44,6 @@ pub unsafe fn new<R: RuleType>(
         input,
         start,
         end,
-        cursor: Cursor::default(),
     }
 }
 
@@ -110,16 +107,7 @@ impl<'i, R: RuleType> Iterator for FlatPairs<'i, R> {
             return None;
         }
 
-        let pair = unsafe {
-            pair::new(
-                Rc::clone(&self.queue),
-                self.input,
-                self.start,
-                self.cursor.clone(),
-            )
-        };
-        self.move_cursor(pair.as_str());
-
+        let pair = unsafe { pair::new(Rc::clone(&self.queue), self.input, self.start, None) };
         self.next_start();
 
         Some(pair)
@@ -134,14 +122,7 @@ impl<'i, R: RuleType> DoubleEndedIterator for FlatPairs<'i, R> {
 
         self.next_start_from_end();
 
-        let pair = unsafe {
-            pair::new(
-                Rc::clone(&self.queue),
-                self.input,
-                self.end,
-                self.cursor.clone(),
-            )
-        };
+        let pair = unsafe { pair::new(Rc::clone(&self.queue), self.input, self.end, None) };
 
         Some(pair)
     }
@@ -162,21 +143,10 @@ impl<'i, R: Clone> Clone for FlatPairs<'i, R> {
             input: self.input,
             start: self.start,
             end: self.end,
-            cursor: self.cursor.clone(),
         }
     }
 }
 
-impl<'i, R: RuleType> CursorPairs for FlatPairs<'i, R> {
-    fn cursor(&self) -> Cursor {
-        self.cursor.clone()
-    }
-
-    fn cursor_mut(&mut self) -> &mut Cursor {
-        &mut self.cursor
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::super::super::macros::tests::*;
@@ -206,4 +176,24 @@ mod tests {
             vec![Rule::c, Rule::b, Rule::a]
         );
     }
+
+    #[test]
+    fn test_line_col() {
+        let mut pairs = AbcParser::parse(Rule::a, "abcNe\nabcde").unwrap().flatten();
+
+        let pair = pairs.next().unwrap();
+        assert_eq!(pair.as_str(), "abc");
+        assert_eq!(pair.line_col(), (1, 1));
+        assert_eq!(pair.line_col(), pair.as_span().start_pos().line_col());
+
+        let pair = pairs.next().unwrap();
+        assert_eq!(pair.as_str(), "b");
+        assert_eq!(pair.line_col(), (1, 2));
+        assert_eq!(pair.line_col(), pair.as_span().start_pos().line_col());
+
+        let pair = pairs.next().unwrap();
+        assert_eq!(pair.as_str(), "e");
+        assert_eq!(pair.line_col(), (1, 5));
+        assert_eq!(pair.line_col(), pair.as_span().start_pos().line_col());
+    }
 }
diff --git a/pest/src/iterators/pair.rs b/pest/src/iterators/pair.rs
index 557794e1..0dc95027 100644
--- a/pest/src/iterators/pair.rs
+++ b/pest/src/iterators/pair.rs
@@ -43,9 +43,7 @@ pub struct Pair<'i, R> {
     input: &'i str,
     /// Token index into `queue`.
     start: usize,
-
-    line: usize,
-    col: usize,
+    cursor: Option<Cursor>,
 }
 
 /// # Safety
@@ -55,14 +53,13 @@ pub unsafe fn new<R: RuleType>(
     queue: Rc<Vec<QueueableToken<R>>>,
     input: &str,
     start: usize,
-    cursor: Cursor,
+    cursor: Option<Cursor>,
 ) -> Pair<'_, R> {
     Pair {
         queue,
         input,
         start,
-        line: cursor.line,
-        col: cursor.col,
+        cursor,
     }
 }
 
@@ -249,7 +246,10 @@ impl<'i, R: RuleType> Pair<'i, R> {
 
     /// Returns the `line`, `col` of this pair start.
     pub fn line_col(&self) -> (usize, usize) {
-        (self.line, self.col)
+        match &self.cursor {
+            Some(cursor) => (cursor.line, cursor.col),
+            None => self.as_span().start_pos().line_col(),
+        }
     }
 
     fn pair(&self) -> usize {
diff --git a/pest/src/iterators/pairs.rs b/pest/src/iterators/pairs.rs
index 30eec02e..eed6e9b9 100644
--- a/pest/src/iterators/pairs.rs
+++ b/pest/src/iterators/pairs.rs
@@ -38,7 +38,7 @@ impl Default for Cursor {
 }
 
 impl Cursor {
-    fn get(&self) -> (usize, usize) {
+    pub(crate) fn get(&self) -> (usize, usize) {
         (self.line, self.col)
     }
 }
@@ -264,7 +264,7 @@ impl<'i, R: RuleType> Pairs<'i, R> {
                     Rc::clone(&self.queue),
                     self.input,
                     self.start,
-                    self.cursor.clone(),
+                    Some(self.cursor.clone()),
                 )
             })
         } else {
@@ -335,14 +335,7 @@ impl<'i, R: RuleType> DoubleEndedIterator for Pairs<'i, R> {
 
         self.end = self.pair_from_end();
 
-        let pair = unsafe {
-            pair::new(
-                Rc::clone(&self.queue),
-                self.input,
-                self.end,
-                self.cursor.clone(),
-            )
-        };
+        let pair = unsafe { pair::new(Rc::clone(&self.queue), self.input, self.end, None) };
 
         Some(pair)
     }