fix: various issues with Python codegen of constructors

Author: lars-reimann

server/src/main/kotlin/com/larsreimann/api_editor/codegen/PythonCodeGenerator.kt

@@ -118,7 +118,7 @@ private fun buildSeparators(
 fun PythonClass.toPythonCode(): String {
     var formattedClass = "class $name:\n"
     if (constructor != null) {
-        formattedClass += buildConstructor().prependIndent("    ")
+        formattedClass += buildConstructor(this).prependIndent("    ")
     }
     if (!methods.isEmpty()) {
         if (constructor != null) {
@@ -133,21 +133,24 @@ private fun buildAllFunctions(pythonClass: PythonClass): List<String> {
     return pythonClass.methods.map { it.toPythonCode().prependIndent("    ") }
 }
 
-private fun PythonClass.buildConstructor(): String {
-    var constructorSeparator = ""
-    val assignments = buildAttributeAssignments(this).joinToString("\n".repeat(1))
-    if (assignments.isNotBlank()) {
-        constructorSeparator = "\n"
-    }
-    var constructorSuffix = constructorSeparator + assignments
-    constructorSuffix += this.constructor?.buildConstructorCall() ?: ""
-    if (constructorSuffix.isBlank()) {
-        constructorSuffix = "pass"
+private fun buildConstructor(`class`: PythonClass) = buildString {
+    appendLine("def __init__(${buildParameters(`class`.constructor?.parameters.orEmpty())}):")
+
+    appendIndented(4) {
+        val attributes = buildAttributeAssignments(`class`).joinToString("\n")
+        if (attributes.isNotBlank()) {
+            append("$attributes\n\n")
+        }
+
+        val constructorCall = `class`.constructor?.buildConstructorCall() ?: ""
+        if (constructorCall.isNotBlank()) {
+            append(constructorCall)
+        }
+
+        if (attributes.isBlank() && constructorCall.isBlank()) {
+            append("pass")
+        }
     }
-    return """
-      |def __init__(${buildParameters(this.constructor?.parameters.orEmpty())}):
-      |${(constructorSuffix).prependIndent("    ")}
-      """.trimMargin()
 }
 
 private fun PythonConstructor.buildConstructorCall(): String {

server/src/main/kotlin/com/larsreimann/api_editor/transformation/Preprocessor.kt

@@ -10,6 +10,7 @@ import com.larsreimann.api_editor.mutable_model.PythonFunction
 import com.larsreimann.api_editor.mutable_model.PythonPackage
 import com.larsreimann.api_editor.mutable_model.PythonParameter
 import com.larsreimann.api_editor.mutable_model.PythonReference
+import com.larsreimann.modeling.closest
 import com.larsreimann.modeling.descendants
 
 /**
@@ -63,12 +64,16 @@ private fun PythonClass.addOriginalDeclarations() {
 }
 
 private fun PythonFunction.addOriginalDeclarations() {
+    val containingClass = closest<PythonClass>()
     this.callToOriginalAPI = PythonCall(
         receiver = when {
+            name == "__init__" && containingClass != null -> containingClass.originalClass!!.qualifiedName
             isMethod() -> "self.instance.$name"
             else -> qualifiedName()
         },
-        arguments = this.parameters.map {
+        arguments = this.parameters
+            .filter { !it.isImplicit() }
+            .map {
             PythonArgument(
                 name = when (it.assignedBy) {
                     PythonParameterAssignment.NAME_ONLY -> it.name

server/src/test/kotlin/com/larsreimann/api_editor/transformation/PreprocessorTest.kt

@@ -181,20 +181,13 @@ class PreprocessorTest {
         }
 
         @Test
-        fun `should add original declaration to class methods`() {
+        fun `should add original declaration to class methods but skip implicit parameters`() {
             testPackage.addOriginalDeclarations()
 
             val callToOriginalAPI = testMethod.callToOriginalAPI.shouldNotBeNull()
             callToOriginalAPI.receiver shouldBe "self.instance.testMethod"
 
-            val arguments = callToOriginalAPI.arguments
-            arguments.shouldHaveSize(1)
-
-            arguments[0].name.shouldBeNull()
-            arguments[0].value.asClue {
-                it.shouldBeInstanceOf<PythonReference>()
-                it.declaration shouldBe testMethodParameter
-            }
+            callToOriginalAPI.arguments.shouldHaveSize(0)
         }
     }