fix: automatically generate method headers and signature defs for native methods

Author: itsaky

android-tree-sitter/build.gradle.kts

@@ -23,8 +23,23 @@ plugins {
 
 description = "Android Java bindings for Tree Sitter."
 
+val nativeHeadersDir =
+  project.layout.buildDirectory.dir("generated/native_headers")
+
 android {
   namespace = "com.itsaky.androidide.treesitter"
+
+  defaultConfig {
+    externalNativeBuild {
+      cmake {
+        arguments += "-DAUTOGEN_HEADERS=${nativeHeadersDir.get().asFile.absolutePath}"
+      }
+    }
+  }
+}
+
+tasks.withType(JavaCompile::class.java).configureEach {
+  options.compilerArgs.add("-AnativeHeaders.outDir=${nativeHeadersDir.get().asFile.absolutePath}")
 }
 
 dependencies {

android-tree-sitter/src/main/cpp/CMakeLists.txt

@@ -29,6 +29,9 @@ include(../../../../cmake/common-config.cmake)
 # headers for those are located in the tree-sitter sources
 include_directories("${TS_DIR}/lib/src")
 
+# Auto-generated headers
+include_directories(${AUTOGEN_HEADERS})
+
 # add android-tree-sitter library
 add_library(android-tree-sitter SHARED
 

android-tree-sitter/src/main/cpp/ts.cc

@@ -15,7 +15,13 @@
  *  along with android-tree-sitter.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <array>
+
+#include "utils/jni_macros.h"
 #include "utils/ts_obj_utils.h"
+#include "utils/ts_log.h"
+#include "ts_meta.h"
+#include "ts_meta_sigs.h"
 
 #if defined(__ANDROID__)
 static jint JNI_VERSION = JNI_VERSION_1_6;
@@ -41,14 +47,30 @@ void JNI_OnUnload(JavaVM *vm, void *reserved) {
 }
 
 
-extern "C" JNIEXPORT jint JNICALL
-Java_com_itsaky_androidide_treesitter_TreeSitter_getLanguageVersion
-    (JNIEnv *env, jclass self) {
+JNIEXPORT jint JNICALL ats_language_version(JNIEnv *env, jclass self) {
   return (jint) TREE_SITTER_LANGUAGE_VERSION;
 }
 
-extern "C" JNIEXPORT jint JNICALL
-Java_com_itsaky_androidide_treesitter_TreeSitter_getMinimumCompatibleLanguageVersion
-    (JNIEnv *env, jclass self) {
+JNIEXPORT jint JNICALL
+ats_min_compatible_language_version(JNIEnv *env, jclass self) {
   return (jint) TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION;
+}
+
+static JNINativeMethod gMethods[] = {
+    MAKE_JNI_METHOD(TS_TREESITTER_GETLANGUAGEVERSION_NAME,
+                    TS_TREESITTER_GETLANGUAGEVERSION_SIG,
+                    ats_language_version),
+    MAKE_JNI_METHOD(TS_TREESITTER_GETMINIMUMCOMPATIBLELANGUAGEVERSION_NAME,
+                    TS_TREESITTER_GETMINIMUMCOMPATIBLELANGUAGEVERSION_SIG,
+                    ats_min_compatible_language_version)
+};
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_itsaky_androidide_treesitter_TreeSitter_00024Native_registerNatives(
+    JNIEnv *env,
+    jclass clazz) {
+
+  auto result = env->RegisterNatives(clazz, gMethods, 2);
+  LOGD("TreeSitter", "RegisterNatives: %d", result);
 }

android-tree-sitter/src/main/cpp/utils/jni_macros.h

@@ -0,0 +1,29 @@
+/*
+ *  This file is part of android-tree-sitter.
+ *
+ *  android-tree-sitter library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  android-tree-sitter library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *  along with android-tree-sitter.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef ATS_JNI_MACROS_H
+#define ATS_JNI_MACROS_H
+
+#include <jni.h>
+
+#define MAKE_JNI_METHOD(_name, _sig, _func) (JNINativeMethod) { \
+                                                .name = _name,  \
+                                                .signature = _sig, \
+                                                .fnPtr = reinterpret_cast<void *>(&_func) \
+                                            }
+
+#endif //ATS_JNI_MACROS_H

android-tree-sitter/src/main/java/com/itsaky/androidide/treesitter/TSLanguage.java

@@ -18,6 +18,7 @@
 package com.itsaky.androidide.treesitter;
 
 import android.content.Context;
+import com.itsaky.androidide.treesitter.annotations.GenerateNativeHeaders;
 import com.itsaky.androidide.treesitter.util.TSObjectFactoryProvider;
 import java.nio.charset.StandardCharsets;
 import java.util.concurrent.atomic.AtomicLong;
@@ -249,6 +250,7 @@ private static void validateLangName(String lang) {
     }
   }
 
+  @GenerateNativeHeaders(fileName = "language")
   private static class Native {
 
     private static native int symCount(long ptr);

android-tree-sitter/src/main/java/com/itsaky/androidide/treesitter/TreeSitter.java

@@ -17,29 +17,64 @@
 
 package com.itsaky.androidide.treesitter;
 
+import com.itsaky.androidide.treesitter.annotations.GenerateNativeHeaders;
+
 /**
  * @author Akash Yadav
  */
 public class TreeSitter {
 
+  private static int sLangVer = -1, sMinCompatLangVer = -1;
+
   /**
    * Loads the <code>android-tree-sitter</code> native library using
    * {@link System#loadLibrary(String)}.
    */
   public static void loadLibrary() {
     System.loadLibrary("android-tree-sitter");
+    Native.registerNatives();
   }
 
+
   /**
    * The latest ABI version that is supported by the current version of the library. When Languages
    * are generated by the Tree-sitter CLI, they are assigned an ABI version number that corresponds
    * to the current CLI version. The Tree-sitter library is generally backwards-compatible with
    * languages generated using older CLI versions, but is not forwards-compatible.
    */
-  public static native int getLanguageVersion();
+  public static int getLanguageVersion() {
+    if (sLangVer == -1) {
+      sLangVer = Native.getLanguageVersion();
+    }
+
+    return sLangVer;
+  }
 
   /**
    * The earliest ABI version that is supported by the current version of the library.
    */
-  public static native int getMinimumCompatibleLanguageVersion();
+  public static int getMinimumCompatibleLanguageVersion() {
+    if (sMinCompatLangVer == -1) {
+      sMinCompatLangVer = Native.getMinimumCompatibleLanguageVersion();
+    }
+
+    return sMinCompatLangVer;
+  }
+
+  public static void registerNatives() {
+    Native.registerNatives();
+  }
+
+  @GenerateNativeHeaders(fileName = "meta")
+  private static final class Native {
+
+    static native int getLanguageVersion();
+
+    /**
+     * The earliest ABI version that is supported by the current version of the library.
+     */
+    static native int getMinimumCompatibleLanguageVersion();
+
+    private static native void registerNatives();
+  }
 }

annotation-processors/src/main/java/com/itsaky/androidide/treesitter/ap/GenerateNativeHeadersAnnotationProcessor.java

@@ -0,0 +1,130 @@
+/*
+ *  This file is part of android-tree-sitter.
+ *
+ *  android-tree-sitter library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  android-tree-sitter library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *  along with android-tree-sitter.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.itsaky.androidide.treesitter.ap;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.AGGREGATING;
+
+import com.google.auto.service.AutoService;
+import com.itsaky.androidide.treesitter.annotations.GenerateNativeHeaders;
+import com.itsaky.androidide.treesitter.annotations.Synchronized;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Objects;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedOptions;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import javax.tools.Diagnostic.Kind;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/**
+ * Annotation processor for {@link GenerateNativeHeaders}.
+ *
+ * @author Akash Yadav
+ */
+@SupportedAnnotationTypes(value = {
+  "com.itsaky.androidide.treesitter.annotations.GenerateNativeHeaders"})
+@SupportedOptions(value = {})
+@SupportedSourceVersion(SourceVersion.RELEASE_11)
+@IncrementalAnnotationProcessor(AGGREGATING)
+@AutoService(Processor.class)
+@SuppressWarnings("unused")
+public class GenerateNativeHeadersAnnotationProcessor extends AbstractProcessor {
+
+  private Types types;
+  private Elements elements;
+
+  private File outputDirectory;
+
+  @Override
+  public Set<String> getSupportedAnnotationTypes() {
+    return Set.of(GenerateNativeHeaders.class.getName());
+  }
+
+  @Override
+  public synchronized void init(ProcessingEnvironment processingEnv) {
+    this.types = processingEnv.getTypeUtils();
+    this.elements = processingEnv.getElementUtils();
+    this.outputDirectory = new File(
+      Objects.requireNonNull(processingEnv.getOptions().get("nativeHeaders.outDir")));
+
+    super.init(processingEnv);
+  }
+
+  @Override
+  public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
+    final var messager = processingEnv.getMessager();
+    final var elements = roundEnvironment.getElementsAnnotatedWith(GenerateNativeHeaders.class);
+    for (Element element : elements) {
+      if (element.getKind() != ElementKind.CLASS) {
+        messager.printMessage(Kind.ERROR,
+          Synchronized.class.getSimpleName() + " can only be applied to classes");
+        continue;
+      }
+
+      final var type = ((TypeElement) element);
+      final var annotation = Objects.requireNonNull(
+        element.getAnnotation(GenerateNativeHeaders.class));
+      final var fileName = annotation.fileName();
+
+      final var writer = new JNIWriter(this.types, this.elements);
+      final var result = writer.generate(type);
+
+      if (outputDirectory.exists()) {
+        outputDirectory.delete();
+      }
+
+      outputDirectory.mkdirs();
+
+      final var methodHeaders = new File(outputDirectory, "ts_" + fileName + ".h");
+      if (methodHeaders.exists()) {
+        methodHeaders.delete();
+      }
+
+      final var methodSignatures = new File(outputDirectory, "ts_" + fileName + "_sigs.h");
+      if (methodSignatures.exists()) {
+        methodSignatures.delete();
+      }
+
+      writeFileContents(result.first, methodHeaders);
+      writeFileContents(result.second, methodSignatures);
+    }
+    return false;
+  }
+
+  private static void writeFileContents(String methodHeaderContents, File methodHeaders) {
+    try (final var out = new FileOutputStream(methodHeaders)) {
+      out.write(methodHeaderContents.getBytes(StandardCharsets.UTF_8));
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}