Shorten enum names (#775)

* Shortening of enum names

Author: CedNaru

docs/src/doc/user-guide/api-differences.md

@@ -132,6 +132,10 @@ To avoid confusion and conflict with Kotlin types, the following Godot symbol is
 - `Array` -> `VariantArray` (to avoid confusion with a built-in type in Kotlin)
 - `PackedXArray::toByteArray` -> `PackedXArray::toPackedByteArray` (to avoid confusion with a built-in type in Kotlin)
 - `PackedByteArray::toXArray` -> `PackedByteArray::toPackedXArray` (to avoid confusion with a built-in type in Kotlin)
+- All enum values are shortened, the name of the enum itself has been removed. Here are some examples:
+  - `Error.ERR_PARAMETER_RANGE_ERROR` -> `Error.PARAMETER_RANGE`
+  - `MethodFlags.METHOD_FLAG_NORMAL` -> `MethodFlags.NORMAL`
+  - `ProcessThreadMessages.FLAG_PROCESS_THREAD_MESSAGES_PHYSICS` -> `Error.FLAG_PHYSICS`
 
 ## Global functions
 
@@ -207,4 +211,4 @@ If you want logs to appear both in CLI and in the Godot Editor you will have to
 GD.print("Hello There!")
 ```
 
-Kotlin's print functions, on the other hand, will only print to CLI! They will print to Godot editor's output panel.
+Kotlin's print functions, on the other hand, will only print to CLI! They won't print to Godot editor's output panel.

harness/tests/src/main/java/godot/tests/JavaTestClass.java

@@ -94,7 +94,7 @@ public void connectAndTriggerSignal() {
         connect(
                 StringNames.asStringName("test_signal"),
                 new NativeCallable(this, StringNames.asStringName("signal_callback")),
-                (int) ConnectFlags.CONNECT_ONE_SHOT.getId()
+                (int) ConnectFlags.ONE_SHOT.getId()
         );
         emitSignal(StringNames.asStringName("test_signal"));
     }

kt/api-generator/src/main/kotlin/godot/codegen/models/enriched/EnrichedEnum.kt

@@ -6,6 +6,11 @@ import godot.codegen.models.Enum
 import godot.codegen.traits.IDocumented
 import godot.codegen.traits.TypedTrait
 import godot.codegen.workarounds.sanitizeApiType
+import godot.common.extensions.isValidKotlinIdentifier
+import godot.common.extensions.removeWords
+import godot.common.extensions.removePrefixWords
+import godot.common.extensions.removeSuffixWords
+import godot.common.extensions.toUpperSnakeCase
 
 class EnrichedEnum(model: Enum, val outerClass: String?) : TypedTrait {
     val simpleName = model.name.sanitizeApiType()
@@ -19,14 +24,34 @@ class EnrichedEnum(model: Enum, val outerClass: String?) : TypedTrait {
     val values = model.values.map {
         EnrichedEnumValue(
             it.name,
+            simpleName,
             it.value,
             it.description ?: ""
         )
     }
 }
 
-class EnrichedEnumValue(val name: String, val value: Long, override val description: String?) : IDocumented
+class EnrichedEnumValue(valueName: String, ownerName: String, val value: Long, override val description: String?) : IDocumented {
+    val name = run {
+        val uppercaseName = ownerName.toUpperSnakeCase()
+        val prefixRemoved = valueName
+            .removePrefixWords(uppercaseName)
+            .removePrefix("_")
+            .takeIf { it.isValidKotlinIdentifier() }
+            ?: valueName
 
+        val suffixRemoved = prefixRemoved
+            .removeSuffixWords(uppercaseName)
+            .removePrefix("_")
+            .takeIf { it.isValidKotlinIdentifier() }
+            ?: prefixRemoved
+
+        suffixRemoved
+            .removeWords(uppercaseName)
+            .takeIf { it.isValidKotlinIdentifier() }
+            ?: suffixRemoved
+    }
+}
 
 fun List<Enum>.toEnriched(outerClass: String? = null) = map { EnrichedEnum(it, outerClass) }
 fun Enum.toEnriched(outerClass: String? = null) = EnrichedEnum(this, outerClass)

kt/api-generator/src/main/kotlin/godot/codegen/services/impl/AwaitGenerationService.kt

@@ -145,7 +145,7 @@ object AwaitGenerationService : IAwaitGenerationService {
             .beginControlFlow(".%M", AS_CALLABLE_UTIL_FUNCTION)
             .addStatement("cont.%L()", cancel)
             .endControlFlow()
-            .addCode(",·%T.ConnectFlags.CONNECT_ONE_SHOT.id.toInt())", GODOT_OBJECT)
+            .addCode(",·%T.ConnectFlags.ONE_SHOT.id.toInt())", GODOT_OBJECT)
             .endControlFlow()
     }
 }

kt/common/src/main/kotlin/godot/common/extensions/StringExtensions.kt

@@ -48,20 +48,64 @@ fun String.convertToSnakeCase(): String =
         else accumulator.append(character)
     }.toString()
 
-fun String.removeSuffixWords(wordWithDashes: String): String {
+fun String.toUpperSnakeCase(): String {
+    if (this.isEmpty()) return this
+    val originalString = this
+
+    val result = buildString {
+        for (i in originalString.indices) {
+            val currentChar = originalString[i]
+            if (i > 0 && currentChar.isUpperCase()) {
+                val prevChar = originalString[i - 1]
+                // Insert underscore if the previous character is lowercase
+                // OR if the previous character is uppercase but the next character exists and is lowercase
+                if (prevChar.isLowerCase() || (prevChar.isUpperCase() && i < originalString.lastIndex && originalString[i + 1].isLowerCase())) {
+                    append('_')
+                }
+            }
+            append(currentChar)
+        }
+    }
+    return result.uppercase(Locale.getDefault())
+}
+
+fun String.removePrefixWords(snakeCaseString: String): String {
+    // We split the 2 strings into different "words"
+    val otherWords = snakeCaseString.split('_')
+    val valueWords = this.split('_')
+
+    var index = 0
+    for (enumWord in otherWords) {
+        if (index >= valueWords.size) break
+        val valueWord = valueWords[index]
+        // Remove the word if the receiver word is not longer than the parameter word
+        // and the parameter word starts with the entire receiver word.
+        if (valueWord.length <= enumWord.length && enumWord.startsWith(valueWord)) {
+            index++
+        } else {
+            break
+        }
+    }
+    // Join the remaining words with underscores.
+    return valueWords.drop(index).joinToString("_")
+}
+
+fun String.removeWords(other: String) = replace("_" + other + "_", "_")
+
+fun String.removeSuffixWords(snakeCaseString: String): String {
     // We split the 2 strings into different "words"
-    val otherWords = wordWithDashes.split('_')
+    val otherWords = snakeCaseString.split('_')
     val valueWords = this.split('_')
 
     var valueIndex = valueWords.size - 1
     var enumIndex = otherWords.size - 1
 
-    // Remove matching words from the end of the other value.
+    // Remove matching words from the end of the parameter value.
     while (valueIndex >= 0 && enumIndex >= 0) {
         val valueWord = valueWords[valueIndex]
         val enumWord = otherWords[enumIndex]
-        // If the receiver word is not longer than the other word and the other word starts with the receiver word,
-        // we consider it a match.
+        // Remove the word if the receiver word is not longer than the parameter word
+        // and the parameter word starts with the entire receiver word.
         if (valueWord.length <= enumWord.length && enumWord.startsWith(valueWord)) {
             valueIndex--
             enumIndex--

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/FunctionRegistrationGenerator.kt

@@ -131,18 +131,18 @@ object FunctionRegistrationGenerator {
     private fun getRpcModeEnum(registeredFunction: RegisteredFunction): ClassName {
         return when (registeredFunction.annotations.getAnnotation<RpcAnnotation>()?.rpcMode) {
             null,
-            RpcMode.DISABLED -> ClassName("$godotApiPackage.${GodotTypes.rpcMode}", "RPC_MODE_DISABLED")
-            RpcMode.ANY -> ClassName("$godotApiPackage.${GodotTypes.rpcMode}", "RPC_MODE_ANY_PEER")
-            RpcMode.AUTHORITY -> ClassName("$godotApiPackage.${GodotTypes.rpcMode}", "RPC_MODE_AUTHORITY")
+            RpcMode.DISABLED -> ClassName("$godotApiPackage.${GodotTypes.rpcMode}", "DISABLED")
+            RpcMode.ANY -> ClassName("$godotApiPackage.${GodotTypes.rpcMode}", "ANY_PEER")
+            RpcMode.AUTHORITY -> ClassName("$godotApiPackage.${GodotTypes.rpcMode}", "AUTHORITY")
         }
     }
 
     private fun getRpcTransferModeEnum(registeredFunction: RegisteredFunction): ClassName {
         return when (registeredFunction.annotations.getAnnotation<RpcAnnotation>()?.transferMode) {
             null,
-            TransferMode.RELIABLE -> ClassName("$godotApiPackage.${GodotTypes.transferMode}", "TRANSFER_MODE_RELIABLE")
-            TransferMode.UNRELIABLE -> ClassName("$godotApiPackage.${GodotTypes.transferMode}", "TRANSFER_MODE_UNRELIABLE")
-            TransferMode.UNRELIABLE_ORDERED -> ClassName("$godotApiPackage.${GodotTypes.transferMode}", "TRANSFER_MODE_UNRELIABLE_ORDERED")
+            TransferMode.RELIABLE -> ClassName("$godotApiPackage.${GodotTypes.transferMode}", "RELIABLE")
+            TransferMode.UNRELIABLE -> ClassName("$godotApiPackage.${GodotTypes.transferMode}", "UNRELIABLE")
+            TransferMode.UNRELIABLE_ORDERED -> ClassName("$godotApiPackage.${GodotTypes.transferMode}", "UNRELIABLE_ORDERED")
         }
     }
 

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/PropertyRegistrationGenerator.kt

@@ -142,12 +142,12 @@ object PropertyRegistrationGenerator {
         return if (registeredProperty.annotations.hasAnnotation<ExportAnnotation>()) {
             ClassName(
                 "$godotCorePackage.${GodotTypes.propertyUsage}",
-                "PROPERTY_USAGE_DEFAULT"
+                "DEFAULT"
             )
         } else {
             ClassName(
                 "$godotCorePackage.${GodotTypes.propertyUsage}",
-                "PROPERTY_USAGE_NONE"
+                "NONE"
             )
         }
     }

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/hintstring/ArrayAndDictionaryHintStringGenerator.kt

@@ -77,7 +77,7 @@ class ArrayAndDictionaryHintStringGenerator(
             //      -> 2 == int -> variant type ordinal
             // example: Dictionary<Int, Button>() -> 2:int;24/34:Button
             //      -> 24 == Object -> variant type ordinal -> VariantParser.OBJECT.id
-            //      -> 34 == Button -> node type property hint ordinal -> PropertyHint.PROPERTY_HINT_NODE_TYPE.id
+            //      -> 34 == Button -> node type property hint ordinal -> PropertyHint.NODE_TYPE.id
             loop@ while (currentElementType != null) {
                 when {
                     currentElementType.isCompatibleList() -> {
@@ -107,7 +107,7 @@ class ArrayAndDictionaryHintStringGenerator(
                             ?: currentElementType.baseGodotType()?.fqName?.substringAfterLast(".")
 
                         val subTypeString = if (className != null) {
-                            "/${PropertyHint.PROPERTY_HINT_NODE_TYPE.id}:$className"
+                            "/${PropertyHint.NODE_TYPE.id}:$className"
                         } else {
                             ""
                         }
@@ -123,7 +123,7 @@ class ArrayAndDictionaryHintStringGenerator(
                             ?: currentElementType.baseGodotType()?.fqName?.substringAfterLast(".")
 
                         val subTypeString = if (className != null) {
-                            "/${PropertyHint.PROPERTY_HINT_RESOURCE_TYPE.id}:$className"
+                            "/${PropertyHint.RESOURCE_TYPE.id}:$className"
                         } else {
                             ""
                         }

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/hintstring/PropertyHintStringGenerator.kt

@@ -3,13 +3,13 @@ package godot.entrygenerator.generator.hintstring
 import godot.entrygenerator.model.PropertyHintAnnotation
 import godot.entrygenerator.model.RegisteredProperty
 
-abstract class PropertyHintStringGenerator<PROPERTY_HINT_ANNOTATION_TYPE: PropertyHintAnnotation> (
+abstract class PropertyHintStringGenerator<ANNOTATION_TYPE: PropertyHintAnnotation> (
     val registeredProperty: RegisteredProperty
 ) {
     @Suppress("UNCHECKED_CAST")
     protected val propertyHintAnnotation = registeredProperty
         .annotations
-        .firstOrNull { it is PropertyHintAnnotation } as PROPERTY_HINT_ANNOTATION_TYPE?
+        .firstOrNull { it is PropertyHintAnnotation } as ANNOTATION_TYPE?
 
     /**
      * Hint string formatting: https://github.com/godotengine/godot/blob/dcd11faad3802679a43b27155f1b6bc59aa39b60/core/object.h

kt/entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/typehint/PropertyTypeHintProvider.kt

@@ -25,21 +25,21 @@ object PropertyTypeHintProvider {
     ): ClassName {
         return when {
             registeredProperty.type.fqName == Int::class.qualifiedName -> if (registeredProperty.annotations.hasAnnotation<IntFlagHintAnnotation>()) {
-                ClassName("$godotCorePackage.${GodotTypes.propertyHint}", "PROPERTY_HINT_FLAGS")
+                ClassName("$godotCorePackage.${GodotTypes.propertyHint}", "FLAGS")
             } else {
                 JvmPrimitivesTypeHintGenerator(registeredProperty).getPropertyTypeHint()
             }
             registeredProperty.type.fqName == String::class.qualifiedName -> when {
                 registeredProperty.annotations.hasAnnotation<MultilineTextHintAnnotation>() -> {
                     ClassName(
                         "$godotCorePackage.${GodotTypes.propertyHint}",
-                        "PROPERTY_HINT_MULTILINE_TEXT"
+                        "MULTILINE_TEXT"
                     )
                 }
                 registeredProperty.annotations.hasAnnotation<PlaceHolderTextHintAnnotation>() -> {
                     ClassName(
                         "$godotCorePackage.${GodotTypes.propertyHint}",
-                        "PROPERTY_HINT_PLACEHOLDER_TEXT"
+                        "PLACEHOLDER_TEXT"
                     )
                 }
                 else -> {
@@ -60,22 +60,22 @@ object PropertyTypeHintProvider {
 
             registeredProperty.type.isRefCounted() -> ClassName(
                 "$godotCorePackage.${GodotTypes.propertyHint}",
-                "PROPERTY_HINT_RESOURCE_TYPE"
+                "RESOURCE_TYPE"
             )
 
             registeredProperty.type.isDictionary() -> JvmArrayAndDictionaryTypeHintGenerator(registeredProperty).getPropertyTypeHint()
             registeredProperty.type.isCompatibleList() -> JvmArrayAndDictionaryTypeHintGenerator(registeredProperty).getPropertyTypeHint()
             registeredProperty.type.fqName.matches(Regex("^kotlin\\.collections\\..*Set\$")) -> ClassName(
                 "$godotCorePackage.${GodotTypes.propertyHint}",
-                "PROPERTY_HINT_RESOURCE_TYPE"
+                "RESOURCE_TYPE"
             )
 
             registeredProperty.type.isNodeType() -> ClassName(
                 "$godotCorePackage.${GodotTypes.propertyHint}",
-                "PROPERTY_HINT_NODE_TYPE"
+                "NODE_TYPE"
             )
 
-            else -> ClassName("$godotCorePackage.${GodotTypes.propertyHint}", "PROPERTY_HINT_NONE")
+            else -> ClassName("$godotCorePackage.${GodotTypes.propertyHint}", "NONE")
         }
     }
 }