typed concepts are generated with default implementations instead impl classes

This simplifies the generated code a lot.
There no inheritance between the impl classes anymore.
The implementation of the members is not inherited through
multiple inheritance paths so no ambiguity that needs to be solved.

Author: slisson

metamodel-generator/src/main/kotlin/org/modelix/metamodel/generator/MetaModelGenerator.kt

@@ -93,7 +93,7 @@ class MetaModelGenerator(val outputDir: Path) {
             .addFileComment(headerComment)
             .addType(generateConceptObject(concept))
             .addType(generateConceptWrapperInterface(concept))
-            .addType(generateConceptWrapperImpl(concept))
+//            .addType(generateConceptWrapperImpl(concept))
             .addType(generateNodeWrapperInterface(concept))
             .addType(generateNodeWrapperImpl(concept))
             .apply {
@@ -139,8 +139,8 @@ class MetaModelGenerator(val outputDir: Path) {
     private fun generateConceptObject(concept: LanguageSet.ConceptInLanguage): TypeSpec {
         return TypeSpec.objectBuilder(concept.conceptObjectName()).apply {
             superclass(GeneratedConcept::class.asTypeName().parameterizedBy(
-                concept.nodeWrapperImplType(),
-                concept.conceptWrapperImplType()
+                concept.nodeWrapperInterfaceType(),
+                concept.conceptWrapperInterfaceType()
             ))
             addSuperclassConstructorParameter("%S", concept.concept.name)
             addSuperclassConstructorParameter(concept.concept.abstract.toString())
@@ -226,74 +226,40 @@ class MetaModelGenerator(val outputDir: Path) {
             }
             for (feature in concept.directFeatures()) {
                 when (val data = feature.data) {
-                    is PropertyData -> addProperty(PropertySpec.builder(feature.validName, GeneratedProperty::class.asClassName().parameterizedBy(data.asKotlinType())).build())
-                    is ChildLinkData -> addProperty(PropertySpec.builder(feature.validName, feature.generatedChildLinkType()).build())
-                    is ReferenceLinkData -> addProperty(PropertySpec.builder(feature.validName, feature.generatedReferenceLinkType()).build())
+                    is PropertyData -> addProperty(PropertySpec.builder(feature.validName, GeneratedProperty::class.asClassName().parameterizedBy(data.asKotlinType()))
+                        .getter(FunSpec.getterBuilder().addCode(feature.returnKotlinRef()).build())
+                        .build())
+                    is ChildLinkData -> addProperty(PropertySpec.builder(feature.validName, feature.generatedChildLinkType())
+                        .getter(FunSpec.getterBuilder().addCode(feature.returnKotlinRef()).build())
+                        .build())
+                    is ReferenceLinkData -> addProperty(PropertySpec.builder(feature.validName, feature.generatedReferenceLinkType())
+                        .getter(FunSpec.getterBuilder().addCode(feature.returnKotlinRef()).build())
+                        .build())
                 }
             }
 
             addType(TypeSpec.companionObjectBuilder().apply {
-                superclass(concept.conceptWrapperImplType())
+                addSuperinterface(concept.conceptWrapperInterfaceType())
                 val t = if (concept.concept.abstract) IConceptOfTypedNode::class else INonAbstractConcept::class
                 addSuperinterface(t.asTypeName().parameterizedBy(concept.nodeWrapperInterfaceType()))
                 addFunction(FunSpec.builder(IConceptOfTypedNode<*>::getInstanceInterface.name)
                     .addModifiers(KModifier.OVERRIDE)
                     .returns(KClass::class.asTypeName().parameterizedBy(concept.nodeWrapperInterfaceType()))
                     .addStatement("return %T::class", concept.nodeWrapperInterfaceType())
                     .build())
+                addFunction(FunSpec.builder(ITypedConcept::untyped.name)
+                    .returns(IConcept::class)
+                    .addModifiers(KModifier.OVERRIDE)
+                    .addStatement("return %T", concept.conceptObjectType())
+                    .build())
             }.build())
         }.build()
     }
 
-    private fun generateConceptWrapperImpl(concept: LanguageSet.ConceptInLanguage): TypeSpec {
-        return TypeSpec.classBuilder(concept.conceptWrapperImplType()).apply {
-            addModifiers(KModifier.OPEN)
-            if (concept.extends().isEmpty()) {
-            } else {
-                superclass(concept.extends().first().conceptWrapperImplType())
-                for (extended in concept.extends().drop(1)) {
-                    addSuperinterface(extended.conceptWrapperInterfaceType(), CodeBlock.of("%T", extended.conceptWrapperInterfaceType()))
-                }
-            }
-            addSuperinterface(concept.conceptWrapperInterfaceType())
-
-            primaryConstructor(FunSpec.constructorBuilder().addModifiers(KModifier.PROTECTED).build())
-
-            addFunction(FunSpec.builder(ITypedConcept::untyped.name)
-                .returns(IConcept::class)
-                .addModifiers(KModifier.OVERRIDE)
-                .addStatement("return %T", concept.conceptObjectType())
-                .build())
-
-            for (feature in concept.directFeaturesAndConflicts()) {
-                when (val data = feature.data) {
-                    is PropertyData -> {
-                        addProperty(PropertySpec.builder(feature.validName, GeneratedProperty::class.asClassName().parameterizedBy(data.asKotlinType()))
-                            .addModifiers(KModifier.OVERRIDE)
-                            .getter(FunSpec.getterBuilder().addCode(feature.returnKotlinRef()).build())
-                            .build())
-                    }
-                    is ChildLinkData -> {
-                        addProperty(PropertySpec.builder(feature.validName, feature.generatedChildLinkType())
-                            .addModifiers(KModifier.OVERRIDE)
-                            .getter(FunSpec.getterBuilder().addCode(feature.returnKotlinRef()).build())
-                            .build())
-                    }
-                    is ReferenceLinkData -> {
-                        addProperty(PropertySpec.builder(feature.validName, feature.generatedReferenceLinkType())
-                            .addModifiers(KModifier.OVERRIDE)
-                            .getter(FunSpec.getterBuilder().addCode(feature.returnKotlinRef()).build())
-                            .build())
-                    }
-                }
-            }
-        }.build()
-    }
-
     private fun generateNodeWrapperImpl(concept: LanguageSet.ConceptInLanguage): TypeSpec {
         return TypeSpec.classBuilder(concept.nodeWrapperImplType()).apply {
             addModifiers(KModifier.OPEN)
-            addProperty(PropertySpec.builder(TypedNodeImpl::_concept.name, concept.conceptWrapperImplType(), KModifier.OVERRIDE)
+            addProperty(PropertySpec.builder(TypedNodeImpl::_concept.name, concept.conceptWrapperInterfaceType(), KModifier.OVERRIDE)
                 .getter(FunSpec.getterBuilder().addStatement("""return %T""", concept.conceptWrapperInterfaceType()).build())
                 .build())
 
@@ -437,7 +403,7 @@ fun PropertyType.asKotlinType(): TypeName {
     }
 }
 fun String.parseClassName() = ClassName(substringBeforeLast("."), substringAfterLast("."))
-fun ConceptRef.conceptWrapperImplType() = ClassName(languageName, conceptName.conceptWrapperImplName())
+//fun ConceptRef.conceptWrapperImplType() = ClassName(languageName, conceptName.conceptWrapperImplName())
 fun ConceptRef.conceptWrapperInterfaceType() = ClassName(languageName, conceptName.conceptWrapperInterfaceName())
 fun ConceptRef.nodeWrapperImplType() = ClassName(languageName, conceptName.nodeWrapperImplName())
 fun ConceptRef.nodeWrapperInterfaceType() = ClassName(languageName, conceptName.nodeWrapperInterfaceName())
@@ -469,7 +435,7 @@ fun LanguageSet.ConceptInLanguage.conceptObjectType() = ClassName(language.name,
 fun LanguageSet.ConceptInLanguage.nodeWrapperImplName() = concept.nodeWrapperImplName()
 fun LanguageSet.ConceptInLanguage.nodeWrapperImplType() = ClassName(language.name, concept.nodeWrapperImplName())
 fun LanguageSet.ConceptInLanguage.nodeWrapperInterfaceType() = ClassName(language.name, concept.nodeWrapperInterfaceName())
-fun LanguageSet.ConceptInLanguage.conceptWrapperImplType() = ClassName(language.name, concept.conceptWrapperImplName())
+//fun LanguageSet.ConceptInLanguage.conceptWrapperImplType() = ClassName(language.name, concept.conceptWrapperImplName())
 fun LanguageSet.ConceptInLanguage.conceptWrapperInterfaceType() = ClassName(language.name, concept.conceptWrapperInterfaceName())
 
 fun FeatureInConcept.kotlinRef() = CodeBlock.of("%T.%N", concept.conceptObjectType(), validName)

metamodel-runtime/src/commonMain/kotlin/org/modelix/metamodel/GeneratedConcept.kt

@@ -3,19 +3,19 @@ package org.modelix.metamodel
 import org.modelix.model.api.*
 import kotlin.reflect.KClass
 
-abstract class GeneratedConcept<InstanceT : ITypedNode, WrapperT : ITypedConcept>(
+abstract class GeneratedConcept<NodeT : ITypedNode, ConceptT : ITypedConcept>(
     private val name: String,
     private val is_abstract: Boolean
 ) : IConcept {
     @Deprecated("use .typed()", ReplaceWith("typed()"))
-    val _typed: WrapperT get() = typed()
-    abstract fun typed(): WrapperT
-    abstract fun getInstanceClass(): KClass<InstanceT>
+    val _typed: ConceptT get() = typed()
+    abstract fun typed(): ConceptT
+    abstract fun getInstanceClass(): KClass<out NodeT>
     private val propertiesMap: MutableMap<String, GeneratedProperty<*>> = LinkedHashMap()
     private val childLinksMap: MutableMap<String, GeneratedChildLink<*, *>> = LinkedHashMap()
     private val referenceLinksMap: MutableMap<String, GeneratedReferenceLink<*, *>> = LinkedHashMap()
 
-    abstract fun wrap(node: INode): InstanceT
+    abstract fun wrap(node: INode): NodeT
 
     override fun isAbstract(): Boolean {
         return is_abstract