Simplify generation classes (#782)

* Simplify TypedTrait
* Enriching API is now a rule

Author: CedNaru

kt/api-generator/src/main/kotlin/godot/codegen/constants/CoreTypeTraits.kt

@@ -1,11 +1,13 @@
 package godot.codegen.exceptions
 
+import godot.codegen.models.Method
+import godot.codegen.models.Signal
 import godot.codegen.models.enriched.EnrichedMethod
 import godot.codegen.models.enriched.EnrichedSignal
 import godot.common.constants.Constraints
 
-class TooManyMethodArgument(method: EnrichedMethod) :
-    Exception("${method.name} has ${method.arguments.size} arguments but the maximum number is ${Constraints.MAX_FUNCTION_ARG_COUNT}")
+class TooManyMethodArgument(method: Method) :
+    Exception("${method.name} has ${method.arguments!!.size} arguments but the maximum number is ${Constraints.MAX_FUNCTION_ARG_COUNT}")
 
-class TooManySignalArgument(signal: EnrichedSignal) :
-    Exception("${signal.name} has ${signal.arguments.size} arguments but the maximum number is ${Constraints.MAX_SIGNAL_ARG_COUNT}")
+class TooManySignalArgument(signal: Signal) :
+    Exception("${signal.name} has ${signal.arguments!!.size} arguments but the maximum number is ${Constraints.MAX_SIGNAL_ARG_COUNT}")

kt/api-generator/src/main/kotlin/godot/codegen/exceptions/ClassGenerationException.kt

@@ -0,0 +1,59 @@
+package godot.codegen.generation
+
+import godot.codegen.exceptions.NoMatchingEnumFound
+import godot.codegen.models.traits.GenerationType
+import godot.codegen.models.ApiDescription
+import godot.codegen.models.enriched.EnrichedClass
+import godot.codegen.models.enriched.EnrichedEnum
+import godot.codegen.models.enriched.EnrichedNativeStructure
+import godot.tools.common.constants.GodotTypes
+import java.io.File
+
+class GenerationContext(
+    val api: ApiDescription,
+) {
+    private var nextEngineClassIndex = 0
+    private var nextSingletonIndex = 0
+
+    val coreTypeMap = mutableMapOf<String, List<EnrichedEnum>>()
+    val nativeStructureMap = HashMap<String, EnrichedNativeStructure>()
+
+    val globalEnumMap = mutableMapOf<String, EnrichedEnum>()
+    val globalEnumList = mutableListOf<EnrichedEnum>()
+    val classMap = mutableMapOf<String, EnrichedClass>()
+    val classList = mutableListOf<EnrichedClass>()
+
+
+    fun getNextEngineClassIndex() = nextEngineClassIndex++
+    fun getNextSingletonIndex(): Int {
+        nextEngineClassIndex++
+        return nextSingletonIndex++
+    }
+
+    fun isNativeStructure(name: String) = name in nativeStructureMap
+
+    fun generateEnumDefaultValue(type: GenerationType, value: Long): String {
+        val simpleNames = type.className.simpleNames
+        val className: String
+        val enrichedEnum = if (simpleNames.size > 1) {
+            className = simpleNames[0]
+            if (GodotTypes.coreTypes.contains(className)) {
+                coreTypeMap[className] ?: listOf()
+            } else {
+                classMap[className]!!.enums
+            }.firstOrNull {
+                it.identifier == type.identifier
+            } ?: throw NoMatchingEnumFound(type.identifier)
+        } else {
+            className = ""
+            globalEnumMap[type.identifier]!!
+        }
+
+        val enumValue = enrichedEnum.values.firstOrNull { it.value == value }
+        return if (enumValue != null) {
+            enrichedEnum.identifier + "." + enumValue.name
+        } else {
+            enrichedEnum.identifier + "(" + value + ")"
+        }
+    }
+}