Fixed extended classes and constructors

Author: Saturn745

src/main/kotlin/extensions/JavaParser.kt

@@ -9,23 +9,38 @@ class LuaEmitter {
         val sb = StringBuilder()
         sb.appendLine("-- ${parsedClass.packageName}.${parsedClass.name}")
         sb.appendLine(
-            "---@class ${parsedClass.name} ${
-                if (parsedClass.extendedTypes.isNotEmpty()) parsedClass.extendedTypes.joinToString(
-                    " : "
-                ) else ""
+            "---@class ${parsedClass.name}${
+                if (parsedClass.extendedTypes.isNotEmpty() || parsedClass.implementedTypes.isNotEmpty())
+                    ": " + (parsedClass.extendedTypes + parsedClass.implementedTypes).joinToString(", ")
+                else ""
             }"
         )
+
+        // Process fields (variables)
+        parsedClass.fields.forEach { field ->
+            sb.appendLine("---@field ${field.name} ${mapJavaTypeToLua(field.type)}")
+        }
+
+        parsedClass.constructors.forEach { constructor ->
+            val doc = extractJavaDocInfo(constructor.comment)
+
+            val params = constructor.parameters.joinToString(", ") { param ->
+                val paramName = param.name
+                val luaType = mapJavaTypeToLua(param.type)
+                "$paramName: $luaType${if (!param.required) "?" else ""}"
+            }
+
+            val returnType = mapJavaTypeToLua(constructor.returnType)
+            sb.appendLine("---@overload fun($params): $returnType ${doc.returnComment ?: ""}")
+        }
+
         sb.appendLine("local ${parsedClass.name} = {}\n")
 
         val docInfo = extractJavaDocInfo(parsedClass.classComment)
         if (docInfo.mainComment.isNotBlank()) {
             sb.insert(0, "--- ${docInfo.mainComment}\n")
         }
 
-        // Process fields (variables)
-        parsedClass.fields.forEach { field ->
-            sb.appendLine("---@field ${field.name} ${mapJavaTypeToLua(field.type)}")
-        }
 
         // Process methods
         parsedClass.methods.forEach { method ->

src/main/kotlin/generator/LuaEmitter.kt

@@ -2,6 +2,7 @@ package parser
 
 import com.github.javaparser.JavaParser
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration
+import com.github.javaparser.ast.body.ConstructorDeclaration
 import com.github.javaparser.ast.body.EnumDeclaration
 import com.github.javaparser.ast.body.FieldDeclaration
 import com.github.javaparser.ast.body.MethodDeclaration
@@ -14,9 +15,7 @@ import java.util.jar.JarEntry
 import java.util.jar.JarFile
 
 class JavaSourceParser : ClassParser {
-
     private val parser = JavaParser()
-    private val combinedTypeSolver = CombinedTypeSolver() // Ensure this is properly initialized
 
     override fun parse(jar: JarFile): List<ParsedClass> {
         val parsedClasses = mutableListOf<ParsedClass>()
@@ -60,31 +59,45 @@ class JavaSourceParser : ClassParser {
             val methods = cls.methods.map { parseMethod(it, cls.nameAsString) }
             val fields = cls.fields.flatMap { parseField(it) }
 
-            // Resolve extended types and their methods
-            val extendedTypes = cls.extendedTypes.mapNotNull { type ->
-                val resolvedType = type.resolveOrNull()
-                resolvedType?.qualifiedName
-            }
-
-            /*val extendedMethods = extendedTypes.flatMap { qualifiedName ->
-                val resolvedClass = combinedTypeSolver.tryToSolveType(qualifiedName).orElse(null)
-                resolvedClass?.methods?.map { parseMethod(it.declaration, resolvedClass.name) } ?: emptyList()
-            }*/
+            // Gather all constructors and parse them
 
             parsedClass = ParsedClass(
                 name = cls.nameAsString,
                 packageName = pkgName,
                 fields = fields,
                 methods = methods, // Combine methods
                 classComment = cls.comment.map { extractJavaDocInfo(it.content).mainComment }.orElse(null),
-                //extendedTypes = extendedTypes, // Broken at the moment
+                extendedTypes = cls.extendedTypes.map { it.asString() },
+                implementedTypes = cls.implementedTypes.map { it.asString() },
+                constructors = cls.constructors.map { parseConstructor(it, cls.nameAsString) },
                 isEnum = false
             )
         }
 
         return parsedClass
     }
 
+    private fun parseConstructor(constructor: ConstructorDeclaration, className: String): ParsedMethod {
+        return ParsedMethod(
+            name = constructor.nameAsString,
+            returnType = className,
+            parameters = constructor.parameters.map { param ->
+                // Check for nullability in the parameter type. Not sure why but it seems to include annotations in the type string
+                val isNullableComment = param.type.toString()?.contains("@Nullable") ?: false
+
+                ParsedParameter(
+                    name = param.nameAsString,
+                    type = param.type.toString().replace("@Nullable ", ""),
+                    required = !isNullableComment,
+                )
+            },
+            comment = constructor.comment.map { extractJavaDocInfo(it.content).mainComment }.orElse(null),
+            isDeprecated = constructor.annotations.any { it.nameAsString == "Deprecated" },
+            isAsync = false, // Constructors are not async
+            isConstructor = true
+        )
+    }
+
     private fun parseMethod(method: MethodDeclaration, className: String): ParsedMethod {
         return ParsedMethod(
             name = method.nameAsString,
@@ -101,7 +114,10 @@ class JavaSourceParser : ClassParser {
             },
             comment = method.comment.map { extractJavaDocInfo(it.content).mainComment }.orElse(null),
             isDeprecated = method.annotations.any { it.nameAsString == "Deprecated" },
-            isAsync = method.nameAsString.contains("Async", ignoreCase = true) // Most Bukkit methods that are async have "Async" in their name
+            isAsync = method.nameAsString.contains(
+                "Async",
+                ignoreCase = true
+            ) // Most Bukkit methods that are async have "Async" in their name
         )
     }
 

src/main/kotlin/parser/JavaSourceParser.kt

@@ -7,5 +7,7 @@ data class ParsedClass(
     val fields: List<ParsedField>,
     val classComment: String?,
     val extendedTypes : List<String> = emptyList(),
+    val implementedTypes : List<String> = emptyList(),
+    val constructors : List<ParsedMethod> = emptyList(),
     val isEnum: Boolean = false,
 )

src/main/kotlin/parser/ParsedClass.kt

@@ -6,7 +6,8 @@ data class ParsedMethod(
     val parameters: List<ParsedParameter>,
     val comment: String?,
     val isDeprecated: Boolean = false,
-    val isAsync: Boolean = false
+    val isAsync: Boolean = false,
+    val isConstructor: Boolean = false,
 )
 
 data class ParsedParameter(

src/main/kotlin/parser/ParsedMethod.kt

@@ -1,7 +1,6 @@
 package util
 
 fun mapJavaTypeToLua(javaType: String): String {
-    println(javaType)
     return when {
         javaType.startsWith("List<") -> {
             val genericType = javaType.substringAfter("List<").substringBeforeLast(">")