feat: Move from KSP to classgraph for registration code and initial Scala support (#761)

* feat: Add java and kotlin parser to get fqdn from source code

* feat: remove script source file path from KtClass and registration.

* feat: First draft of ClassGraph symbol processor

* enh(entry-gen): Disallow multiple constructors with same argument count and simplify constructor registration so we get rid of nullable info need

* feat(entry-gen): Manage type parameters with classgraph

* feat(classgraph): get signal parameter names from annotation

* feat(classgraph): generate registrars using classgraph

* feat: configure gradle plugin to use classgraph instead of KSP and first steps in scala support

* feat: Add update of gdj files

* feat: Add support of scala source script in engine

* feat: set scala version configurable from gradle plugin

* chore: remove classes to test parser

* feat: Remove support for registering constructors with arguments

* feat: Remove multi args constructor constraints and simplify code according to this modification

* chore: update scala implementation code to godot 4.4 and add scala call test

* chore: rename fqdn to fqName

* enh: fail on errors at the end of classgraph process

* doc: Add scala support to documentation

* enh: Add context on classgraph errors

* chore: regenerate api with godot kotlin json

---------

Co-authored-by: Ced Naru <cednaru.dev@gmail.com>
Co-authored-by: chippmann <cedric@hippmann.ch>

Author: 3 people

docs/src/doc/contribution/knowledge-base/entry-generation.md

@@ -5,7 +5,7 @@
 To make it more language agnostic, the entry generator provides a set of model classes which represent the needed information about the source code by the entry genenerator.
 It expects this information to be gathered and assembled by the calling tool and to be provided in the entry point of the entry generator.
 
-For Kotlin and Java, this tool is `godot-kotlin-symbol-processor` (a Kotlin compiler's plugin), which analyses the source code, and gathers the information needed by the entry generator.
+For Kotlin, Java and Scala, this tool is `godot-class-graph-symbol-processor`, which analyses the byte code, and gathers the information needed by the entry generator.
 It then calls the entry generator which in turn generates the needed entry files.
 
 ## The godot-kotlin-symbol-processor

docs/src/doc/index.md

@@ -36,7 +36,7 @@ The items in this list are explicitly mentioned here as these will be implemente
 Also consider the [API Differences](user-guide/api-differences.md) section for general differences
 and limitations which will not be or cannot be adressed in the near forseable future or ever.
 
-- Each registered constructor must have a unique number of arguments, constructor overloading is not yet supported.
+- Only a default no arg constructor can be registered.
 - No tool mode (you can set it already in the `@RegisterClass` annotation but it has no effect yet).
 - No addon support, you cannot use Godot Kotlin/JVM to write plugins and addons yet (you can however [write libraries](develop-libraries/introduction.md) with godot specific code).
 - Web is currently not supported. See [Supported platforms](#supported-platforms) to see what platforms we currently support
@@ -48,7 +48,7 @@ If you don't have Discord or you don't want to use it, please file an issue on G
 
 ## Supported languages
 
-The main language supported is Kotlin. We do however support Java experimentally. It should be possible to support other JVM-based languages as well but this is not the focus of this project. If you want to have support for other languages, have a look at [support for other JVM-based languages](contribution/support-for-other-jvm-based-languages.md).
+The main language supported is Kotlin. We do however support Java and Scala experimentally. It should be possible to support other JVM-based languages as well but this is not the focus of this project. If you want to have support for other languages, have a look at [support for other JVM-based languages](contribution/support-for-other-jvm-based-languages.md).
 
 ## Supported platforms
 
@@ -85,7 +85,7 @@ Contrary to the official binaries, there are two builds of the editor per Platfo
 `release` editors are the editors you use normally. `debug` editors provide debug symbols and are intended to provide better stacktraces in case of crashes of the editor. Please use those when submitting bugreports. 
 
 !!! warning
-    This module will NOT work with the official Godot Editor and Export Templates! To be able to use Kotlin and Java scripts in Godot, you need our Editor and Export Templates builds.
+    This module will NOT work with the official Godot Editor and Export Templates! To be able to use Kotlin, Java and Scala scripts in Godot, you need our Editor and Export Templates builds.
 
 ## Developer discussion
 

docs/src/doc/user-guide/advanced/cleanup-operations.md

@@ -1,4 +1,4 @@
-When running Kotlin/Java code, the JVM is embedded and managed directly by Godot, which offer little control when the game is closing. 
+When running Kotlin/Java/Scala code, the JVM is embedded and managed directly by Godot, which offer little control when the game is closing. 
 If you use third-party library that needs resources to be freed/saved or threads to be closed. 
 To that end, we provide a simple method that allows you to register callbacks that will be called when the JVM is shutdown.
 

docs/src/doc/user-guide/api-differences.md

@@ -5,9 +5,9 @@ Godot Kotlin/JVM offers two different ways to attach scripts:
 - Source files
 - Registration files.
 
-## Source files .kt and .java
+## Source files .kt, .java and .scala
 
-Just like you would do with GDScript, you can directly attach your Kotlin/Java files to Nodes as scripts.
+Just like you would do with GDScript, you can directly attach your Kotlin/Java/Scala files to Nodes as scripts.
 This is the most straightforward method to use Kotlin scripts but not the most flexible.
 
 The limitations are the following:
@@ -20,7 +20,7 @@ The limitations are the following:
     var test_script: MyScript = load("res://pathToScript/MyScript.kt").new() // Wrong
     var test_script: Node = load("res://pathToScript/MyScript.kt").new() // Correct
     ```
-    The same applies if you use a Godot object with a .kt/.java attached to it
+    The same applies if you use a Godot object with a .kt/.java/.scala attached to it
 
 If those limitations don't apply to you, feel free to use Kotlin source files directly.
 
@@ -32,7 +32,7 @@ They have several benefits over source files:
 - .gdj can be placed wherever you want in your Godot project, you are not limited to the source set.
 - Each script get its own .gdj. This includes scripts in different modules and libraries.
 - If a source file contains several scripts. A different .gdj will be generated for each.
-- Registration files are language agnostic, they are generated for Kotlin and Java files with no difference.
+- Registration files are language agnostic, they are generated for Kotlin, Java and Scala files with no difference.
 - When creating a script from code using its registered name. The module is going to use the registration file as the script. Therefore, registration files are treated as the default way to use scripts inside the module.
 
 By default, these files are generated into a folder called `gdj` in the root of your project.
@@ -186,6 +186,14 @@ This kind of operation can be costly so we provide extension functions which cac
 ```
 ///
 
+/// tab | Scala
+```scala
+    val stringName = StringNames.asCachedStringName("myString")
+    val nodePath = NodePaths.asCachedNodePath("myNode/myChildNode")
+    val snakeCaseStringName = StringNames.toGodotName("myString")
+```
+///
+
 You can also use the non-cached version of them if you simply want ease of conversion:
 
 /// tab | Kotlin
@@ -202,6 +210,13 @@ You can also use the non-cached version of them if you simply want ease of conve
 ```
 ///
 
+/// tab | Scala
+```scala
+    val stringName = StringNames.asStringName("myString")
+    val nodePath = NodePaths.asNodePath("myNode/myChildNode")
+```
+///
+
 
 ## Logging
 

docs/src/doc/user-guide/classes.md

@@ -139,12 +139,9 @@ This also works for any type you define.
 
 ## Constructors
 
-Godot requires you to have a default constructor on your classes.
-You can define additional constructors but you have to register them by annothing them with `@RegisterConstructor`.
-Default constructors, on the other hand, are always registered automatically.
-
-Constructors can also have **a maximum of 8 arguments** and must have a unique argument count as constructor overloading is not yet supported.
-This limitation is only for registered constructors.
+Godot requires you to have a default constructor on your classes. These are automatically registered for you.  
+Registering constructor with arguments is currently not supported. But you can freely use them from Kotlin/Java/Scala
+just not from GDScript or any other non Godot Kotlin/JVM language.
 
 ### Instantiate Kotlin script classes in GDScript
 
@@ -154,15 +151,8 @@ From GDScript it is possible to create an instance of a Kotlin class using the d
 var instance := YourKotlinClass.new()
 ```
 
-Additional constructors must use the `load` function:
-
-```kt
-var instance := load("res://gdj/YourClass.gdj").new(oneArg, anotherArg)
-```
-
-!!! info
-    The limitation of max 16 arguments for constructors is arbitrary. We decided to introduce this limitation to prevent performance bottlenecks for creating objects as each argument passed to a constructor needs to be unpacked by the binding. The more arguments, the more unpacking is needed which means more overhead.
-
+Using other constructors is not possible. Only the default no arg constructor is registered.  
+But you can create the object and set the required properties after instantiation.
 
 ## Customization
 

docs/src/doc/user-guide/signals_and_callables.md

@@ -35,6 +35,16 @@ public MyScript extends Node {
 ```
 ///
 
+/// tab | Scala
+```scala
+@RegisterClass
+class MyScript extends Node {
+    @RegisterSignal("reverse")
+    val mySignal: Signal1[Boolean] = Signal1.create(this, "mySignal") // Only one way to do it in Scala.
+}
+```
+///
+
 !!! warning Signal parameter count
     In GDScript, signals can have any number of arguments, this is not possible in Kotlin as it is a statically typed language. 
     At the moment, you can create signals and expose them to Godot up to 16 parameters.
@@ -55,6 +65,12 @@ reverseChanged.emit(false);
 ```
 ///
 
+/// tab | Scala
+```scala
+reverseChanged.emit(false)
+```
+///
+
 ## Callables
 
 You can use a classic Callable referencing a Godot Object and one of its method or conveniently use to avoid to creating a separate function.
@@ -80,6 +96,19 @@ You can use a classic Callable referencing a Godot Object and one of its method
 ```
 ///
 
+/// tab | Scala
+```scala
+    val regularCallable = Callable.create(this, "myMethod".toGodotName())
+    val customCallable = LambdaCallable1.create(
+      classOf[Void],
+      classOf[String],
+      (string: String) => {
+        println(string);
+      }
+    )
+```
+///
+
 ### Signals and Callables together
 
 Kotlin and Java already have ways to pass functions around as References. 
@@ -143,6 +172,33 @@ public class AnotherObject extends Object {
 ```
 ///
 
+/// tab | Scala
+```scala
+@RegisterClass
+class SomeObject extends Object {
+    @RegisterFunction
+    def onReverseChanged(boolean reverse): Unit = {
+        println(s"Value of reverse has changed: $reverse")
+    }
+}
+
+@RegisterClass
+class AnotherObject extends Object {
+    @RegisterSignal("reverse")
+    val mySignal: Signal1[Boolean] = Signal1.create(this, "mySignal")
+
+    private val targetObject = new SomeObject()
+
+    public AnotherObject() {
+        // Here are 3 different ways to connect a signal to a registered method. The method reference syntax is not implemented for Scala.
+        mySignal.connect(Callable.create(targetObject, StringNames.toGodotName("onReverseChanged"))) // The recommanded way.
+        mySignal.connect(Callable.create(targetObject, "on_reverse_changed")) // Unsafe, try to use snake_case in your code as least as possible.
+        connect("my_signal", Callable.create(targetObject, "on_reverse_changed")) // Really, don't do that.
+    }
+}
+```
+///
+
 You can also use Kotlin lambdas directly to subscribe to signals
 
 ```kt

harness/tests/FreeformRegistrationFileTestClass.gdj

@@ -3,15 +3,13 @@
 
 registeredName = FreeformRegistrationFileTestClass
 fqName = godot.tests.freeform.FreeformRegistrationFileTestClass
-relativeSourcePath = src/main/kotlin/godot/tests/freeform/FreeformRegistrationFileTestClass.kt
 baseType = Node
 supertypes = [
     godot.api.Node,
 	godot.api.Object,
 	godot.core.KtObject,
 	godot.common.interop.NativeWrapper,
-	godot.common.interop.NativePointer,
-	kotlin.Any
+	godot.common.interop.NativePointer
 ]
 signals = [
 

harness/tests/build.gradle.kts

@@ -37,6 +37,7 @@ godot {
 
     // uncomment to test ios
 //    isIOSExportEnabled.set(true)
+
 }
 
 dependencies {

harness/tests/project.godot

@@ -12,7 +12,7 @@ config_version=5
 
 config/name="Godot Kotlin Tests"
 run/main_scene="res://test/GutTests.tscn"
-config/features=PackedStringArray("4.4")
+config/features=PackedStringArray("4.3")
 config/icon="res://icon.png"
 
 [debug]

harness/tests/scala_test_scene.tscn

@@ -0,0 +1,10 @@
+[gd_scene load_steps=2 format=3 uid="uid://c27pq6lr7xver"]
+
+[ext_resource type="Script" path="res://scripts/godot/tests/ScalaTestClass.gdj" id="1_ls5ji"]
+
+[node name="ScalaTestScene" type="Node3D"]
+script = ExtResource("1_ls5ji")
+
+[node name="Button" type="Button" parent="."]
+offset_right = 8.0
+offset_bottom = 8.0