Abstract class registration

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/EntryGenerator.kt

@@ -2,7 +2,6 @@ package godot.entrygenerator
 
 import godot.entrygenerator.checks.ConstructorArgCountCheck
 import godot.entrygenerator.checks.ConstructorOverloadingCheck
-import godot.entrygenerator.checks.DefaultConstructorCheck
 import godot.entrygenerator.checks.FunctionArgCountCheck
 import godot.entrygenerator.checks.LateinitPropertyCheck
 import godot.entrygenerator.checks.NullablePropertyCheck
@@ -106,7 +105,6 @@ object EntryGenerator {
         sourceFiles: List<SourceFile>
     ): Boolean {
         return listOf(
-            DefaultConstructorCheck(logger, sourceFiles).execute(),
             ConstructorArgCountCheck(logger, sourceFiles).execute(),
             ConstructorOverloadingCheck(logger, sourceFiles).execute(),
 

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/filebuilder/ClassRegistrarFileBuilder.kt

@@ -45,11 +45,6 @@ class ClassRegistrarFileBuilder(
                 )
             }
         }
-        .let { classBuilder ->
-            if (registeredClass.isAbstract) {
-                classBuilder.addKdoc("Registrar for abstract class. Does not register any members as it's only used for default value providing if any properties with default values are provided in the abstract class. Members of this abstract class are registered by the inheriting registrars")
-            } else classBuilder
-        }
 
     private val className = ClassName(registeredClass.containingPackage, registeredClass.name)
 
