Merge pull request #162 from tree-sitter/upgrade-tree-sitter

Upgrade tree sitter

CHANGELOG.md

···
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.12.0 -- 2024-12-12
+
+Upgraded the `tree-sitter` dependency to version 0.24.
+
 ## v0.11.3 -- 2024-05-29
 
 ### Library

Cargo.toml

···
 [package]
 name = "tree-sitter-graph"
-version = "0.11.3"
+version = "0.12.0"
 description = "Construct graphs from parsed source code"
 homepage = "https://github.com/tree-sitter/tree-sitter-graph/"
 repository = "https://github.com/tree-sitter/tree-sitter-graph/"
···
 serde = "1.0"
 serde_json = "1.0"
 smallvec = { version="1.6", features=["union"] }
-string-interner = { version = "0.12", default-features = false, features = ["std", "inline-more", "backends"] }
+streaming-iterator = "0.1.9"
 thiserror = "1.0.7"
-tree-sitter = "0.20.3"
-tree-sitter-config = { version = "0.19", optional = true }
-tree-sitter-loader = { version = "0.20", optional = true }
+tree-sitter = "0.24"
+tree-sitter-config = { version = "0.24", optional = true }
+tree-sitter-loader = { version = "0.24", optional = true }
 
 [dev-dependencies]
 env_logger = "0.9"
 indoc = "1.0"
-tree-sitter-python = "0.20"
+tree-sitter-python = "=0.23.5"

README.md

···
 
 ``` toml
 [dependencies]
-tree-sitter-graph = "0.11"
+tree-sitter-graph = "0.12"
 ```
 
 To use it as a program, install it via `cargo install`:

src/bin/tree-sitter-graph/main.rs

···
         )?;
     }
 
-    let config = Config::load()?;
+    let config = Config::load(None)?;
     let mut loader = Loader::new()?;
     let loader_config = config.get()?;
     loader.find_all_languages(&loader_config)?;
···
     let tsg = std::fs::read(tsg_path)
         .with_context(|| format!("Cannot read TSG file {}", tsg_path.display()))?;
     let tsg = String::from_utf8(tsg)?;
-    let file = match File::from_str(language, &tsg) {
+    let file = match File::from_str(language.clone(), &tsg) {
         Ok(file) => file,
         Err(err) => {
             eprintln!("{}", err.display_pretty(tsg_path, &tsg));
···
         .with_context(|| format!("Cannot read source file {}", source_path.display()))?;
     let source = String::from_utf8(source)?;
     let mut parser = Parser::new();
-    parser.set_language(language)?;
+    parser.set_language(&language)?;
     let tree = parser
         .parse(&source, None)
         .ok_or_else(|| anyhow!("Cannot parse {}", source_path.display()))?;

src/checker.rs

···
                     .expect("capture should have index")
                     != self.full_match_stanza_capture_index as u32
             })
-            .map(|cn| Identifier::from(cn.as_str()))
+            .map(|cn| Identifier::from(*cn))
             .collect::<HashSet<_>>();
         let unused_captures = all_captures
             .difference(&used_captures)

src/execution.rs

···
                     .iter()
                     .map(|name| {
                         let index = file_query
-                            .capture_index_for_name(name)
+                            .capture_index_for_name(*name)
                             .expect("missing index for capture");
                         let quantifier =
                             file_query.capture_quantifiers(mat.pattern_index)[index as usize];
-                        (name, quantifier, index)
+                        (*name, quantifier, index)
                     })
                     .filter(|c| c.2 != stanza.full_match_file_capture_index as u32)
                     .collect();
···
                     .map(|name| {
                         let index = stanza
                             .query
-                            .capture_index_for_name(name)
+                            .capture_index_for_name(*name)
                             .expect("missing index for capture");
                         let quantifier = stanza.query.capture_quantifiers(0)[index as usize];
-                        (name, quantifier, index)
+                        (*name, quantifier, index)
                     })
                     .filter(|c| c.2 != stanza.full_match_stanza_capture_index as u32)
                     .collect();
···
                 .map(|name| {
                     let index = self
                         .query
-                        .capture_index_for_name(name)
+                        .capture_index_for_name(*name)
                         .expect("missing index for capture");
                     let quantifier = self.query.capture_quantifiers(0)[index as usize];
-                    (name, quantifier, index)
+                    (*name, quantifier, index)
                 })
                 .filter(|c| c.2 != self.full_match_stanza_capture_index as u32)
                 .collect();
···
 }
 
 pub struct Match<'a, 'tree> {
-    mat: QueryMatch<'a, 'tree>,
+    mat: &'a QueryMatch<'a, 'tree>,
     full_capture_index: u32,
-    named_captures: Vec<(&'a String, CaptureQuantifier, u32)>,
+    named_captures: Vec<(&'a str, CaptureQuantifier, u32)>,
     query_location: Location,
 }
 
···
         &'s self,
     ) -> impl Iterator<
         Item = (
-            &String,
+            &'a str,
             CaptureQuantifier,
             impl Iterator<Item = Node<'tree>> + 's,
         ),
···
     }
 
     /// Return an iterator over all capture names.
