fix: codegen of Python methods

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

@@ -3,9 +3,11 @@ package com.larsreimann.api_editor.codegen
 import com.larsreimann.api_editor.model.ComparisonOperator
 import com.larsreimann.api_editor.model.PythonParameterAssignment
 import com.larsreimann.api_editor.mutable_model.MutablePythonClass
+import com.larsreimann.api_editor.mutable_model.MutablePythonConstructor
 import com.larsreimann.api_editor.mutable_model.MutablePythonFunction
 import com.larsreimann.api_editor.mutable_model.MutablePythonModule
 import com.larsreimann.api_editor.mutable_model.MutablePythonParameter
+import com.larsreimann.api_editor.mutable_model.OriginalPythonParameter
 
 /**
  * Builds a string containing the formatted module content
@@ -117,6 +119,7 @@ private fun MutablePythonClass.buildConstructor(): String {
         constructorSeparator = "\n"
     }
     var constructorSuffix = constructorSeparator + assignments
+    constructorSuffix += this.constructor?.buildConstructorCall() ?: ""
     if (constructorSuffix.isBlank()) {
         constructorSuffix = "pass"
     }
@@ -126,16 +129,25 @@ private fun MutablePythonClass.buildConstructor(): String {
       """.trimMargin()
 }
 
+private fun MutablePythonConstructor.buildConstructorCall(): String {
+    return "self.instance = ${callToOriginalAPI!!.qualifiedName}(${this.buildParameterCall()})"
+}
+
 /**
  * Builds a string containing the formatted function content
  * @receiver The function whose adapter content should be built
  * @return The string containing the formatted function content
  */
 fun MutablePythonFunction.toPythonCode(): String {
-    return """
+    val function = """
       |def $name(${buildParameters(this.parameters)}):
       |${(buildFunctionBody(this)).prependIndent("    ")}
       """.trimMargin()
+
+    return when {
+        isStaticMethod() -> "@staticmethod\n$function"
+        else -> function
+    }
 }
 
 private fun buildAttributeAssignments(pythonClass: MutablePythonClass): List<String> {
@@ -204,11 +216,23 @@ private fun buildFunctionBody(pythonFunction: MutablePythonFunction): String {
     if (formattedBoundaries.isNotBlank()) {
         formattedBoundaries = "$formattedBoundaries\n"
     }
+
+    if (!pythonFunction.isMethod() || pythonFunction.isStaticMethod()) {
+        return (
+            formattedBoundaries +
+                pythonFunction.originalFunction!!.qualifiedName +
+                "(" +
+                pythonFunction.buildParameterCall() +
+                ")"
+            )
+    }
+
     return (
         formattedBoundaries +
-            pythonFunction.originalFunction!!.qualifiedName +
+            "self.instance." +
+            pythonFunction.originalFunction!!.qualifiedName.split(".").last() +
             "(" +
-            buildParameterCall(pythonFunction) +
+            pythonFunction.buildParameterCall() +
             ")"
         )
 }
@@ -297,10 +321,28 @@ private fun buildBoundaryChecks(pythonFunction: MutablePythonFunction): List<Str
     return formattedBoundaries
 }
 
-private fun buildParameterCall(pythonFunction: MutablePythonFunction): String {
+private fun MutablePythonFunction.buildParameterCall(): String {
+    return buildParameterCall(
+        parameters,
+        originalFunction!!.parameters
+    )
+}
+
+private fun MutablePythonConstructor.buildParameterCall(): String {
+    return buildParameterCall(
+        parameters,
+        callToOriginalAPI!!.parameters
+    )
+}
+
+private fun buildParameterCall(
+    parameters: List<MutablePythonParameter>,
+    originalParameters: List<OriginalPythonParameter>
+): String {
+
     val formattedParameters: MutableList<String?> = ArrayList()
     val originalNameToValueMap: MutableMap<String, String?> = HashMap()
-    pythonFunction.parameters.forEach {
+    parameters.forEach {
         val value: String? =
             if (it.assignedBy == PythonParameterAssignment.CONSTANT || it.assignedBy == PythonParameterAssignment.ATTRIBUTE) {
                 it.defaultValue
@@ -309,7 +351,7 @@ private fun buildParameterCall(pythonFunction: MutablePythonFunction): String {
             }
         originalNameToValueMap[it.originalParameter!!.name] = value
     }
-    pythonFunction.originalFunction!!.parameters
+    originalParameters
         .filter { it.assignedBy != PythonParameterAssignment.IMPLICIT }
         .forEach {
             if (it.assignedBy === PythonParameterAssignment.NAME_ONLY) {

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

@@ -135,6 +135,7 @@ internal fun MutablePythonFunction.toSmlFunction(): SmlFunction {
 
     return createSmlFunction(
         name = stubName,
+        isStatic = isStaticMethod(),
         annotations = buildList {
             if (isPure) {
                 add(createSmlAnnotationUse("Pure"))

server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/Node.kt

@@ -181,11 +181,11 @@ open class Node {
             }
         }
 
-        operator fun getValue(node: Node, property: KProperty<*>): T? {
+        operator fun getValue(thisRef: Any?, property: KProperty<*>): T? {
             return this.node
         }
 
-        operator fun setValue(oldNode: Node, property: KProperty<*>, newNode: T?) {
+        operator fun setValue(thisRef: Any?, property: KProperty<*>, newNode: T?) {
             this.node = newNode
         }
     }
@@ -382,11 +382,11 @@ open class Node {
             handleMove(from, to)
         }
 
-        operator fun getValue(node: T, property: KProperty<*>): T? {
+        operator fun getValue(thisRef: Any?, property: KProperty<*>): T? {
             return this.node
         }
 
-        operator fun setValue(oldNode: T, property: KProperty<*>, newNode: T?) {
+        operator fun setValue(thisRef: Any?, property: KProperty<*>, newNode: T?) {
             this.node = newNode
         }
     }

server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/PythonAst.kt

@@ -90,7 +90,8 @@ class MutablePythonClass(
 }
 
 class MutablePythonConstructor(
-    parameters: List<MutablePythonParameter> = emptyList()
+    parameters: List<MutablePythonParameter> = emptyList(),
+    val callToOriginalAPI: OriginalPythonFunction? = null
 ) : MutablePythonAstNode() {
 
     val parameters = MutableContainmentList(parameters)
@@ -141,7 +142,8 @@ class MutablePythonFunction(
         yieldAll(results)
     }
 
-    fun isStatic() = "staticmethod" in decorators
+    fun isMethod() = parent is MutablePythonClass
+    fun isStaticMethod() = isMethod() && "staticmethod" in decorators
 }
 
 data class OriginalPythonFunction(

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

@@ -6,6 +6,7 @@ import com.larsreimann.api_editor.mutable_model.MutablePythonClass
 import com.larsreimann.api_editor.mutable_model.MutablePythonConstructor
 import com.larsreimann.api_editor.mutable_model.MutablePythonFunction
 import com.larsreimann.api_editor.mutable_model.MutablePythonPackage
+import com.larsreimann.api_editor.mutable_model.OriginalPythonFunction
 import com.larsreimann.api_editor.mutable_model.descendants
 
 /**
@@ -51,12 +52,36 @@ fun MutablePythonPackage.createConstructors() {
 }
 
 private fun MutablePythonClass.createConstructor() {
-    this.constructor = MutablePythonConstructor()
+    when (val constructorMethod = this.methods.firstOrNull { it.name == "__init__" }) {
+        null -> {
+            this.constructor = MutablePythonConstructor(
+                parameters = emptyList(),
+                callToOriginalAPI = OriginalPythonFunction(
+                    qualifiedName = this.qualifiedName()
+                )
+            )
+        }
+        else -> {
+            val qualifiedName = constructorMethod.originalFunction
+                ?.qualifiedName
+                ?.removeSuffix(".__init__")
+                ?: qualifiedName()
 
-    val constructorMethod = this.methods.firstOrNull { it.name == "__init__" } ?: return
+            val parameters = constructorMethod.originalFunction
+                ?.parameters
+                ?: emptyList()
 
-    this.constructor?.parameters?.addAll(constructorMethod.parameters.toList())
-    constructorMethod.release()
+            this.constructor = MutablePythonConstructor(
+                parameters = constructorMethod.parameters.toList(),
+                callToOriginalAPI = OriginalPythonFunction(
+                    qualifiedName = qualifiedName,
+                    parameters = parameters
+                )
+            )
+
+            constructorMethod.release()
+        }
+    }
 }
 
 /**

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

@@ -138,6 +138,18 @@ private fun MutablePythonParameter.updateParameterAssignment() {
 private fun MutablePythonParameter.isImplicit(): Boolean {
     val currentFunction = this.parent as? MutablePythonFunction ?: return false
     return currentFunction.parent is MutablePythonClass &&
-        !currentFunction.isStatic() &&
+        !currentFunction.isStaticMethod() &&
         currentFunction.parameters.firstOrNull() == this
 }
+
+/**
+ * Changes the name of implicit parameters to "self".
+ */
+fun MutablePythonPackage.normalizeNamesOfImplicitParameters() {
+    this.descendants()
+        .filterIsInstance<MutablePythonParameter>()
+        .filter { it.assignedBy == PythonParameterAssignment.IMPLICIT }
+        .forEach {
+            it.name = "self"
+        }
+}

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

@@ -20,6 +20,7 @@ private fun MutablePythonPackage.preprocess() {
     changeModulePrefix(newPrefix = "simpleml")
     replaceClassMethodsWithStaticMethods()
     updateParameterAssignment()
+    normalizeNamesOfImplicitParameters()
 }
 
 /**
@@ -40,5 +41,6 @@ private fun MutablePythonPackage.processAnnotations() {
 private fun MutablePythonPackage.postprocess() {
     removeEmptyModules()
     reorderParameters()
+    createConstructors()
     createAttributesForParametersOfConstructor()
 }