@@ -59,29 +54,24 @@ class ClassRegistrarFileBuilder(
         .addParameter("registry", ClassName(godotRegistrationPackage, GodotKotlinJvmTypes.classRegistry))
         .beginControlFlow("with(registry)") //START: with registry
         .let { funSpecBuilder ->
-            if (!registeredClass.isAbstract) {
-                val superClasses = registeredClass.supertypes.mapNotNull { supertype ->
-                    //Used to implement script inheritance methods, so we remove base types and abstract parents.
-                    val value = if (supertype is RegisteredClass && !supertype.isAbstract) {
-                        "\"${supertype.registeredName}\""
-                    } else {
-                        null
-                    }
-                    value
-                }.reduceOrNull { statement, name -> "$statement,$name" } ?: ""
-                funSpecBuilder.beginControlFlow(
-                    "registerClass<%T>(listOf($superClasses),·%T::class,·${registeredClass.isTool},·%S,·%S,·%S,·%S)·{",
-                    className,
-                    className,
-                    registeredClass.godotBaseClass,
-                    registeredClass.registeredName,
-                    registeredClass.relativeSourcePath,
-                    compilationTimeRelativeRegistrationFilePath,
-                ) //START: registerClass
-            } else {
-                funSpecBuilder
-                    .addComment("Abstract classes don't need to have any members to be registered")
-            }
+            val superClasses = registeredClass.supertypes.mapNotNull { supertype ->
+                //Used to implement script inheritance methods, so we remove base types
+                val value = if (supertype is RegisteredClass) {
+                    "\"${supertype.registeredName}\""
+                } else {
+                    null
+                }
+                value
+            }.reduceOrNull { statement, name -> "$statement,$name" } ?: ""
+            funSpecBuilder.beginControlFlow(
+                "registerClass<%T>(listOf($superClasses),·%T::class,·${registeredClass.isAbstract},·${registeredClass.isTool},·%S,·%S,·%S,·%S)·{",
+                className,
+                className,
+                registeredClass.godotBaseClass,
+                registeredClass.registeredName,
+                registeredClass.relativeSourcePath,
+                compilationTimeRelativeRegistrationFilePath,
+            ) //START: registerClass
         }
 
 
@@ -92,18 +82,14 @@ class ClassRegistrarFileBuilder(
 
         if (!registeredClass.isAbstract) {
             ConstructorRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
-            FunctionRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
-            SignalRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
-            PropertyRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
         }
+        FunctionRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
+        SignalRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
+        PropertyRegistrationGenerator.generate(registeredClass, className, registerClassControlFlow)
 
         classRegistrarBuilder.addFunction(
             registerClassControlFlow
-                .let { funSpecBuilder ->
-                    if (!registeredClass.isAbstract) {
-                        funSpecBuilder.endControlFlow() //END: registerClass
-                    } else funSpecBuilder
-                }
+                .endControlFlow() //END: registerClass
                 .endControlFlow() //END: with registry
                 .build()
         )

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/model/RegisteredClass.kt

@@ -23,11 +23,7 @@ data class RegisteredClass(
         get() = annotations.getAnnotation<ToolAnnotation>() != null
 
     internal val godotBaseClass: String
-        get() = if (isAbstract) {
-            ""
-        } else {
-            supertypes
-                .first { it.annotations.hasAnnotation<GodotBaseTypeAnnotation>() }
-                .name
-        }
+        get() = supertypes
+            .first { it.annotations.hasAnnotation<GodotBaseTypeAnnotation>() }
+            .name
 }

kt/entry-generation/godot-kotlin-symbol-processor/src/main/kotlin/godot/annotation/processor/ext/ksClassDeclarationExt.kt

@@ -9,6 +9,7 @@ import com.google.devtools.ksp.symbol.ClassKind
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.google.devtools.ksp.symbol.KSFunctionDeclaration
 import com.google.devtools.ksp.symbol.KSPropertyDeclaration
+import com.google.devtools.ksp.symbol.Modifier
 import godot.annotation.GodotApiMember
 import godot.annotation.Member
 import godot.annotation.processor.Settings
@@ -95,7 +96,7 @@ internal fun KSClassDeclaration.mapToClazz(
             functions = registeredFunctions,
             signals = registeredSignals,
             properties = registeredProperties,
-            isAbstract = isAbstract(),
+            isAbstract = this.modifiers.contains(Modifier.ABSTRACT),
             isFqNameRegistrationEnabled = settings.isFqNameRegistrationEnabled,
             classNamePrefix = settings.classPrefix,
             symbolProcessorSource = this

kt/entry-generation/godot-kotlin-symbol-processor/src/main/kotlin/godot/annotation/processor/visitor/RegistrationAnnotationVisitor.kt

@@ -1,5 +1,6 @@
 package godot.annotation.processor.visitor
 
+import com.google.devtools.ksp.symbol.ClassKind
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.google.devtools.ksp.symbol.KSFile
 import com.google.devtools.ksp.symbol.KSVisitorVoid
@@ -36,9 +37,11 @@ internal class RegistrationAnnotationVisitor(
                         if (declaration.hasCompilationErrors()) {
                             null
                         } else {
-                            val clazz = declaration.mapToClazz(settings)
-                            if (clazz is RegisteredClass) {
-                                clazz
+                            if (declaration.classKind == ClassKind.CLASS) {
+                                val clazz = declaration.mapToClazz(settings)
+                                if (clazz is RegisteredClass) {
+                                    clazz
+                                } else null
                             } else null
                         }
                     }

kt/godot-library/src/main/kotlin/godot/core/KtClass.kt

@@ -13,7 +13,8 @@ data class KtClass<T : KtObject>(
     private val _functions: Map<String, KtFunction<T, *>>,
     private val _notificationFunctions: List<Any.(Int) -> Unit>,
     private val _signalInfos: Map<String, KtSignalInfo>,
-    val baseGodotClass: String
+    val baseGodotClass: String,
+    val isAbstract: Boolean,
 ) {
     val registeredSupertypes: Array<String>
         get() = _registeredSupertypes.toTypedArray()

kt/godot-library/src/main/kotlin/godot/registration/Registration.kt

@@ -77,7 +77,8 @@ class ClassBuilderDsl<T : KtObject>(
     private val relativeSourcePath: String,
     private val compilationTimeRelativeRegistrationFilePath: String,
     private val superClasses: List<String>,
-    private val baseGodotClass: String
+    private val baseGodotClass: String,
+    private val isAbstract: Boolean,
 ) {
     private val constructors = mutableMapOf<Int, KtConstructor<T>>()
 
@@ -1274,7 +1275,6 @@ class ClassBuilderDsl<T : KtObject>(
     }
 
     internal fun build(): KtClass<T> {
-        check(constructors.isNotEmpty()) { "Please provide at least one constructor." }
         // Constraints.MAX_CONSTRUCTOR_ARG_COUNT + 1 because we have no arg constructor.
         val constructorArray = arrayOfNulls<KtConstructor<T>>(Constraints.MAX_CONSTRUCTOR_ARG_COUNT + 1)
         constructors.forEach {
@@ -1290,7 +1290,8 @@ class ClassBuilderDsl<T : KtObject>(
             _functions = functions,
             _notificationFunctions = notificationFunctions,
             _signalInfos = signals,
-            baseGodotClass = baseGodotClass
+            baseGodotClass = baseGodotClass,
+            isAbstract = isAbstract,
         )
     }
 }
@@ -1305,14 +1306,15 @@ class ClassRegistry(
     fun <T : KtObject> registerClass(
         superClass: List<String>,
         kClass: KClass<out KtObject>,
+        isAbstract: Boolean = false,
         isTool: Boolean = false,
         baseGodotClass: String,
         registeredName: String,
         relativeSourcePath: String,
         compilationTimeRelativeRegistrationFilePath: String,
         cb: ClassBuilderDsl<T>.() -> Unit
     ) {
-        val builder = ClassBuilderDsl<T>(registeredName, relativeSourcePath, compilationTimeRelativeRegistrationFilePath, superClass, baseGodotClass)
+        val builder = ClassBuilderDsl<T>(registeredName, relativeSourcePath, compilationTimeRelativeRegistrationFilePath, superClass, baseGodotClass, isAbstract)
         builder.cb()
         TypeManager.registerUserType(registeredName, kClass)
         registerClass(builder.build())