-    pub fn capture_names(&self) -> impl Iterator<Item = &String> {
+    pub fn capture_names(&self) -> impl Iterator<Item = &str> {
         self.named_captures.iter().map(|c| c.0)
     }
 

src/execution/lazy.rs

···
 use tree_sitter::QueryMatch;
 use tree_sitter::Tree;
 
+use streaming_iterator::StreamingIterator;
+
 use crate::ast;
 use crate::execution::error::ExecutionError;
 use crate::execution::error::ResultWithExecutionError;
···
         mut visit: F,
     ) -> Result<(), E>
     where
-        F: FnMut(&ast::Stanza, QueryMatch<'_, 'tree>) -> Result<(), E>,
+        F: FnMut(&ast::Stanza, &QueryMatch<'_, 'tree>) -> Result<(), E>,
     {
         let mut cursor = QueryCursor::new();
         let query = self.query.as_ref().unwrap();
-        let matches = cursor.matches(query, tree.root_node(), source.as_bytes());
-        for mat in matches {
+        let mut matches = cursor.matches(query, tree.root_node(), source.as_bytes());
+        while let Some(mat) = matches.next() {
             let stanza = &self.stanzas[mat.pattern_index];
             visit(stanza, mat)?;
         }

src/execution/strict.rs

···
 use std::collections::BTreeSet;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use streaming_iterator::StreamingIterator;
 use tree_sitter::QueryCursor;
 use tree_sitter::QueryMatch;
 use tree_sitter::Tree;
···
         mut visit: F,
     ) -> Result<(), E>
     where
-        F: FnMut(&Stanza, QueryMatch<'_, 'tree>) -> Result<(), E>,
+        F: FnMut(&Stanza, &QueryMatch<'_, 'tree>) -> Result<(), E>,
     {
         for stanza in &self.stanzas {
             stanza.try_visit_matches_strict(tree, source, |mat| visit(stanza, mat))?;
···
         mut visit: F,
     ) -> Result<(), E>
     where
-        F: FnMut(QueryMatch<'_, 'tree>) -> Result<(), E>,
+        F: FnMut(&QueryMatch<'_, 'tree>) -> Result<(), E>,
     {
         let mut cursor = QueryCursor::new();
-        let matches = cursor.matches(&self.query, tree.root_node(), source.as_bytes());
-        for mat in matches {
+        let mut matches = cursor.matches(&self.query, tree.root_node(), source.as_bytes());
+        while let Some(mat) = matches.next() {
             visit(mat)?;
         }
         Ok(())

src/parse_error.rs

···
     }
 
     /// Return all parse errors in the given tree.
-    pub fn all(tree: &'tree Tree) -> Vec<ParseError> {
+    pub fn all(tree: &'tree Tree) -> Vec<ParseError<'tree>> {
         let mut errors = Vec::new();
         find_errors(tree, &mut errors, false);
         errors

src/parser.rs

···
                 let name = self.parse_identifier("inherit")?;
                 file.inherited_variables.insert(name);
             } else {
-                let stanza = self.parse_stanza(file.language)?;
+                let stanza = self.parse_stanza(&file.language)?;
                 file.stanzas.push(stanza);
             }
             self.consume_whitespace();
         }
         // we can unwrap here because all queries have already been parsed before
-        file.query = Some(Query::new(file.language, &self.query_source).unwrap());
+        file.query = Some(Query::new(&file.language, &self.query_source).unwrap());
         Ok(())
     }
 
···
         Ok(quantifier)
     }
 
-    fn parse_stanza(&mut self, language: Language) -> Result<ast::Stanza, ParseError> {
+    fn parse_stanza(&mut self, language: &Language) -> Result<ast::Stanza, ParseError> {
         let start = self.location;
         let (query, full_match_stanza_capture_index) = self.parse_query(language)?;
         self.consume_whitespace();
···
         })
     }
 
-    fn parse_query(&mut self, language: Language) -> Result<(Query, usize), ParseError> {
+    fn parse_query(&mut self, language: &Language) -> Result<(Query, usize), ParseError> {
         let location = self.location;
         let query_start = self.offset;
         self.skip_query()?;

tests/it/execution.rs

···
 fn execute(python_source: &str, dsl_source: &str) -> Result<String, ExecutionError> {
     init_log();
     let mut parser = Parser::new();
-    parser.set_language(tree_sitter_python::language()).unwrap();
+    parser
+        .set_language(&tree_sitter_python::LANGUAGE.into())
+        .unwrap();
     let tree = parser.parse(python_source, None).unwrap();
     let file =
-        File::from_str(tree_sitter_python::language(), dsl_source).expect("Cannot parse file");
+        File::from_str(tree_sitter_python::LANGUAGE.into(), dsl_source).expect("Cannot parse file");
     let functions = Functions::stdlib();
     let mut globals = Variables::new();
     globals

tests/it/functions.rs

···
 fn execute(python_source: &str, dsl_source: &str) -> Result<String, ExecutionError> {
     init_log();
     let mut parser = Parser::new();
-    parser.set_language(tree_sitter_python::language()).unwrap();
+    parser
+        .set_language(&tree_sitter_python::LANGUAGE.into())
+        .unwrap();
     let tree = parser.parse(python_source, None).unwrap();
     let file =
-        File::from_str(tree_sitter_python::language(), dsl_source).expect("Cannot parse file");
+        File::from_str(tree_sitter_python::LANGUAGE.into(), dsl_source).expect("Cannot parse file");
     let functions = Functions::stdlib();
     let mut globals = Variables::new();
     globals

tests/it/graph.rs

···
 fn can_display_graph() {
     let python_source = "pass";
     let mut parser = Parser::new();
-    parser.set_language(tree_sitter_python::language()).unwrap();
+    parser
+        .set_language(&tree_sitter_python::LANGUAGE.into())
+        .unwrap();
     let tree = parser.parse(python_source, None).unwrap();
 
     let mut graph = Graph::new();

tests/it/lazy_execution.rs

···
 fn execute(python_source: &str, dsl_source: &str) -> Result<String, ExecutionError> {
     init_log();
     let mut parser = Parser::new();
-    parser.set_language(tree_sitter_python::language()).unwrap();
+    parser
+        .set_language(&tree_sitter_python::LANGUAGE.into())
+        .unwrap();
     let tree = parser.parse(python_source, None).unwrap();
     let file =
-        File::from_str(tree_sitter_python::language(), dsl_source).expect("Cannot parse file");
+        File::from_str(tree_sitter_python::LANGUAGE.into(), dsl_source).expect("Cannot parse file");
     let functions = Functions::stdlib();
     let mut globals = Variables::new();
     globals

tests/it/parse_errors.rs

···
 fn parse(python_source: &str) -> Tree {
     init_log();
     let mut parser = Parser::new();
-    parser.set_language(tree_sitter_python::language()).unwrap();
+    parser
+        .set_language(&tree_sitter_python::LANGUAGE.into())
+        .unwrap();
     parser.parse(python_source, None).unwrap()
 }
 

tests/it/parser.rs

···
           set @cap2.var1 = loc1
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let loc1 = Identifier::from("loc1");
     let precedence = Identifier::from("precedence");
···
           let t = #true
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let f = Identifier::from("f");
     let n = Identifier::from("n");
···
           let loc1 = "\"abc,\ndef\\"
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let loc1 = Identifier::from("loc1");
 
···
           let list3 = ["hello", "world",]
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let list1 = Identifier::from("list1");
     let list2 = Identifier::from("list2");
···
           let set3 = {"hello", "world",}
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let set1 = Identifier::from("set1");
     let set2 = Identifier::from("set2");
···
           print "x =", 5
         }    
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let statements = file
         .stanzas
···
           node n
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           print @stmts
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmts = Identifier::from("stmts");
 
···
           print @stmts
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmt = Identifier::from("stmt");
     let stmts = Identifier::from("stmts");
···
           print @stmts
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmts = Identifier::from("stmts");
 
···
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmt = Identifier::from("stmt");
 
···
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmt = Identifier::from("stmt");
 
···
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmt = Identifier::from("stmt");
 
···
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let stmt = Identifier::from("stmt");
 
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let x = Identifier::from("x");
 
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let x = Identifier::from("x");
 
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let x = Identifier::from("x");
 
···
           }
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let xs = Identifier::from("xs");
     let x = Identifier::from("x");
···
           }
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
         }
       }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
         }
       }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           print [ (named-child-index x) for x in @xs ]
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let statements = file
         .stanzas
