use std::path::Path;
use tree_sitter::{Language, Parser, Tree};
#[derive(Debug, Clone)]
pub enum ParseError {
UnsupportedLanguage(String),
ParseFailed,
LanguageSetFailed,
}
impl std::fmt::Display for ParseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ParseError::UnsupportedLanguage(ext) => {
write!(f, "unsupported language for extension: {}", ext)
}
ParseError::ParseFailed => write!(f, "tree-sitter failed to parse source"),
ParseError::LanguageSetFailed => write!(f, "failed to set language on parser"),
}
}
}
impl std::error::Error for ParseError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SupportedLanguage {
Rust,
Python,
TypeScript,
JavaScript,
Go,
Java,
Cpp,
}
impl SupportedLanguage {
pub fn tree_sitter_language(&self) -> Language {
match self {
SupportedLanguage::Rust => tree_sitter_rust::LANGUAGE.into(),
SupportedLanguage::Python => tree_sitter_python::LANGUAGE.into(),
SupportedLanguage::TypeScript => tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
SupportedLanguage::JavaScript => tree_sitter_javascript::LANGUAGE.into(),
SupportedLanguage::Go => tree_sitter_go::LANGUAGE.into(),
SupportedLanguage::Java => tree_sitter_java::LANGUAGE.into(),
SupportedLanguage::Cpp => tree_sitter_cpp::LANGUAGE.into(),
}
}
pub fn name(&self) -> &'static str {
match self {
SupportedLanguage::Rust => "Rust",
SupportedLanguage::Python => "Python",
SupportedLanguage::TypeScript => "TypeScript",
SupportedLanguage::JavaScript => "JavaScript",
SupportedLanguage::Go => "Go",
SupportedLanguage::Java => "Java",
SupportedLanguage::Cpp => "C++",
}
}
pub fn extensions(&self) -> &'static [&'static str] {
match self {
SupportedLanguage::Rust => &["rs"],
SupportedLanguage::Python => &["py"],
SupportedLanguage::TypeScript => &["ts", "tsx"],
SupportedLanguage::JavaScript => &["js", "jsx"],
SupportedLanguage::Go => &["go"],
SupportedLanguage::Java => &["java"],
SupportedLanguage::Cpp => &["cpp", "cc", "cxx", "c", "h", "hpp"],
}
}
}
pub fn detect_language(path: &Path) -> Option<SupportedLanguage> {
let ext = path.extension()?.to_str()?;
extension_to_language(ext)
}
fn extension_to_language(ext: &str) -> Option<SupportedLanguage> {
match ext.to_lowercase().as_str() {
"rs" => Some(SupportedLanguage::Rust),
"py" => Some(SupportedLanguage::Python),
"ts" | "tsx" => Some(SupportedLanguage::TypeScript),
"js" | "jsx" => Some(SupportedLanguage::JavaScript),
"go" => Some(SupportedLanguage::Go),
"java" => Some(SupportedLanguage::Java),
"cpp" | "cc" | "cxx" | "c" | "h" | "hpp" => Some(SupportedLanguage::Cpp),
_ => None,
}
}
#[derive(Debug)]
pub struct ParseResult {
pub tree: Tree,
pub language: SupportedLanguage,
pub source_bytes: usize,
}
impl ParseResult {
pub fn root_node(&self) -> tree_sitter::Node<'_> {
self.tree.root_node()
}
pub fn has_errors(&self) -> bool {
self.tree.root_node().has_error()
}
}
pub struct LanguageSupport {
parser: Parser,
language: SupportedLanguage,
}
impl LanguageSupport {
pub fn for_extension(ext: &str) -> Option<Self> {
let lang = extension_to_language(ext)?;
Some(Self::for_language(lang))
}
pub fn for_language(lang: SupportedLanguage) -> Self {
let mut parser = Parser::new();
parser
.set_language(&lang.tree_sitter_language())
.expect("failed to set language on parser");
Self {
parser,
language: lang,
}
}
pub fn language(&self) -> SupportedLanguage {
self.language
}
pub fn parse(&mut self, source: &str) -> Option<Tree> {
self.parser.parse(source, None)
}
pub fn parse_with_old_tree(&mut self, source: &str, old_tree: &Tree) -> Option<Tree> {
self.parser.parse(source, Some(old_tree))
}
}
pub fn parse_file(path: &Path, content: &str) -> Result<ParseResult, ParseError> {
let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
let language = extension_to_language(ext)
.ok_or_else(|| ParseError::UnsupportedLanguage(ext.to_string()))?;
let mut support = LanguageSupport::for_language(language);
let tree = support.parse(content).ok_or(ParseError::ParseFailed)?;
Ok(ParseResult {
tree,
language,
source_bytes: content.len(),
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
#[test]
fn test_parse_rust_function() {
let source = "fn main() {}";
let path = PathBuf::from("test.rs");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::Rust);
assert_eq!(result.source_bytes, source.len());
assert!(!result.has_errors());
let root = result.root_node();
assert_eq!(root.kind(), "source_file");
assert!(root.child_count() > 0);
}
#[test]
fn test_parse_python_function() {
let source = "def main():\n pass";
let path = PathBuf::from("test.py");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::Python);
assert!(!result.has_errors());
let root = result.root_node();
assert_eq!(root.kind(), "module");
}
#[test]
fn test_parse_typescript_function() {
let source = "function main(): void {}";
let path = PathBuf::from("test.ts");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::TypeScript);
assert!(!result.has_errors());
let root = result.root_node();
assert_eq!(root.kind(), "program");
}
#[test]
fn test_parse_javascript_function() {
let source = "function main() { return 42; }";
let path = PathBuf::from("test.js");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::JavaScript);
assert!(!result.has_errors());
}
#[test]
fn test_parse_go_function() {
let source = "package main\n\nfunc main() {}";
let path = PathBuf::from("test.go");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::Go);
assert!(!result.has_errors());
let root = result.root_node();
assert_eq!(root.kind(), "source_file");
}
#[test]
fn test_parse_java_class() {
let source = "public class Main { public static void main(String[] args) {} }";
let path = PathBuf::from("Main.java");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::Java);
assert!(!result.has_errors());
let root = result.root_node();
assert_eq!(root.kind(), "program");
}
#[test]
fn test_parse_cpp_function() {
let source = "int main() { return 0; }";
let path = PathBuf::from("test.cpp");
let result = parse_file(&path, source).expect("parsing should succeed");
assert_eq!(result.language, SupportedLanguage::Cpp);
assert!(!result.has_errors());
let root = result.root_node();
assert_eq!(root.kind(), "translation_unit");
}
#[test]
fn test_detect_language_extensions() {
assert_eq!(
detect_language(Path::new("foo.rs")),
Some(SupportedLanguage::Rust)
);
assert_eq!(
detect_language(Path::new("foo.py")),
Some(SupportedLanguage::Python)
);
assert_eq!(
detect_language(Path::new("foo.ts")),
Some(SupportedLanguage::TypeScript)
);
assert_eq!(
detect_language(Path::new("foo.tsx")),
Some(SupportedLanguage::TypeScript)
);
assert_eq!(
detect_language(Path::new("foo.js")),
Some(SupportedLanguage::JavaScript)
);
assert_eq!(
detect_language(Path::new("foo.jsx")),
Some(SupportedLanguage::JavaScript)
);
assert_eq!(
detect_language(Path::new("foo.go")),
Some(SupportedLanguage::Go)
);
assert_eq!(
detect_language(Path::new("Foo.java")),
Some(SupportedLanguage::Java)
);
assert_eq!(
detect_language(Path::new("foo.cpp")),
Some(SupportedLanguage::Cpp)
);
assert_eq!(
detect_language(Path::new("foo.cc")),
Some(SupportedLanguage::Cpp)
);
assert_eq!(
detect_language(Path::new("foo.cxx")),
Some(SupportedLanguage::Cpp)
);
assert_eq!(
detect_language(Path::new("foo.c")),
Some(SupportedLanguage::Cpp)
);
assert_eq!(
detect_language(Path::new("foo.h")),
Some(SupportedLanguage::Cpp)
);
assert_eq!(
detect_language(Path::new("foo.hpp")),
Some(SupportedLanguage::Cpp)
);
}
#[test]
fn test_unsupported_extension_returns_none() {
assert_eq!(detect_language(Path::new("foo.txt")), None);
assert_eq!(detect_language(Path::new("foo.md")), None);
assert_eq!(detect_language(Path::new("foo.json")), None);
assert_eq!(detect_language(Path::new("Makefile")), None);
}
#[test]
fn test_unsupported_extension_parse_error() {
let result = parse_file(Path::new("foo.txt"), "some text");
assert!(result.is_err());
if let Err(ParseError::UnsupportedLanguage(ext)) = result {
assert_eq!(ext, "txt");
} else {
panic!("expected UnsupportedLanguage error");
}
}
#[test]
fn test_language_support_direct_usage() {
let mut support = LanguageSupport::for_extension("rs").expect("rs should be supported");
assert_eq!(support.language(), SupportedLanguage::Rust);
let tree = support.parse("fn foo() {}").expect("should parse");
assert_eq!(tree.root_node().kind(), "source_file");
}
#[test]
fn test_incremental_parsing() {
let mut support = LanguageSupport::for_language(SupportedLanguage::Rust);
let tree1 = support.parse("fn foo() {}").expect("should parse");
let tree2 = support
.parse_with_old_tree("fn foo() { let x = 1; }", &tree1)
.expect("should parse");
assert_eq!(tree2.root_node().kind(), "source_file");
}
#[test]
fn test_supported_language_name() {
assert_eq!(SupportedLanguage::Rust.name(), "Rust");
assert_eq!(SupportedLanguage::Python.name(), "Python");
assert_eq!(SupportedLanguage::TypeScript.name(), "TypeScript");
assert_eq!(SupportedLanguage::JavaScript.name(), "JavaScript");
assert_eq!(SupportedLanguage::Go.name(), "Go");
assert_eq!(SupportedLanguage::Java.name(), "Java");
assert_eq!(SupportedLanguage::Cpp.name(), "C++");
}
#[test]
fn test_supported_language_extensions() {
assert_eq!(SupportedLanguage::Rust.extensions(), &["rs"]);
assert_eq!(SupportedLanguage::TypeScript.extensions(), &["ts", "tsx"]);
assert_eq!(
SupportedLanguage::Cpp.extensions(),
&["cpp", "cc", "cxx", "c", "h", "hpp"]
);
}
#[test]
fn test_parse_with_syntax_errors() {
let source = "fn main( { }"; let path = PathBuf::from("test.rs");
let result = parse_file(&path, source).expect("parsing should succeed");
assert!(result.has_errors());
}
}