fix(modelql): return the concept type instead of the link type after node creation steps

Author: mhuster23

model-api-gen-gradle-test/kotlin-generation/src/test/kotlin/org/modelix/modelql/typed/TypedModelQLTest.kt

@@ -360,4 +360,15 @@ abstract class TypedModelQLTest {
 
         assertTrue { actual.instanceOf(C_XmlDocument) }
     }
+
+    @Test
+    fun `write operations return typed nodes`() = runTest { client ->
+        val name = client.query { root ->
+            root.children("classes").ofConcept(C_ClassConcept)
+                .first()
+                .addToMember(C_StaticMethodDeclaration)
+                .name
+        }
+        assertEquals("", name)
+    }
 }

model-api-gen/src/main/kotlin/org/modelix/metamodel/generator/internal/ModelQLExtensionsGenerator.kt

@@ -23,8 +23,9 @@ import com.squareup.kotlinpoet.ParameterSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeVariableName
 import com.squareup.kotlinpoet.asTypeName
-import org.modelix.metamodel.ITypedConcept
+import org.modelix.metamodel.IConceptOfTypedNode
 import org.modelix.metamodel.generator.MetaModelGenerator
 import org.modelix.metamodel.generator.NameConfig
 import org.modelix.metamodel.generator.ProcessedChildLink
@@ -159,9 +160,10 @@ internal class ModelQLExtensionsGenerator(
 
     private fun FileSpec.Builder.addChildSetter(childLink: ProcessedChildLink) {
         val targetType = childLink.type.resolved.nodeWrapperInterfaceType()
-        val returnType = IMonoStep::class.asTypeName().parameterizedBy(targetType)
+        val outType = TypeVariableName("Out", targetType)
+        val returnType = IMonoStep::class.asTypeName().parameterizedBy(outType)
         val receiverType = IMonoStep::class.asTypeName().parameterizedBy(concept.nodeWrapperInterfaceType())
-        val conceptParameter = ParameterSpec.builder("concept", ITypedConcept::class.asTypeName()).apply {
+        val conceptParameter = ParameterSpec.builder("concept", IConceptOfTypedNode::class.asTypeName().parameterizedBy(outType)).apply {
             if (!childLink.type.resolved.abstract) {
                 defaultValue("%T", childLink.type.resolved.conceptWrapperInterfaceClass())
             }
@@ -170,6 +172,7 @@ internal class ModelQLExtensionsGenerator(
         val funName = if (childLink.multiple) childLink.adderMethodName() else childLink.setterName()
 
         val funSpec = FunSpec.builder(funName).runBuild {
+            addTypeVariable(outType)
             returns(returnType)
             receiver(receiverType)
             addParameter(conceptParameter)

modelql-typed/src/commonMain/kotlin/org/modelix/modelql/typed/TypedModelQL.kt

@@ -144,15 +144,15 @@ object TypedModelQL {
         return input.untyped().flatMap { it.children(link.untyped().key()) }.typedUnsafe(link.getTypedChildConcept().getInstanceInterface())
     }
 
-    fun <ParentT : ITypedNode, ChildT : ITypedNode> addNewChild(input: IMonoStep<ParentT>, link: ITypedChildListLink<ChildT>, index: Int = -1, concept: ITypedConcept): IMonoStep<ChildT> {
+    fun <ParentT : ITypedNode, ChildT : ITypedNode, Out : ChildT> addNewChild(input: IMonoStep<ParentT>, link: ITypedChildListLink<ChildT>, index: Int = -1, concept: IConceptOfTypedNode<Out>): IMonoStep<Out> {
         val conceptRef = ConceptReference(concept.untyped().getUID())
-        return input.untyped().addNewChild(link.untyped(), index, conceptRef).typedUnsafe(link.getTypedChildConcept().getInstanceInterface())
+        return input.untyped().addNewChild(link.untyped(), index, conceptRef).ofConcept(concept)
     }
 
-    fun <ParentT : ITypedNode, ChildT : ITypedNode> setChild(input: IMonoStep<ParentT>, link: ITypedSingleChildLink<ChildT>, concept: ITypedConcept): IMonoStep<ChildT> {
+    fun <ParentT : ITypedNode, ChildT : ITypedNode, Out : ChildT> setChild(input: IMonoStep<ParentT>, link: ITypedSingleChildLink<ChildT>, concept: IConceptOfTypedNode<Out>): IMonoStep<Out> {
         val conceptRef = ConceptReference(concept.untyped().getUID())
         input.untyped().children(link.untyped().key()).firstOrNull().mapIfNotNull { it.remove() }
-        return input.untyped().addNewChild(link.untyped(), conceptRef).typedUnsafe(link.getTypedChildConcept().getInstanceInterface())
+        return input.untyped().addNewChild(link.untyped(), conceptRef).ofConcept(concept)
     }
 
     fun <SourceT : ITypedNode, TargetT : ITypedNode> reference(input: IMonoStep<SourceT>, link: ITypedReferenceLink<TargetT>): IMonoStep<TargetT> {