···
           print { (named-child-index x) for x in @xs }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let statements = file
         .stanzas
···
           edge n -> root
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     assert_eq!(
         file.globals,
···
           print PKG_NAME
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     assert_eq!(
         file.globals,
···
           edge n -> root
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     assert_eq!(
         file.globals,
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     assert_eq!(
         file.globals,
···
           node root
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           node root
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           set root = #null
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
           attr (n) sh = @name
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("Cannot parse file");
 
     let shorthands = file.shorthands.into_iter().collect::<Vec<_>>();
     assert_eq!(
···
         {
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
         (module (non_existing_node))
         {}
     "#;
-    let err = match File::from_str(tree_sitter_python::language(), source) {
+    let err = match File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         Ok(_) => panic!("Parse succeeded unexpectedly"),
         Err(ParseError::QueryError(e)) => e,
         Err(e) => panic!("Unexpected error: {}", e),
···
         ]
         {}
     "#;
-    let err = match File::from_str(tree_sitter_python::language(), source) {
+    let err = match File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         Ok(_) => panic!("Parse succeeded unexpectedly"),
         Err(ParseError::QueryError(e)) => e,
         Err(e) => panic!("Unexpected error: {}", e),
···
         (function_definition name: (identifier) @name) {
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::LANGUAGE.into(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
···
         (function_definition name: (identifier) @_name) {
         }
     "#;
-    File::from_str(tree_sitter_python::language(), source).expect("parse to succeed");
+    File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("parse to succeed");
 }
 
 #[test]
···
     let source = r#"
         inherit .scope
     "#;
-    let file = File::from_str(tree_sitter_python::language(), source).expect("parse to succeed");
+    let file =
+        File::from_str(tree_sitter_python::LANGUAGE.into(), source).expect("parse to succeed");
     assert!(file.inherited_variables.contains("scope".into()));
 }

vscode/CHANGELOG.md

···
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.2 -- 2023-12-12
+
+### Added
+
+- Add missing `else` keyword
+
 ## 0.1.1 -- 2023-06-01
 
 ### Added

vscode/package.json

···
 {
     "name": "tree-sitter-graph",
-    "version": "0.1.1",
+    "version": "0.1.2",
     "publisher": "tree-sitter",
     "engines": {
         "vscode": "^1.60.0"