Adds flag to measure performance.

src/main.rs

@@ -11,9 +11,13 @@ struct Args {
     language: st::lang::Select,
     query: String,
     file: std::path::PathBuf,
+    #[arg(long)]
+    metrics: bool,
 }
 
 fn main() {
+    let timer = std::time::Instant::now();
+
     let args = Args::parse();
 
     let language = args.language.load();
@@ -24,6 +28,8 @@ fn main() {
     let document =
         st::document::new::<&str, Tree>(&text, Tree::new(&text, &language, Default::default()));
 
+    let parsing = timer.elapsed();
+
     for m in pattern.find_iter(document.walk()) {
         let start = m.start.node().start_position();
         let end = m.end.node().end_position();
@@ -38,4 +44,20 @@ fn main() {
             end.column + 1
         );
     }
+
+    let searching = timer.elapsed();
+
+    if args.metrics {
+        let (n, d) = document.dim();
+        let (k, h) = (pattern.len(), pattern.holes());
+        eprintln!(
+            "{},{},{},{},{:?},{:?}",
+            n, // tree size
+            d, // tree depth
+            k, // query length
+            h, // query hole count
+            parsing.as_millis(),
+            (searching - parsing).as_millis(),
+        );
+    }
 }

src/pattern.rs

@@ -76,6 +76,17 @@ impl<T> Pattern<T> {
             None => Err(start),
         }
     }
+
+    pub fn len(&self) -> usize {
+        self.sequence.len()
+    }
+
+    pub fn holes(&self) -> usize {
+        self.sequence
+            .iter()
+            .filter(|t| matches!(t, Token::Subtree | Token::Siblings))
+            .count()
+    }
 }
 
 impl<T> FromIterator<Token<T>> for Pattern<T> {

src/tree.rs

@@ -8,6 +8,38 @@ pub trait Subtree {
 
     #[must_use]
     fn walk(self) -> Self::Cursor;
+
+    #[must_use]
+    fn dim(self) -> (usize, usize)
+    where
+        Self: Sized,
+    {
+        let (mut size, mut depth) = (1, 1);
+
+        let mut cursor = self.walk();
+        let mut level = 1;
+
+        loop {
+            while cursor.goto_first_child() {
+                size += 1;
+                level += 1;
+            }
+
+            depth = std::cmp::max(depth, level);
+
+            loop {
+                if cursor.goto_next_sibling() {
+                    size += 1;
+                    break;
+                } else if cursor.goto_parent() {
+                    level -= 1;
+                    continue;
+                }
+                assert_eq!(level, 1);
+                return  (size, depth)
+            }
+        }
+    }
 }
 
 pub trait Traverse {