Merge pull request #301 from tree-sitter/clock-based-timeouts

Replace operation limit API with a clock-based timeout API

cli/src/tests/parser_test.rs

@@ -1,7 +1,7 @@
 use super::helpers::edits::{perform_edit, Edit, ReadRecorder};
 use super::helpers::fixtures::{get_language, get_test_language};
 use crate::generate::generate_parser_for_grammar;
-use std::{thread, usize};
+use std::{thread, time};
 use tree_sitter::{InputEdit, LogType, Parser, Point, Range};
 
 #[test]
@@ -269,84 +269,117 @@ fn test_parsing_on_multiple_threads() {
     assert_eq!(child_count_differences, &[1, 2, 3, 4]);
 }
 
-// Operation limits
+// Timeouts
 
 #[test]
-fn test_parsing_with_an_operation_limit() {
+fn test_parsing_with_a_timeout() {
     let mut parser = Parser::new();
     parser.set_language(get_language("json")).unwrap();
 
-    // Start parsing from an infinite input. Parsing should abort after 5 "operations".
-    parser.set_operation_limit(5);
-    let mut call_count = 0;
+    // Parse an infinitely-long array, but pause after 100 microseconds of processing.
+    parser.set_timeout_micros(100);
+    let start_time = time::Instant::now();
     let tree = parser.parse_with(
-        &mut |_, _| {
-            if call_count == 0 {
-                call_count += 1;
-                b"[0"
+        &mut |offset, _| {
+            if offset == 0 {
+                b" ["
             } else {
-                call_count += 1;
-                b", 0"
+                b",0"
             }
         },
         None,
     );
     assert!(tree.is_none());
-    assert!(call_count >= 3);
-    assert!(call_count <= 8);
+    assert!(start_time.elapsed().as_micros() < 500);
 
-    // Resume parsing from the previous state.
-    call_count = 0;
-    parser.set_operation_limit(20);
+    // Continue parsing, but pause after 300 microseconds of processing.
+    parser.set_timeout_micros(1000);
+    let start_time = time::Instant::now();
+    let tree = parser.parse_with(
+        &mut |offset, _| {
+            if offset == 0 {
+                b" ["
+            } else {
+                b",0"
+            }
+        },
+        None,
+    );
+    assert!(tree.is_none());
+    assert!(start_time.elapsed().as_micros() > 500);
+    assert!(start_time.elapsed().as_micros() < 1500);
+
+    // Finish parsing
+    parser.set_timeout_micros(0);
     let tree = parser
         .parse_with(
-            &mut |_, _| {
-                if call_count == 0 {
-                    call_count += 1;
+            &mut |offset, _| {
+                if offset > 5000 {
+                    b""
+                } else if offset == 5000 {
                     b"]"
                 } else {
-                    b""
+                    b",0"
                 }
             },
             None,
         )
         .unwrap();
-    assert_eq!(
-        tree.root_node().to_sexp(),
-        "(value (array (number) (number) (number)))"
-    );
+    assert_eq!(tree.root_node().child(0).unwrap().kind(), "array");
 }
 
 #[test]
-fn test_parsing_with_a_reset_after_reaching_an_operation_limit() {
+fn test_parsing_with_a_timeout_and_a_reset() {
     let mut parser = Parser::new();
     parser.set_language(get_language("json")).unwrap();
 
-    parser.set_operation_limit(3);
-    let tree = parser.parse("[1234, 5, 6, 7, 8]", None);
+    parser.set_timeout_micros(30);
+    let tree = parser.parse(
+        "[\"ok\", 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]",
+        None,
+    );
     assert!(tree.is_none());
 
     // Without calling reset, the parser continues from where it left off, so
     // it does not see the changes to the beginning of the source code.
-    parser.set_operation_limit(usize::MAX);
-    let tree = parser.parse("[null, 5, 6, 4, 5]", None).unwrap();
+    parser.set_timeout_micros(0);
+    let tree = parser.parse(
+        "[null, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]",
+        None,
+    ).unwrap();
     assert_eq!(
-        tree.root_node().to_sexp(),
-        "(value (array (number) (number) (number) (number) (number)))"
+        tree.root_node()
+            .named_child(0)
+            .unwrap()
+            .named_child(0)
+            .unwrap()
+            .kind(),
+        "string"
     );
 
-    parser.set_operation_limit(3);
-    let tree = parser.parse("[1234, 5, 6, 7, 8]", None);
+    parser.set_timeout_micros(30);
+    let tree = parser.parse(
+        "[\"ok\", 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]",
+        None,
+    );
     assert!(tree.is_none());
 
     // By calling reset, we force the parser to start over from scratch so
     // that it sees the changes to the beginning of the source code.
-    parser.set_operation_limit(usize::MAX);
+    parser.set_timeout_micros(0);
     parser.reset();
-    let tree = parser.parse("[null, 5, 6, 4, 5]", None).unwrap();
+    let tree = parser.parse(
+        "[null, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]",
+        None,
+    ).unwrap();
     assert_eq!(
-        tree.root_node().to_sexp(),
-        "(value (array (null) (number) (number) (number) (number)))"
+        tree.root_node()
+            .named_child(0)
+            .unwrap()
+            .named_child(0)
+            .unwrap()
+            .kind(),
+        "null"
     );
 }