Add support for nested classes and enums

Author: Saturn745

src/main/kotlin/Main.kt

@@ -36,7 +36,7 @@ fun main(args: Array<String>) {
 
         parsedClasses.forEach { parsedClass ->
             val luaOutput = luaEmitter.emit(parsedClass)
-            val outputFile = File(outputDir, "${parsedClass.packageName}.${parsedClass.name}.lua")
+            val outputFile = File(outputDir, "${parsedClass.fqcn}.lua")
             outputFile.writeText(luaOutput)
             println("Generated Lua stubs for ${parsedClass.name} in ${outputFile.absolutePath}")
         }

src/main/kotlin/generator/LuaEmitter.kt

@@ -8,9 +8,9 @@ class LuaEmitter {
     fun emit(parsedClass: ParsedClass): String {
         val sb = StringBuilder()
         sb.appendLine("---@meta")
-        sb.appendLine("-- ${parsedClass.packageName}.${parsedClass.name}")
+        sb.appendLine("-- ${parsedClass.fqcn}")
         sb.appendLine(
-            "---@class ${parsedClass.packageName}.${parsedClass.name}${
+            "---@class ${parsedClass.fqcn}${
                 if (parsedClass.extendedTypes.isNotEmpty() || parsedClass.implementedTypes.isNotEmpty())
                     ": " + (parsedClass.extendedTypes + parsedClass.implementedTypes).joinToString(", ")
                 else ""

src/main/kotlin/parser/JavaSourceParser.kt

@@ -91,48 +91,80 @@ class JavaSourceParser(private val jarFiles: List<File>) : ClassParser {
 
         // Handle enum
         cu.findFirst(EnumDeclaration::class.java).ifPresent { enumDecl ->
-            parsedClass = ParsedClass(
-                name = enumDecl.nameAsString,
-                packageName = pkgName,
-                fields = enumDecl.entries.map {
-                    ParsedField(
-                        name = it.nameAsString,
-                        type = enumDecl.fullyQualifiedName.get(),
-                        visibility = Visibility.PUBLIC,
-                        comment = extractMainComment(it.javadoc.getOrNull())
-                    )
-                },
-                methods = emptyList(),
-                classComment = extractMainComment(enumDecl.javadoc.getOrNull()),
-                isEnum = true
-            )
-            parsedClasses[enumDecl.fullyQualifiedName.toString()] = parsedClass!!
+            parsedClass = parseEnum(enumDecl, pkgName)
+            parsedClasses[enumDecl.fullyQualifiedName.get()] = parsedClass!!
         }
 
         // Handle class or interface
         cu.findFirst(ClassOrInterfaceDeclaration::class.java).ifPresent { cls ->
-            val methods = cls.methods.map { parseMethod(it, cls.nameAsString) }
-            val fields = cls.fields.flatMap { parseField(it) }
-
-            // Gather all constructors and parse them
-
-            parsedClass = ParsedClass(
-                name = cls.nameAsString,
-                packageName = pkgName,
-                fields = fields,
-                methods = methods, // Combine methods
-                classComment = extractMainComment(cls.javadoc.getOrNull()),
-                extendedTypes = cls.extendedTypes.map { getFullyQualifiedName(it) },
-                implementedTypes = cls.implementedTypes.map { getFullyQualifiedName(it) },
-                constructors = cls.constructors.map { parseConstructor(it, cls.fullyQualifiedName.get()) },
-                isEnum = false
-            )
-            parsedClasses[cls.fullyQualifiedName.toString()] = parsedClass!!
+            parsedClass = parseClassOrInterface(cls, pkgName)
+            parsedClasses[cls.fullyQualifiedName.get()] = parsedClass!!
         }
 
         return parsedClass
     }
 
+    private fun parseEnum(enumDecl: EnumDeclaration, pkgName: String): ParsedClass {
+        return ParsedClass(
+            name = enumDecl.nameAsString,
+            packageName = pkgName,
+            fqcn = enumDecl.fullyQualifiedName.get(),
+            fields = enumDecl.entries.map {
+                ParsedField(
+                    name = it.nameAsString,
+                    type = enumDecl.fullyQualifiedName.get(),
+                    visibility = Visibility.PUBLIC,
+                    comment = extractMainComment(it.javadoc.getOrNull())
+                )
+            },
+            methods = emptyList(),
+            classComment = extractMainComment(enumDecl.javadoc.getOrNull()),
+            isEnum = true
+        )
+    }
+
+    private fun parseClassOrInterface(cls: ClassOrInterfaceDeclaration, pkgName: String): ParsedClass {
+        val methods = cls.methods.map { parseMethod(it, cls.nameAsString) }
+        val fields = cls.fields.flatMap { parseField(it) }
+
+        // Parse nested classes and enums, add as fields and also parse them recursively
+        val nestedClassFields = cls.members.filterIsInstance<ClassOrInterfaceDeclaration>().map { nested ->
+            val nestedParsed = parseClassOrInterface(nested, pkgName)
+            parsedClasses[nested.fullyQualifiedName.get()] = nestedParsed
+            ParsedField(
+                name = nested.nameAsString,
+                type = nested.fullyQualifiedName.orElse(nested.nameAsString),
+                visibility = Visibility.fromString(nested.accessSpecifier.toString().uppercase()),
+                comment = extractMainComment(nested.javadoc.getOrNull()),
+                isNestedClass = true
+            )
+        }
+        val nestedEnumFields = cls.members.filterIsInstance<EnumDeclaration>().map { nestedEnum ->
+            val nestedParsed = parseEnum(nestedEnum, pkgName)
+            parsedClasses[nestedEnum.fullyQualifiedName.get()] = nestedParsed
+            ParsedField(
+                name = nestedEnum.nameAsString,
+                type = nestedEnum.fullyQualifiedName.orElse(nestedEnum.nameAsString),
+                visibility = Visibility.PUBLIC,
+                comment = extractMainComment(nestedEnum.javadoc.getOrNull()),
+                isNestedClass = true
+            )
+        }
+
+        return ParsedClass(
+            name = cls.nameAsString,
+            packageName = pkgName,
+            fqcn = cls.fullyQualifiedName.get(),
+            fields = fields + nestedClassFields + nestedEnumFields,
+            methods = methods,
+            classComment = extractMainComment(cls.javadoc.getOrNull()),
+            extendedTypes = cls.extendedTypes.map { getFullyQualifiedName(it) },
+            implementedTypes = cls.implementedTypes.map { getFullyQualifiedName(it) },
+            constructors = cls.constructors.map { parseConstructor(it, cls.fullyQualifiedName.get()) },
+            isEnum = false
+        )
+    }
+
     private fun parseConstructor(constructor: ConstructorDeclaration, className: String): ParsedMethod {
         return ParsedMethod(
             name = constructor.nameAsString,

src/main/kotlin/parser/ParsedClass.kt

@@ -3,6 +3,7 @@ package parser
 data class ParsedClass(
     val name: String,
     val packageName: String,
+    val fqcn: String,
     val methods: List<ParsedMethod>,
     val fields: List<ParsedField>,
     val classComment: String?,

src/main/kotlin/parser/ParsedField.kt

@@ -4,5 +4,6 @@ data class ParsedField(
     val name: String,
     val type: String,
     val visibility: Visibility,
-    val comment: String?
+    val comment: String?,
+    val isNestedClass: Boolean = false
 )