Hook up vendored tree-sitter-go

build.rs

@@ -1,16 +1,21 @@
 use std::path::PathBuf;
 
-fn build(package_name: &str) {
+fn build(package_name: &str, has_scanner: bool) {
     let dir: PathBuf = ["vendor", package_name, "src"].iter().collect();
 
-    cc::Build::new()
-        .include(&dir)
-        .file(dir.join("parser.c"))
-        .file(dir.join("scanner.c"))
-        .warnings(false) // ignore unused parameter warnings
-        .compile(package_name);
+    let mut build = cc::Build::new();
+
+    build.include(&dir).warnings(false); // ignore unused parameter warnings
+
+    build.file(dir.join("parser.c"));
+    if has_scanner {
+        build.file(dir.join("scanner.c"));
+    }
+
+    build.compile(package_name);
 }
 
 fn main() {
-    build("tree-sitter-rust");
+    build("tree-sitter-rust", true);
+    build("tree-sitter-go", false);
 }

src/main.rs

@@ -115,10 +115,11 @@ fn main() {
     let arena = Arena::new();
 
     let prefer_legacy_parser = env::var("DFT_LEGACY").is_ok();
-    let (lhs, rhs) = if sitter::supported(extension.unwrap_or_else(|| OsStr::new(""))) && !prefer_legacy_parser {
+    let extension = extension.unwrap_or_else(|| OsStr::new(""));
+    let (lhs, rhs) = if sitter::supported(extension) && !prefer_legacy_parser {
         (
-            sitter::parse(&arena, &lhs_src),
-            sitter::parse(&arena, &rhs_src),
+            sitter::parse(&arena, &lhs_src, extension),
+            sitter::parse(&arena, &rhs_src, extension),
         )
     } else {
         match &lang {

src/sitter.rs

@@ -7,18 +7,30 @@ use crate::{lines::NewlinePositions, syntax::Syntax};
 
 extern "C" {
     fn tree_sitter_rust() -> Language;
+    fn tree_sitter_go() -> Language;
 }
 
 pub fn supported(extension: &OsStr) -> bool {
-    extension == "rs"
+    extension == "rs" || extension == "go"
 }
 
-pub fn parse<'a>(arena: &'a Arena<Syntax<'a>>, src: &str) -> Vec<&'a Syntax<'a>> {
+pub fn parse<'a>(
+    arena: &'a Arena<Syntax<'a>>,
+    src: &str,
+    extension: &OsStr,
+) -> Vec<&'a Syntax<'a>> {
     let mut parser = Parser::new();
-    let language = unsafe { tree_sitter_rust() };
+
+    let language = if extension == "rs" {
+        unsafe { tree_sitter_rust() }
+    } else if extension == "go" {
+        unsafe { tree_sitter_go() }
+    } else {
+        panic!("Unknown extension for tree-sitter parsers.")
+    };
     parser
         .set_language(language)
-        .expect("Incompatible tree-sitter version in tree-sitter-rust");
+        .expect("Incompatible tree-sitter version");
 
     let tree = parser.parse(src, None).unwrap();