Rework library and add some tools

Author: kaleidawave

language-tool/README.md

@@ -0,0 +1,3 @@
+Tools for operating on code
+
+Currently focused on Rust, but more languages supported in the future...

language-tool/src/lib.rs

@@ -1,76 +1,76 @@
-// use libloading::{Library, Symbol, library_filename};
 use std::ops::Range;
-use tree_sitter::{Node, Parser}; // use tree_sitter::{Language, Node, Parser};
-// use tree_sitter_language::LanguageFn;
+use std::path::{Path, PathBuf};
+use tree_sitter::Parser;
+
+pub use tree_sitter::Node;
+
+pub mod loader;
+pub mod tools;
 
 pub type GrammarName = &'static str;
+pub type SliceRange = Range<usize>;
 
-#[derive(Debug)]
-pub struct Item<'s, 'a> {
-    pub total_source: &'s str,
-    pub raw_node: Node<'a>,
+pub struct File {
+    path: PathBuf,
+    source: String,
 }
 
-impl<'s, 'a> Item<'s, 'a> {
-    pub fn source(&self) -> &'s str {
-        &self.total_source[self.range()]
+impl File {
+    pub fn new(path: PathBuf, source: String) -> Self {
+        Self { path, source }
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.path
     }
 
-    pub fn range(&self) -> Range<usize> {
-        self.raw_node.start_byte()..self.raw_node.end_byte()
+    pub fn source(&self) -> &str {
+        &self.source
     }
 
-    pub fn grammar_name(&self) -> &'static str {
-        self.raw_node.grammar_name()
+    pub fn node_text(&self, item: Node<'_>) -> &str {
+        item.utf8_text(self.source.as_bytes()).unwrap()
     }
 }
 
 pub type Chain = Vec<(GrammarName, Range<usize>)>;
 
-pub trait Scanner<'s> {
+pub trait Scanner {
     /// returning `false` skip descendents
     /// chain gives information about location
-    fn scan_tree<'a>(&mut self, _item: Item<'s, 'a>, _chain: &Chain) -> bool {
+    fn scan_tree<'a>(&mut self, _file: &'a File, _item: Node<'a>, _chain: &Chain) -> bool {
         false
     }
 
     /// chain gives information about location
-    fn scan_leaf<'a>(&mut self, item: Item<'s, 'a>, chain: &Chain);
+    fn scan_leaf<'a>(&mut self, file: &'a File, item: Node<'a>, chain: &Chain);
 }
 
-pub fn scan<'a>(source_code: &'a str, parser: &mut Parser, scanner: &mut impl Scanner<'a>) {
-    fn flat_walk<'a, 's>(
-        source_code: &'s str,
+pub fn scan(file: &File, parser: &mut Parser, scanner: &mut impl Scanner) {
+    fn flat_walk<'a>(
+        file: &File,
         node: tree_sitter::Node<'a>,
-        scanner: &mut impl Scanner<'s>,
+        scanner: &mut impl Scanner,
         chain: &mut Chain,
     ) {
         if node.child_count() > 0 {
-            let item = Item {
-                total_source: source_code,
-                raw_node: node,
-            };
-            let result = scanner.scan_tree(item, chain);
+            let result = scanner.scan_tree(file, node, chain);
             if !result {
                 let range = node.start_byte()..node.end_byte();
                 chain.push((node.grammar_name(), range));
 
                 let mut walker = node.walk();
                 for child in node.children(&mut walker) {
-                    flat_walk(source_code, child, scanner, chain);
+                    flat_walk(file, child, scanner, chain);
                 }
                 chain.pop();
             }
         } else {
-            let item = Item {
-                total_source: source_code,
-                raw_node: node,
-            };
-            scanner.scan_leaf(item, chain);
+            scanner.scan_leaf(file, node, chain);
         }
     }
 
-    let tree = parser.parse(source_code, None).unwrap();
+    let tree = parser.parse(&file.source, None).unwrap();
     let root = tree.root_node();
-    flat_walk(source_code, root, scanner, &mut Vec::new());
+    flat_walk(file, root, scanner, &mut Vec::new());
 }

language-tool/src/loader.rs

@@ -0,0 +1,40 @@
+use libloading::{Library, Symbol, library_filename};
+use tree_sitter::{Language, Parser as TreeSitterParser};
+use tree_sitter_language::LanguageFn;
+
+// unsafe extern "C" {
+//     fn tree_sitter_rust() -> *const ();
+// }
+
+pub struct Parser {
+    #[allow(unused)]
+    library: Library,
+    pub parser: TreeSitterParser,
+}
+
+pub fn get_rust_parser() -> Parser {
+    let language = "rust";
+    eprintln!("loading {language}");
+    let module = std::path::Path::new("languages").join(library_filename(language));
+    let function_name = format!("tree_sitter_{language}");
+    let library = unsafe { Library::new(&module).unwrap() };
+    let function = unsafe {
+        library
+            .get::<Symbol<extern "C" fn() -> *const ()>>(function_name.as_bytes())
+            .unwrap()
+    };
+    let language_fn = unsafe { LanguageFn::from_raw(**function) };
+    eprintln!(
+        "loaded {function_name} from {module}",
+        module = module.display()
+    );
+
+    // let language_fn = unsafe { LanguageFn::from_raw(tree_sitter_rust) };
+
+    let mut parser = TreeSitterParser::new();
+    parser
+        .set_language(&Language::from(language_fn))
+        .unwrap_or_else(|_| panic!("Error loading {language:?} grammar"));
+
+    Parser { library, parser }
+}