From bb7c2e6aae19132c9ced55b035c4368e25bcb7d7 Mon Sep 17 00:00:00 2001 From: CedNaru Date: Sat, 10 May 2025 06:55:18 +0200 Subject: [PATCH 1/3] Add CallableX interface --- .../impl/CallableGenerationService.kt | 172 +- .../main/kotlin/gen/godot/core/Callables.kt | 1740 +++++++++++++++++ .../kotlin/gen/godot/core/LambdaCallables.kt | 866 ++------ .../godot/core/callback/MethodCallable.kt | 10 +- 4 files changed, 2014 insertions(+), 774 deletions(-) create mode 100644 kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt index 5cb14e0ec..11c176269 100644 --- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt +++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt @@ -25,34 +25,93 @@ import java.io.File object CallableGenerationService : ICallableGenerationService { - private const val FUNCTION_PARAMETER_NAME = "function" + private const val CALLABLE_NAME = "Callable" private const val LAMBDA_CALLABLE_NAME = "LambdaCallable" private const val LAMBDA_CONTAINER_NAME = "LambdaContainer" + + private const val FUNCTION_PARAMETER_NAME = "function" private const val CONTAINER_ARGUMENT_NAME = "container" private const val BOUND_ARGS_ARGUMENT_NAME = "boundArgs" private const val CALLABLE_FUNCTION_NAME = "callable" private const val VARIANT_TYPE_RETURN_NAME = "returnConverter" private const val VARIANT_TYPE_ARGUMENT_NAME = "typeConverters" + private val LAMBDA_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CALLABLE_NAME) private val LAMBDA_CONTAINER_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CONTAINER_NAME) + private val CALLABLE_CLASS_NAME = ClassName(godotCorePackage, CALLABLE_NAME) private val returnTypeParameter = TypeVariableName("R", ANY.copy(nullable = true)) private val variantConverterClassName = ClassName(godotInteropPackage, GodotKotlinJvmTypes.variantConverter) override fun generate(outputDir: File) { - val callableFileSpec = FileSpec.builder(godotCorePackage, "LambdaCallables") + val lambdaFileSpec = FileSpec.builder(godotCorePackage, "LambdaCallables") val containerFileSpec = FileSpec.builder(godotCorePackage, "LambdaContainers") + val callableFileSpec = FileSpec.builder(godotCorePackage, "Callables") for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) { val lambdaContainerClassName = ClassName(godotCorePackage, "$LAMBDA_CONTAINER_NAME$argCount") val lambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME$argCount") + val callableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME$argCount") val containerInfo = GenericClassNameInfo(lambdaContainerClassName, argCount) - val callableInfo = GenericClassNameInfo(lambdaCallableClassName, argCount) + val lambdaInfo = GenericClassNameInfo(lambdaCallableClassName, argCount) + val callableInfo = GenericClassNameInfo(callableClassName, argCount) val genericParameters = containerInfo.genericTypes - val lambdaTypeName = callableInfo.toLambdaTypeName(returnType = returnTypeParameter) + val lambdaTypeName = lambdaInfo.toLambdaTypeName(returnType = returnTypeParameter) + val callableClassBuilder = TypeSpec + .interfaceBuilder(callableClassName) + .addSuperinterface(CALLABLE_CLASS_NAME) + .addTypeVariable(returnTypeParameter) + .addTypeVariables(genericParameters) + .addFunction( + FunSpec + .builder("call") + .addParameters(callableInfo.toParameterSpecList()) + .returns(returnTypeParameter) + .addCode( + CodeBlock.of( + buildString { + append("return·callUnsafe(") + append(callableInfo.toArgumentsString("pINDEX", "INDEX")) + append(") as R") + } + ) + ) + .build() + ) + .addFunction( + FunSpec.builder("callDeferred") + .addParameters(callableInfo.toParameterSpecList()) + .addCode( + CodeBlock.of( + buildString { + append("return·callDeferredUnsafe(") + append(callableInfo.toArgumentsString("pINDEX", "INDEX")) + append(")") + } + ) + ) + .build() + ) + .addFunction( + FunSpec.builder("invoke") + .addParameters(lambdaInfo.toParameterSpecList()) + .returns(returnTypeParameter) + .addCode( + CodeBlock.of( + buildString { + append("return·call(") + append(callableInfo.toArgumentsString("pINDEX", "INDEX")) + append(')') + }, + *genericParameters.toTypedArray() + ) + ) + .addModifiers(KModifier.OPERATOR) + .build() + ) val lambdaContainerClassBuilder = TypeSpec .classBuilder(lambdaContainerClassName) @@ -107,10 +166,10 @@ object CallableGenerationService : ICallableGenerationService { CodeBlock.of( buildString { append("return·($FUNCTION_PARAMETER_NAME·as?·%T)?.invoke(") - append(callableInfo.toArgumentsString("args[INDEX]", "INDEX")) + append(lambdaInfo.toArgumentsString("args[INDEX]", "INDEX")) append(")?:·throw·%T()") }, - callableInfo.toErasedLambdaTypeName(returnType = returnTypeParameter), + lambdaInfo.toErasedLambdaTypeName(returnType = returnTypeParameter), ClassName(godotCorePackage, "InvalidJvmLambdaException") ) ) @@ -121,6 +180,7 @@ object CallableGenerationService : ICallableGenerationService { val lambdaCallableClassBuilder = TypeSpec .classBuilder(lambdaCallableClassName) .superclass(LAMBDA_CALLABLE_CLASS_NAME.parameterizedBy(returnTypeParameter)) + .addSuperinterface(callableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters)) .addTypeVariable(returnTypeParameter) .addTypeVariables(genericParameters) .primaryConstructor( @@ -148,68 +208,36 @@ object CallableGenerationService : ICallableGenerationService { .build() ) .addSuperclassConstructorParameter(CONTAINER_ARGUMENT_NAME, BOUND_ARGS_ARGUMENT_NAME) - .addFunction( - FunSpec - .builder("call") - .addParameters(callableInfo.toParameterSpecList()) - .returns(returnTypeParameter) - .addCode( - CodeBlock.of( - buildString { - append("return·$CONTAINER_ARGUMENT_NAME.invokeUnsafe(") - append(callableInfo.toArgumentsString("pINDEX", "INDEX")) - append(')') - } - ) - ) - .build() - ) - .addFunction( - FunSpec.builder("callDeferred") - .addParameters(callableInfo.toParameterSpecList()) - .addCode( - CodeBlock.of( - buildString { - append("return·callDeferredUnsafe(") - append(callableInfo.toArgumentsString("pINDEX", "INDEX")) - append(")") - } - ) - ) - .build() - ) - .addFunction( - FunSpec.builder("invoke") - .addParameters(callableInfo.toParameterSpecList()) - .returns(returnTypeParameter) - .addCode( - CodeBlock.of( - buildString { - append("return·call(") - append(callableInfo.toArgumentsString("pINDEX", "INDEX")) - append(')') - }, - *genericParameters.toTypedArray() - ) - ) - .addModifiers(KModifier.OPERATOR) - .build() - ) + val typeVariables = genericParameters.toMutableList() var remainingParameters = 0 while (typeVariables.isNotEmpty()) { - val bindClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}") - val bindInfo = GenericClassNameInfo(bindClassName, remainingParameters) + val boundLambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}") + val boundCallableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME${remainingParameters}") + val bindInfo = GenericClassNameInfo(boundLambdaCallableClassName, remainingParameters) + + callableClassBuilder.addFunction( + FunSpec.builder("bind") + .addModifiers(KModifier.ABSTRACT) + .addParameters( + typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName -> + ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) + .build() + } + ) + .returns(boundCallableClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes)) + .build() + ) lambdaCallableClassBuilder.addFunction( FunSpec.builder("bind") + .addModifiers(KModifier.OVERRIDE) .addParameters( - typeVariables - .mapIndexed { index: Int, typeVariableName: TypeVariableName -> - ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) - .build() - } + typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName -> + ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) + .build() + } ) .addCode( buildString { @@ -222,7 +250,7 @@ object CallableGenerationService : ICallableGenerationService { append("))") }, - bindClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes), + boundLambdaCallableClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes), ) .build() ) @@ -232,10 +260,11 @@ object CallableGenerationService : ICallableGenerationService { } containerFileSpec.addType(lambdaContainerClassBuilder.build()) - callableFileSpec.addType(lambdaCallableClassBuilder.build()) + lambdaFileSpec.addType(lambdaCallableClassBuilder.build()) + callableFileSpec.addType(callableClassBuilder.build()) val variantMapperMember = MemberName(godotCorePackage, "variantMapper") - callableFileSpec.addFunction( + lambdaFileSpec.addFunction( FunSpec.builder(CALLABLE_FUNCTION_NAME + argCount) .addTypeVariables(genericParameters.map { it.copy(reified = true) }) .addTypeVariable(returnTypeParameter.copy(reified = true)) @@ -264,7 +293,7 @@ object CallableGenerationService : ICallableGenerationService { append(FUNCTION_PARAMETER_NAME) append("))") }, - callableInfo.className.parameterizedBy(listOf(returnTypeParameter) + callableInfo.genericTypes), + lambdaInfo.className.parameterizedBy(listOf(returnTypeParameter) + lambdaInfo.genericTypes), containerInfo.className.parameterizedBy(listOf(returnTypeParameter) + containerInfo.genericTypes), variantMapperMember, returnTypeParameter, @@ -279,7 +308,7 @@ object CallableGenerationService : ICallableGenerationService { .build() ) - callableFileSpec + lambdaFileSpec .addFunction( FunSpec .builder(GodotFunctions.asCallable) @@ -292,7 +321,7 @@ object CallableGenerationService : ICallableGenerationService { ) } - callableFileSpec + lambdaFileSpec .addAnnotation( AnnotationSpec .builder(ClassName("kotlin", "Suppress")) @@ -313,5 +342,16 @@ object CallableGenerationService : ICallableGenerationService { ) .build() .writeTo(outputDir) + + callableFileSpec + .addAnnotation( + AnnotationSpec + .builder(ClassName("kotlin", "Suppress")) + .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"") + .addMember("\"unused\"") + .build() + ) + .build() + .writeTo(outputDir) } } diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt new file mode 100644 index 000000000..700bbcae8 --- /dev/null +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt @@ -0,0 +1,1740 @@ +@file:Suppress( + "PackageDirectoryMismatch", "UNCHECKED_CAST", + "unused", +) + +package godot.core + +import kotlin.Suppress + +public interface Callable0 : Callable { + public fun call(): R = callUnsafe() as R + + public fun callDeferred() = callDeferredUnsafe() + + public operator fun invoke(): R = call() +} + +public interface Callable1 : Callable { + public fun call(p0: P0): R = callUnsafe(p0) as R + + public fun callDeferred(p0: P0) = callDeferredUnsafe(p0) + + public operator fun invoke(p0: P0): R = call(p0) + + public fun bind(p0: P0): Callable0 +} + +public interface Callable2 : Callable { + public fun call(p0: P0, p1: P1): R = callUnsafe(p0, p1) as R + + public fun callDeferred(p0: P0, p1: P1) = callDeferredUnsafe(p0, p1) + + public operator fun invoke(p0: P0, p1: P1): R = call(p0, p1) + + public fun bind(p0: P0, p1: P1): Callable0 + + public fun bind(p1: P1): Callable1 +} + +public interface Callable3 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + ): R = callUnsafe(p0, p1, p2) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + ) = callDeferredUnsafe(p0, p1, p2) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + ): R = call(p0, p1, p2) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + ): Callable0 + + public fun bind(p1: P1, p2: P2): Callable1 + + public fun bind(p2: P2): Callable2 +} + +public interface Callable4 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ): R = callUnsafe(p0, p1, p2, p3) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ) = callDeferredUnsafe(p0, p1, p2, p3) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ): R = call(p0, p1, p2, p3) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + ): Callable1 + + public fun bind(p2: P2, p3: P3): Callable2 + + public fun bind(p3: P3): Callable3 +} + +public interface Callable5 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): R = callUnsafe(p0, p1, p2, p3, p4) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): R = call(p0, p1, p2, p3, p4) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + ): Callable2 + + public fun bind(p3: P3, p4: P4): Callable3 + + public fun bind(p4: P4): Callable4 +} + +public interface Callable6 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): R = call(p0, p1, p2, p3, p4, p5) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + ): Callable3 + + public fun bind(p4: P4, p5: P5): Callable4 + + public fun bind(p5: P5): Callable5 +} + +public interface Callable7 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): R = call(p0, p1, p2, p3, p4, p5, p6) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + ): Callable4 + + public fun bind(p5: P5, p6: P6): Callable5 + + public fun bind(p6: P6): Callable6 +} + +public interface Callable8 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + ): Callable5 + + public fun bind(p6: P6, p7: P7): Callable6 + + public fun bind(p7: P7): Callable7 +} + +public interface Callable9 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + ): Callable6 + + public fun bind(p7: P7, p8: P8): Callable7 + + public fun bind(p8: P8): Callable8 +} + +public interface Callable10 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + ): Callable7 + + public fun bind(p8: P8, p9: P9): Callable8 + + public fun bind(p9: P9): Callable9 +} + +public interface Callable11 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + ): Callable8 + + public fun bind(p9: P9, p10: P10): Callable9 + + public fun bind(p10: P10): Callable10 +} + +public interface Callable12 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + ): Callable9 + + public fun bind(p10: P10, p11: P11): Callable10 + + public fun bind(p11: P11): Callable11 +} + +public interface Callable13 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + ): Callable10 + + public fun bind(p11: P11, p12: P12): Callable11 + + public fun bind(p12: P12): Callable12 +} + +public interface Callable14 : + Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable10 + + public fun bind( + p11: P11, + p12: P12, + p13: P13, + ): Callable11 + + public fun bind(p12: P12, p13: P13): + Callable12 + + public fun bind(p13: P13): Callable13 +} + +public interface Callable15 : + Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable10 + + public fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable11 + + public fun bind( + p12: P12, + p13: P13, + p14: P14, + ): Callable12 + + public fun bind(p13: P13, p14: P14): + Callable13 + + public fun bind(p14: P14): + Callable14 +} + +public interface Callable16 + : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable10 + + public fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable11 + + public fun bind( + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable12 + + public fun bind( + p13: P13, + p14: P14, + p15: P15, + ): Callable13 + + public fun bind(p14: P14, p15: P15): + Callable14 + + public fun bind(p15: P15): + Callable15 +} diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt index a510be006..45220a6cd 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt @@ -14,13 +14,7 @@ import kotlin.Suppress public class LambdaCallable0 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call(): R = container.invokeUnsafe() - - public fun callDeferred() = callDeferredUnsafe() - - public operator fun invoke(): R = call() -} +) : LambdaCallable(container), Callable0 public inline fun callable0(noinline function: () -> R) = LambdaCallable0(LambdaContainer0(variantMapper.getOrDefault(R::class, NIL), arrayOf(), function)) @@ -30,14 +24,8 @@ public inline fun (() -> R).asCallable() = callable0(this) public class LambdaCallable1 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call(p0: P0): R = container.invokeUnsafe(p0) - - public fun callDeferred(p0: P0) = callDeferredUnsafe(p0) - - public operator fun invoke(p0: P0): R = call(p0) - - public fun bind(p0: P0) = LambdaCallable0(container, arrayOf(p0)) +) : LambdaCallable(container), Callable1 { + public override fun bind(p0: P0) = LambdaCallable0(container, arrayOf(p0)) } public inline fun callable1(noinline function: (p0: P0) -> R) = @@ -48,16 +36,10 @@ public inline fun ((p0: P0) -> R).asCallable() = callabl public class LambdaCallable2 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call(p0: P0, p1: P1): R = container.invokeUnsafe(p0, p1) - - public fun callDeferred(p0: P0, p1: P1) = callDeferredUnsafe(p0, p1) - - public operator fun invoke(p0: P0, p1: P1): R = call(p0, p1) +) : LambdaCallable(container), Callable2 { + public override fun bind(p0: P0, p1: P1) = LambdaCallable0(container, arrayOf(p0, p1)) - public fun bind(p0: P0, p1: P1) = LambdaCallable0(container, arrayOf(p0, p1)) - - public fun bind(p1: P1) = LambdaCallable1(container, arrayOf(p1)) + public override fun bind(p1: P1) = LambdaCallable1(container, arrayOf(p1)) } public inline fun callable2(noinline function: (p0: P0, @@ -70,34 +52,16 @@ public inline fun ((p0: P0, p1: P1) -> R).as public class LambdaCallable3 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - ): R = container.invokeUnsafe(p0, p1, p2) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - ) = callDeferredUnsafe(p0, p1, p2) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - ): R = call(p0, p1, p2) - - public fun bind( +) : LambdaCallable(container), Callable3 { + public override fun bind( p0: P0, p1: P1, p2: P2, ) = LambdaCallable0(container, arrayOf(p0, p1, p2)) - public fun bind(p1: P1, p2: P2) = LambdaCallable1(container, arrayOf(p1, p2)) + public override fun bind(p1: P1, p2: P2) = LambdaCallable1(container, arrayOf(p1, p2)) - public fun bind(p2: P2) = LambdaCallable2(container, arrayOf(p2)) + public override fun bind(p2: P2) = LambdaCallable2(container, arrayOf(p2)) } public inline fun callable3(noinline function: ( @@ -116,44 +80,23 @@ public inline fun (( public class LambdaCallable4 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - ): R = container.invokeUnsafe(p0, p1, p2, p3) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - ) = callDeferredUnsafe(p0, p1, p2, p3) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - ): R = call(p0, p1, p2, p3) - - public fun bind( +) : LambdaCallable(container), Callable4 { + public override fun bind( p0: P0, p1: P1, p2: P2, p3: P3, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, ) = LambdaCallable1(container, arrayOf(p1, p2, p3)) - public fun bind(p2: P2, p3: P3) = LambdaCallable2(container, arrayOf(p2, p3)) + public override fun bind(p2: P2, p3: P3) = LambdaCallable2(container, arrayOf(p2, p3)) - public fun bind(p3: P3) = LambdaCallable3(container, arrayOf(p3)) + public override fun bind(p3: P3) = LambdaCallable3(container, arrayOf(p3)) } public inline fun callable4(noinline @@ -175,32 +118,8 @@ public inline fun (( public class LambdaCallable5 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - ): R = call(p0, p1, p2, p3, p4) - - public fun bind( +) : LambdaCallable(container), Callable5 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -208,22 +127,23 @@ public class LambdaCallable5 @PublishedApi internal const p4: P4, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, p4: P4, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, ) = LambdaCallable2(container, arrayOf(p2, p3, p4)) - public fun bind(p3: P3, p4: P4) = LambdaCallable3(container, arrayOf(p3, p4)) + public override fun bind(p3: P3, p4: P4) = LambdaCallable3(container, + arrayOf(p3, p4)) - public fun bind(p4: P4) = LambdaCallable4(container, arrayOf(p4)) + public override fun bind(p4: P4) = LambdaCallable4(container, arrayOf(p4)) } public inline fun @@ -247,35 +167,8 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - ): R = call(p0, p1, p2, p3, p4, p5) - - public fun bind( +) : LambdaCallable(container), Callable6 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -284,7 +177,7 @@ public class LambdaCallable6 @PublishedApi internal c p5: P5, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -292,22 +185,23 @@ public class LambdaCallable6 @PublishedApi internal c p5: P5, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, p5: P5, ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, ) = LambdaCallable3(container, arrayOf(p3, p4, p5)) - public fun bind(p4: P4, p5: P5) = LambdaCallable4(container, arrayOf(p4, p5)) + public override fun bind(p4: P4, p5: P5) = LambdaCallable4(container, + arrayOf(p4, p5)) - public fun bind(p5: P5) = LambdaCallable5(container, arrayOf(p5)) + public override fun bind(p5: P5) = LambdaCallable5(container, arrayOf(p5)) } public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - ): R = call(p0, p1, p2, p3, p4, p5, p6) - - public fun bind( +) : LambdaCallable(container), Callable7 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -375,7 +239,7 @@ public class LambdaCallable7 @PublishedApi intern p6: P6, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -384,7 +248,7 @@ public class LambdaCallable7 @PublishedApi intern p6: P6, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -392,23 +256,24 @@ public class LambdaCallable7 @PublishedApi intern p6: P6, ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, p6: P6, ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, ) = LambdaCallable4(container, arrayOf(p4, p5, p6)) - public fun bind(p5: P5, p6: P6) = LambdaCallable5(container, + public override fun bind(p5: P5, p6: P6) = LambdaCallable5(container, arrayOf(p5, p6)) - public fun bind(p6: P6) = LambdaCallable6(container, arrayOf(p6)) + public override fun bind(p6: P6) = LambdaCallable6(container, + arrayOf(p6)) } public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7) - - public fun bind( +) : LambdaCallable(container), Callable8 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -482,7 +314,7 @@ public class LambdaCallable8 @PublishedApi in p7: P7, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -492,7 +324,7 @@ public class LambdaCallable8 @PublishedApi in p7: P7, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -501,7 +333,7 @@ public class LambdaCallable8 @PublishedApi in p7: P7, ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -509,23 +341,24 @@ public class LambdaCallable8 @PublishedApi in p7: P7, ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, p7: P7, ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, ) = LambdaCallable5(container, arrayOf(p5, p6, p7)) - public fun bind(p6: P6, p7: P7) = LambdaCallable6(container, + public override fun bind(p6: P6, p7: P7) = LambdaCallable6(container, arrayOf(p6, p7)) - public fun bind(p7: P7) = LambdaCallable7(container, arrayOf(p7)) + public override fun bind(p7: P7) = LambdaCallable7(container, + arrayOf(p7)) } public inline fun @PublishedAp constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8) - - public fun bind( +) : LambdaCallable(container), Callable9 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -606,7 +403,7 @@ public class LambdaCallable9 @PublishedAp p8: P8, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -617,7 +414,7 @@ public class LambdaCallable9 @PublishedAp p8: P8, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -627,7 +424,7 @@ public class LambdaCallable9 @PublishedAp p8: P8, ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -636,7 +433,7 @@ public class LambdaCallable9 @PublishedAp p8: P8, ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -644,23 +441,23 @@ public class LambdaCallable9 @PublishedAp p8: P8, ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, p8: P8, ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, ) = LambdaCallable6(container, arrayOf(p6, p7, p8)) - public fun bind(p7: P7, p8: P8) = LambdaCallable7(container, - arrayOf(p7, p8)) + public override fun bind(p7: P7, p8: P8) = + LambdaCallable7(container, arrayOf(p7, p8)) - public fun bind(p8: P8) = LambdaCallable8(container, + public override fun bind(p8: P8) = LambdaCallable8(container, arrayOf(p8)) } @@ -695,47 +492,8 @@ public class LambdaCallable10 @Publis constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) - - public fun bind( +) : LambdaCallable(container), Callable10 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -748,7 +506,7 @@ public class LambdaCallable10 @Publis p9: P9, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -760,7 +518,7 @@ public class LambdaCallable10 @Publis p9: P9, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -771,7 +529,7 @@ public class LambdaCallable10 @Publis p9: P9, ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -781,7 +539,7 @@ public class LambdaCallable10 @Publis p9: P9, ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -790,7 +548,7 @@ public class LambdaCallable10 @Publis p9: P9, ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -798,24 +556,24 @@ public class LambdaCallable10 @Publis p9: P9, ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, p9: P9, ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, ) = LambdaCallable7(container, arrayOf(p7, p8, p9)) - public fun bind(p8: P8, p9: P9) = LambdaCallable8(container, - arrayOf(p8, p9)) + public override fun bind(p8: P8, p9: P9) = + LambdaCallable8(container, arrayOf(p8, p9)) - public fun bind(p9: P9) = LambdaCallable9(container, - arrayOf(p9)) + public override fun bind(p9: P9) = + LambdaCallable9(container, arrayOf(p9)) } public inline fun @P constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) - - public fun bind( +) : LambdaCallable(container), Callable11 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -908,7 +624,7 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -921,7 +637,7 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -933,7 +649,7 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -944,7 +660,7 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -954,7 +670,7 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -963,7 +679,7 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -971,24 +687,24 @@ public class LambdaCallable11 @P p10: P10, ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, p10: P10, ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, ) = LambdaCallable8(container, arrayOf(p8, p9, p10)) - public fun bind(p9: P9, p10: P10) = + public override fun bind(p9: P9, p10: P10) = LambdaCallable9(container, arrayOf(p9, p10)) - public fun bind(p10: P10) = LambdaCallable10(container, - arrayOf(p10)) + public override fun bind(p10: P10) = + LambdaCallable10(container, arrayOf(p10)) } public inline fun , boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) - - public fun bind( +) : LambdaCallable(container), Callable12 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1087,7 +758,7 @@ public class LambdaCallable12(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1101,7 +772,7 @@ public class LambdaCallable12(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1114,7 +785,7 @@ public class LambdaCallable12(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1126,7 +797,7 @@ public class LambdaCallable12(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1137,7 +808,7 @@ public class LambdaCallable12(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1147,7 +818,7 @@ public class LambdaCallable12(container, arrayOf(p5, p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1156,7 +827,7 @@ public class LambdaCallable12(container, arrayOf(p6, p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -1164,23 +835,23 @@ public class LambdaCallable12(container, arrayOf(p7, p8, p9, p10, p11)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, p11: P11, ) = LambdaCallable8(container, arrayOf(p8, p9, p10, p11)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, ) = LambdaCallable9(container, arrayOf(p9, p10, p11)) - public fun bind(p10: P10, p11: P11) = + public override fun bind(p10: P10, p11: P11) = LambdaCallable10(container, arrayOf(p10, p11)) - public fun bind(p11: P11) = + public override fun bind(p11: P11) = LambdaCallable11(container, arrayOf(p11)) } @@ -1222,56 +893,9 @@ public class LambdaCallable13, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) - - public fun bind( +) : LambdaCallable(container), + Callable13 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1287,7 +911,7 @@ public class LambdaCallable13(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1302,7 +926,7 @@ public class LambdaCallable13(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1316,7 +940,7 @@ public class LambdaCallable13(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1329,7 +953,7 @@ public class LambdaCallable13(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1341,7 +965,7 @@ public class LambdaCallable13(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1352,7 +976,7 @@ public class LambdaCallable13(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1362,7 +986,7 @@ public class LambdaCallable13(container, arrayOf(p6, p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -1371,7 +995,7 @@ public class LambdaCallable13(container, arrayOf(p7, p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -1379,23 +1003,23 @@ public class LambdaCallable13(container, arrayOf(p8, p9, p10, p11, p12)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, p12: P12, ) = LambdaCallable9(container, arrayOf(p9, p10, p11, p12)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, ) = LambdaCallable10(container, arrayOf(p10, p11, p12)) - public fun bind(p11: P11, p12: P12) = + public override fun bind(p11: P11, p12: P12) = LambdaCallable11(container, arrayOf(p11, p12)) - public fun bind(p12: P12) = + public override fun bind(p12: P12) = LambdaCallable12(container, arrayOf(p12)) } @@ -1439,59 +1063,9 @@ public class LambdaCallable14, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) - - public fun bind( +) : LambdaCallable(container), + Callable14 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1509,7 +1083,7 @@ public class LambdaCallable14(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1526,7 +1100,7 @@ public class LambdaCallable14(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1542,7 +1116,7 @@ public class LambdaCallable14(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1557,7 +1131,7 @@ public class LambdaCallable14(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1571,7 +1145,7 @@ public class LambdaCallable14(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1584,7 +1158,7 @@ public class LambdaCallable14(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1596,7 +1170,7 @@ public class LambdaCallable14(container, arrayOf(p6, p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -1607,7 +1181,7 @@ public class LambdaCallable14(container, arrayOf(p7, p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -1617,7 +1191,7 @@ public class LambdaCallable14(container, arrayOf(p8, p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, @@ -1626,7 +1200,7 @@ public class LambdaCallable14(container, arrayOf(p9, p10, p11, p12, p13)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, @@ -1634,18 +1208,18 @@ public class LambdaCallable14(container, arrayOf(p10, p11, p12, p13)) - public fun bind( + public override fun bind( p11: P11, p12: P12, p13: P13, ) = LambdaCallable11(container, arrayOf(p11, p12, p13)) - public fun bind(p12: P12, p13: P13) = + public override fun bind(p12: P12, p13: P13) = LambdaCallable12(container, arrayOf(p12, p13)) - public fun bind(p13: P13) = + public override fun bind(p13: P13) = LambdaCallable13(container, arrayOf(p13)) } @@ -1693,62 +1267,9 @@ public class LambdaCallable15, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - - public fun bind( +) : LambdaCallable(container), + Callable15 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1767,7 +1288,7 @@ public class LambdaCallable15(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1785,7 +1306,7 @@ public class LambdaCallable15(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1802,7 +1323,7 @@ public class LambdaCallable15(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1818,7 +1339,7 @@ public class LambdaCallable15(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1833,7 +1354,7 @@ public class LambdaCallable15(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1847,7 +1368,7 @@ public class LambdaCallable15(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1860,7 +1381,7 @@ public class LambdaCallable15(container, arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -1872,7 +1393,7 @@ public class LambdaCallable15(container, arrayOf(p7, p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -1883,7 +1404,7 @@ public class LambdaCallable15(container, arrayOf(p8, p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, @@ -1893,7 +1414,7 @@ public class LambdaCallable15(container, arrayOf(p9, p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, @@ -1902,7 +1423,7 @@ public class LambdaCallable15(container, arrayOf(p10, p11, p12, p13, p14)) - public fun bind( + public override fun bind( p11: P11, p12: P12, p13: P13, @@ -1910,18 +1431,18 @@ public class LambdaCallable15(container, arrayOf(p11, p12, p13, p14)) - public fun bind( + public override fun bind( p12: P12, p13: P13, p14: P14, ) = LambdaCallable12(container, arrayOf(p12, p13, p14)) - public fun bind(p13: P13, p14: P14) = + public override fun bind(p13: P13, p14: P14) = LambdaCallable13(container, arrayOf(p13, p14)) - public fun bind(p14: P14) = + public override fun bind(p14: P14) = LambdaCallable14(container, arrayOf(p14)) } @@ -1971,66 +1492,9 @@ public class LambdaCallable16 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - p15: P15, - ): R = - container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - p15: P15, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - p15: P15, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) - - public fun bind( +) : LambdaCallable(container), + Callable16 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -2050,7 +1514,7 @@ public class LambdaCallable16(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -2069,7 +1533,7 @@ public class LambdaCallable16(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -2087,7 +1551,7 @@ public class LambdaCallable16(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -2104,7 +1568,7 @@ public class LambdaCallable16(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -2120,7 +1584,7 @@ public class LambdaCallable16(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -2135,7 +1599,7 @@ public class LambdaCallable16(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -2149,7 +1613,7 @@ public class LambdaCallable16(container, arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -2162,7 +1626,7 @@ public class LambdaCallable16(container, arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -2174,7 +1638,7 @@ public class LambdaCallable16(container, arrayOf(p8, p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, @@ -2185,7 +1649,7 @@ public class LambdaCallable16(container, arrayOf(p9, p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, @@ -2195,7 +1659,7 @@ public class LambdaCallable16(container, arrayOf(p10, p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p11: P11, p12: P12, p13: P13, @@ -2204,7 +1668,7 @@ public class LambdaCallable16(container, arrayOf(p11, p12, p13, p14, p15)) - public fun bind( + public override fun bind( p12: P12, p13: P13, p14: P14, @@ -2212,18 +1676,18 @@ public class LambdaCallable16(container, arrayOf(p12, p13, p14, p15)) - public fun bind( + public override fun bind( p13: P13, p14: P14, p15: P15, ) = LambdaCallable13(container, arrayOf(p13, p14, p15)) - public fun bind(p14: P14, p15: P15) = + public override fun bind(p14: P14, p15: P15) = LambdaCallable14(container, arrayOf(p14, p15)) - public fun bind(p15: P15) = + public override fun bind(p15: P15) = LambdaCallable15(container, arrayOf(p15)) } diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt index 9bd2fd6b7..d5e8e9666 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt @@ -9,9 +9,11 @@ import godot.internal.memory.MemoryManager class MethodCallable internal constructor( private val target: Object, private val methodName: StringName, - private var boundArgs: Array = emptyArray() + private var boundArgs: Array ) : Callable { + constructor(target: Object, methodName: StringName) : this(target, methodName, emptyArray()) + override fun getBoundArguments() = boundArgs.toList() override fun getBoundArgumentCount() = boundArgs.size override fun getMethod() = methodName @@ -39,10 +41,4 @@ class MethodCallable internal constructor( } return unbound } - - companion object { - @JvmStatic - @JvmName("create") - operator fun invoke(target: Object, methodName: StringName) = MethodCallable(target, methodName) - } } From 9788bcd7b41fd2aeb66f1885e6d19ebe350dabc5 Mon Sep 17 00:00:00 2001 From: CedNaru Date: Sat, 10 May 2025 20:48:39 +0200 Subject: [PATCH 2/3] Add MethodCallableX classes --- .../tests/callable/CallableMethodBindTest.kt | 21 +- .../test/unit/test_callable_method_bind.gd | 18 +- .../impl/CallableGenerationService.kt | 159 +- .../kotlin/gen/godot/core/LambdaCallables.kt | 485 ++--- .../kotlin/gen/godot/core/MethodCallables.kt | 1614 +++++++++++++++++ .../godot/core/callback/LambdaCallable.kt | 2 +- .../godot/core/callback/MethodCallable.kt | 8 +- .../godot/tools/common/constants/Classes.kt | 1 + 8 files changed, 2057 insertions(+), 251 deletions(-) create mode 100644 kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt diff --git a/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt b/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt index 3eddea009..672ae6865 100644 --- a/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt +++ b/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt @@ -4,9 +4,12 @@ import godot.api.Node import godot.annotation.RegisterClass import godot.annotation.RegisterFunction import godot.annotation.RegisterProperty -import godot.core.MethodCallable +import godot.core.Callable0 +import godot.core.Callable1 +import godot.core.Callable2 +import godot.core.Callable3 import godot.core.VariantArray -import godot.core.toGodotName +import godot.core.callable3 import godot.core.variantArrayOf import godot.global.GD @@ -17,22 +20,28 @@ class CallableMethodBindTest: Node() { @RegisterFunction fun callWithMethodWithAllBinds() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe(1, 2, 3).callUnsafe() + val unboundCallable: Callable3 = callable3(CallableMethodBindTest::readySignalMethodBindTest) + val boundCallable: Callable0 = unboundCallable.bind(1, 2, 3) + boundCallable.call() } @RegisterFunction fun callWithMethodWithTwoBinds() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe(2, 3).callUnsafe(0) + val unboundCallable: Callable3 = callable3(CallableMethodBindTest::readySignalMethodBindTest) + val boundCallable: Callable1 = unboundCallable.bind(5, 6) + boundCallable.call(4) } @RegisterFunction fun callWithMethodWithOneBind() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe(3).callUnsafe(0, 0) + val unboundCallable: Callable3 = callable3(CallableMethodBindTest::readySignalMethodBindTest) + val boundCallable: Callable2 = unboundCallable.bind(9) + boundCallable.call(7, 8) } @RegisterFunction fun callWithMethodWithNoBind() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe().callUnsafe(0, 0, 0) + callable3(CallableMethodBindTest::readySignalMethodBindTest).call(10, 11, 12) } @RegisterFunction diff --git a/harness/tests/test/unit/test_callable_method_bind.gd b/harness/tests/test/unit/test_callable_method_bind.gd index 9d899b4ff..f3fb54216 100644 --- a/harness/tests/test/unit/test_callable_method_bind.gd +++ b/harness/tests/test/unit/test_callable_method_bind.gd @@ -26,17 +26,17 @@ func test_method_bind_passing_correct_binds_with_one_args_provided() -> void: binds_test_script.call_with_method_with_two_binds() assert_eq( binds_test_script.method_binds[0], - 0, + 4, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[1], - 2, + 5, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[2], - 3, + 6, "Incorrect bind value passed" ) binds_test_script.free() @@ -46,17 +46,17 @@ func test_method_bind_passing_correct_binds_with_two_args_provided() -> void: binds_test_script.call_with_method_with_one_bind() assert_eq( binds_test_script.method_binds[0], - 0, + 7, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[1], - 0, + 8, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[2], - 3, + 9, "Incorrect bind value passed" ) binds_test_script.free() @@ -66,17 +66,17 @@ func test_method_bind_passing_correct_binds_with_three_args_provided() -> void: binds_test_script.call_with_method_with_no_bind() assert_eq( binds_test_script.method_binds[0], - 0, + 10, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[1], - 0, + 11, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[2], - 0, + 12, "Incorrect bind value passed" ) binds_test_script.free() diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt index 11c176269..e89c457ba 100644 --- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt +++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt @@ -13,49 +13,63 @@ import com.squareup.kotlinpoet.ParameterSpec import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy import com.squareup.kotlinpoet.TypeSpec import com.squareup.kotlinpoet.TypeVariableName +import com.squareup.kotlinpoet.asClassName import godot.codegen.poet.GenericClassNameInfo import godot.codegen.services.ICallableGenerationService import godot.common.constants.Constraints +import godot.tools.common.constants.GODOT_METHOD_CALLABLE +import godot.tools.common.constants.GODOT_OBJECT import godot.tools.common.constants.GodotFunctions import godot.tools.common.constants.GodotKotlinJvmTypes +import godot.tools.common.constants.STRING_NAME +import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION import godot.tools.common.constants.VARIANT_PARSER_NIL import godot.tools.common.constants.godotCorePackage import godot.tools.common.constants.godotInteropPackage import java.io.File +import kotlin.reflect.KCallable object CallableGenerationService : ICallableGenerationService { private const val CALLABLE_NAME = "Callable" private const val LAMBDA_CALLABLE_NAME = "LambdaCallable" private const val LAMBDA_CONTAINER_NAME = "LambdaContainer" + private const val METHOD_CALLABLE_NAME = "MethodCallable" private const val FUNCTION_PARAMETER_NAME = "function" private const val CONTAINER_ARGUMENT_NAME = "container" + private const val TARGET_ARGUMENT_NAME = "target" + private const val METHOD_NAME_ARGUMENT_NAME = "methodName" private const val BOUND_ARGS_ARGUMENT_NAME = "boundArgs" private const val CALLABLE_FUNCTION_NAME = "callable" private const val VARIANT_TYPE_RETURN_NAME = "returnConverter" private const val VARIANT_TYPE_ARGUMENT_NAME = "typeConverters" + private val CALLABLE_CLASS_NAME = ClassName(godotCorePackage, CALLABLE_NAME) private val LAMBDA_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CALLABLE_NAME) private val LAMBDA_CONTAINER_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CONTAINER_NAME) - private val CALLABLE_CLASS_NAME = ClassName(godotCorePackage, CALLABLE_NAME) + private val METHOD_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, METHOD_CALLABLE_NAME) + private val returnTypeParameter = TypeVariableName("R", ANY.copy(nullable = true)) private val variantConverterClassName = ClassName(godotInteropPackage, GodotKotlinJvmTypes.variantConverter) override fun generate(outputDir: File) { - val lambdaFileSpec = FileSpec.builder(godotCorePackage, "LambdaCallables") - val containerFileSpec = FileSpec.builder(godotCorePackage, "LambdaContainers") - val callableFileSpec = FileSpec.builder(godotCorePackage, "Callables") + val callableFileSpec = FileSpec.builder(godotCorePackage, CALLABLE_NAME + "s") + val lambdaFileSpec = FileSpec.builder(godotCorePackage, LAMBDA_CALLABLE_NAME + "s") + val containerFileSpec = FileSpec.builder(godotCorePackage, LAMBDA_CONTAINER_NAME + "s") + val methodFileSpec = FileSpec.builder(godotCorePackage, METHOD_CALLABLE_NAME + "s") for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) { + val callableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME$argCount") val lambdaContainerClassName = ClassName(godotCorePackage, "$LAMBDA_CONTAINER_NAME$argCount") val lambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME$argCount") - val callableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME$argCount") + val methodCallableClassName = ClassName(godotCorePackage, "$METHOD_CALLABLE_NAME$argCount") + val callableInfo = GenericClassNameInfo(callableClassName, argCount) val containerInfo = GenericClassNameInfo(lambdaContainerClassName, argCount) val lambdaInfo = GenericClassNameInfo(lambdaCallableClassName, argCount) - val callableInfo = GenericClassNameInfo(callableClassName, argCount) + val methodCallableInfo = GenericClassNameInfo(methodCallableClassName, argCount) val genericParameters = containerInfo.genericTypes val lambdaTypeName = lambdaInfo.toLambdaTypeName(returnType = returnTypeParameter) @@ -207,14 +221,58 @@ object CallableGenerationService : ICallableGenerationService { .addAnnotation(PublishedApi::class) .build() ) - .addSuperclassConstructorParameter(CONTAINER_ARGUMENT_NAME, BOUND_ARGS_ARGUMENT_NAME) + .addSuperclassConstructorParameter(CONTAINER_ARGUMENT_NAME) + .addSuperclassConstructorParameter(BOUND_ARGS_ARGUMENT_NAME) + val methodCallableClassBuilder = TypeSpec + .classBuilder(methodCallableClassName) + .superclass(METHOD_CALLABLE_CLASS_NAME) + .addSuperinterface(callableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters)) + .addTypeVariable(returnTypeParameter) + .addTypeVariables(genericParameters) + .primaryConstructor( + FunSpec + .constructorBuilder() + .addModifiers(KModifier.INTERNAL) + .addParameter( + ParameterSpec + .builder( + TARGET_ARGUMENT_NAME, + GODOT_OBJECT + ) + .build() + ) + .addParameter( + ParameterSpec + .builder( + METHOD_NAME_ARGUMENT_NAME, + STRING_NAME + ) + .build() + ) + .addParameter( + ParameterSpec + .builder( + BOUND_ARGS_ARGUMENT_NAME, + ARRAY.parameterizedBy(ANY.copy(nullable = true)) + ) + .defaultValue("emptyArray()") + .build() + ) + .addAnnotation(PublishedApi::class) + .build() + ) + .addSuperclassConstructorParameter(TARGET_ARGUMENT_NAME) + .addSuperclassConstructorParameter(METHOD_NAME_ARGUMENT_NAME) + .addSuperclassConstructorParameter(BOUND_ARGS_ARGUMENT_NAME) val typeVariables = genericParameters.toMutableList() var remainingParameters = 0 while (typeVariables.isNotEmpty()) { - val boundLambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}") val boundCallableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME${remainingParameters}") + val boundLambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}") + val boundMethodCallableClassName = ClassName(godotCorePackage, "$METHOD_CALLABLE_NAME${remainingParameters}") + val bindInfo = GenericClassNameInfo(boundLambdaCallableClassName, remainingParameters) callableClassBuilder.addFunction( @@ -241,33 +299,60 @@ object CallableGenerationService : ICallableGenerationService { ) .addCode( buildString { - append("return·%T($CONTAINER_ARGUMENT_NAME, arrayOf(") + append("return·%T($CONTAINER_ARGUMENT_NAME, arrayOf(") for (index in (0.. + ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) + .build() + } + ) + .addCode( + buildString { + append("return·%T($TARGET_ARGUMENT_NAME, $METHOD_NAME_ARGUMENT_NAME, arrayOf(") + + for (index in (0..).name.%M())", + methodCallableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters), + KCallable::class.asClassName(), + TO_GODOT_NAME_UTIL_FUNCTION, + ) + ) + .build() + ) } - lambdaFileSpec + callableFileSpec .addAnnotation( AnnotationSpec .builder(ClassName("kotlin", "Suppress")) @@ -343,7 +457,18 @@ object CallableGenerationService : ICallableGenerationService { .build() .writeTo(outputDir) - callableFileSpec + lambdaFileSpec + .addAnnotation( + AnnotationSpec + .builder(ClassName("kotlin", "Suppress")) + .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"") + .addMember("\"unused\"") + .build() + ) + .build() + .writeTo(outputDir) + + methodFileSpec .addAnnotation( AnnotationSpec .builder(ClassName("kotlin", "Suppress")) diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt index 45220a6cd..fe1d8de2a 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt @@ -14,7 +14,7 @@ import kotlin.Suppress public class LambdaCallable0 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable0 +) : LambdaCallable(container, boundArgs), Callable0 public inline fun callable0(noinline function: () -> R) = LambdaCallable0(LambdaContainer0(variantMapper.getOrDefault(R::class, NIL), arrayOf(), function)) @@ -24,54 +24,58 @@ public inline fun (() -> R).asCallable() = callable0(this) public class LambdaCallable1 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable1 { - public override fun bind(p0: P0) = LambdaCallable0(container, arrayOf(p0)) +) : LambdaCallable(container, boundArgs), Callable1 { + public override fun bind(p0: P0) = LambdaCallable0(container, arrayOf(p0, *boundArgs)) } -public inline fun callable1(noinline function: (p0: P0) -> R) = +public inline fun callable1(noinline function: (p0: P0) -> R) = LambdaCallable1(LambdaContainer1(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!), function)) -public inline fun ((p0: P0) -> R).asCallable() = callable1(this) +public inline fun ((p0: P0) -> R).asCallable() = callable1(this) public class LambdaCallable2 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable2 { - public override fun bind(p0: P0, p1: P1) = LambdaCallable0(container, arrayOf(p0, p1)) +) : LambdaCallable(container, boundArgs), Callable2 { + public override fun bind(p0: P0, p1: P1) = LambdaCallable0(container, arrayOf(p0, p1, + *boundArgs)) - public override fun bind(p1: P1) = LambdaCallable1(container, arrayOf(p1)) + public override fun bind(p1: P1) = LambdaCallable1(container, arrayOf(p1, + *boundArgs)) } -public inline fun callable2(noinline function: (p0: P0, +public inline fun callable2(noinline function: (p0: P0, p1: P1) -> R) = LambdaCallable2(LambdaContainer2(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!), function)) -public inline fun ((p0: P0, p1: P1) -> R).asCallable() = +public inline fun ((p0: P0, p1: P1) -> R).asCallable() = callable2(this) public class LambdaCallable3 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable3 { +) : LambdaCallable(container, boundArgs), Callable3 { public override fun bind( p0: P0, p1: P1, p2: P2, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, *boundArgs)) - public override fun bind(p1: P1, p2: P2) = LambdaCallable1(container, arrayOf(p1, p2)) + public override fun bind(p1: P1, p2: P2) = LambdaCallable1(container, arrayOf(p1, p2, + *boundArgs)) - public override fun bind(p2: P2) = LambdaCallable2(container, arrayOf(p2)) + public override fun bind(p2: P2) = LambdaCallable2(container, arrayOf(p2, + *boundArgs)) } -public inline fun callable3(noinline function: ( +public inline fun callable3(noinline function: ( p0: P0, p1: P1, p2: P2, ) -> R) = LambdaCallable3(LambdaContainer3(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -80,26 +84,28 @@ public inline fun (( public class LambdaCallable4 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable4 { +) : LambdaCallable(container, boundArgs), Callable4 { public override fun bind( p0: P0, p1: P1, p2: P2, p3: P3, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, *boundArgs)) public override fun bind( p1: P1, p2: P2, p3: P3, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, *boundArgs)) - public override fun bind(p2: P2, p3: P3) = LambdaCallable2(container, arrayOf(p2, p3)) + public override fun bind(p2: P2, p3: P3) = LambdaCallable2(container, + arrayOf(p2, p3, *boundArgs)) - public override fun bind(p3: P3) = LambdaCallable3(container, arrayOf(p3)) + public override fun bind(p3: P3) = LambdaCallable3(container, arrayOf(p3, + *boundArgs)) } -public inline fun callable4(noinline +public inline fun callable4(noinline function: ( p0: P0, p1: P1, @@ -108,7 +114,7 @@ public inline fun ca ) -> R) = LambdaCallable4(LambdaContainer4(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -118,35 +124,36 @@ public inline fun (( public class LambdaCallable5 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable5 { +) : LambdaCallable(container, boundArgs), Callable5 { public override fun bind( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, *boundArgs)) public override fun bind( p1: P1, p2: P2, p3: P3, p4: P4, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, *boundArgs)) public override fun bind( p2: P2, p3: P3, p4: P4, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, *boundArgs)) public override fun bind(p3: P3, p4: P4) = LambdaCallable3(container, - arrayOf(p3, p4)) + arrayOf(p3, p4, *boundArgs)) - public override fun bind(p4: P4) = LambdaCallable4(container, arrayOf(p4)) + public override fun bind(p4: P4) = LambdaCallable4(container, arrayOf(p4, + *boundArgs)) } -public inline fun +public inline fun callable5(noinline function: ( p0: P0, p1: P1, @@ -156,7 +163,7 @@ public inline fun R) = LambdaCallable5(LambdaContainer5(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -167,7 +174,7 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable6 { +) : LambdaCallable(container, boundArgs), Callable6 { public override fun bind( p0: P0, p1: P1, @@ -175,7 +182,7 @@ public class LambdaCallable6 @PublishedApi internal c p3: P3, p4: P4, p5: P5, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, *boundArgs)) public override fun bind( p1: P1, @@ -183,29 +190,30 @@ public class LambdaCallable6 @PublishedApi internal c p3: P3, p4: P4, p5: P5, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, *boundArgs)) public override fun bind( p2: P2, p3: P3, p4: P4, p5: P5, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, *boundArgs)) public override fun bind( p3: P3, p4: P4, p5: P5, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, *boundArgs)) public override fun bind(p4: P4, p5: P5) = LambdaCallable4(container, - arrayOf(p4, p5)) + arrayOf(p4, p5, *boundArgs)) - public override fun bind(p5: P5) = LambdaCallable5(container, arrayOf(p5)) + public override fun bind(p5: P5) = LambdaCallable5(container, + arrayOf(p5, *boundArgs)) } -public inline fun callable6(noinline function: ( +public inline fun callable6(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -215,8 +223,8 @@ public inline fun R) = LambdaCallable6(LambdaContainer6(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -228,7 +236,7 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable7 { +) : LambdaCallable(container, boundArgs), Callable7 { public override fun bind( p0: P0, p1: P1, @@ -237,7 +245,7 @@ public class LambdaCallable7 @PublishedApi intern p4: P4, p5: P5, p6: P6, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, *boundArgs)) public override fun bind( p1: P1, @@ -246,7 +254,7 @@ public class LambdaCallable7 @PublishedApi intern p4: P4, p5: P5, p6: P6, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, *boundArgs)) public override fun bind( p2: P2, @@ -254,30 +262,30 @@ public class LambdaCallable7 @PublishedApi intern p4: P4, p5: P5, p6: P6, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, *boundArgs)) public override fun bind( p3: P3, p4: P4, p5: P5, p6: P6, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, *boundArgs)) public override fun bind( p4: P4, p5: P5, p6: P6, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, *boundArgs)) public override fun bind(p5: P5, p6: P6) = LambdaCallable5(container, - arrayOf(p5, p6)) + arrayOf(p5, p6, *boundArgs)) public override fun bind(p6: P6) = LambdaCallable6(container, - arrayOf(p6)) + arrayOf(p6, *boundArgs)) } -public inline fun callable7(noinline function: ( +public inline fun callable7(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -288,8 +296,8 @@ public inline fun R) = LambdaCallable7(LambdaContainer7(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -302,7 +310,7 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable8 { +) : LambdaCallable(container, boundArgs), Callable8 { public override fun bind( p0: P0, p1: P1, @@ -312,7 +320,7 @@ public class LambdaCallable8 @PublishedApi in p5: P5, p6: P6, p7: P7, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, *boundArgs)) public override fun bind( p1: P1, @@ -322,7 +330,7 @@ public class LambdaCallable8 @PublishedApi in p5: P5, p6: P6, p7: P7, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, *boundArgs)) public override fun bind( p2: P2, @@ -331,7 +339,7 @@ public class LambdaCallable8 @PublishedApi in p5: P5, p6: P6, p7: P7, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, *boundArgs)) public override fun bind( p3: P3, @@ -339,30 +347,30 @@ public class LambdaCallable8 @PublishedApi in p5: P5, p6: P6, p7: P7, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, *boundArgs)) public override fun bind( p4: P4, p5: P5, p6: P6, p7: P7, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, *boundArgs)) public override fun bind( p5: P5, p6: P6, p7: P7, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, *boundArgs)) public override fun bind(p6: P6, p7: P7) = LambdaCallable6(container, - arrayOf(p6, p7)) + arrayOf(p6, p7, *boundArgs)) public override fun bind(p7: P7) = LambdaCallable7(container, - arrayOf(p7)) + arrayOf(p7, *boundArgs)) } -public inline fun callable8(noinline function: ( +public inline fun callable8(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -374,8 +382,8 @@ public inline fun R) = LambdaCallable8(LambdaContainer8(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -390,7 +398,7 @@ public class LambdaCallable9 @PublishedAp constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable9 { +) : LambdaCallable(container, boundArgs), Callable9 { public override fun bind( p0: P0, p1: P1, @@ -401,7 +409,7 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, *boundArgs)) public override fun bind( p1: P1, @@ -412,7 +420,7 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, *boundArgs)) public override fun bind( p2: P2, @@ -422,7 +430,7 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, *boundArgs)) public override fun bind( p3: P3, @@ -431,7 +439,7 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, *boundArgs)) public override fun bind( p4: P4, @@ -439,30 +447,30 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, *boundArgs)) public override fun bind( p5: P5, p6: P6, p7: P7, p8: P8, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, *boundArgs)) public override fun bind( p6: P6, p7: P7, p8: P8, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, *boundArgs)) public override fun bind(p7: P7, p8: P8) = - LambdaCallable7(container, arrayOf(p7, p8)) + LambdaCallable7(container, arrayOf(p7, p8, *boundArgs)) public override fun bind(p8: P8) = LambdaCallable8(container, - arrayOf(p8)) + arrayOf(p8, *boundArgs)) } -public inline fun callable9(noinline function: ( +public inline fun callable9(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -475,8 +483,8 @@ public inline fun R) = LambdaCallable9(LambdaContainer9(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -492,7 +500,7 @@ public class LambdaCallable10 @Publis constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable10 { +) : LambdaCallable(container, boundArgs), Callable10 { public override fun bind( p0: P0, p1: P1, @@ -504,7 +512,8 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) public override fun bind( p1: P1, @@ -516,7 +525,8 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) public override fun bind( p2: P2, @@ -527,7 +537,8 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) public override fun bind( p3: P3, @@ -537,7 +548,8 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) public override fun bind( p4: P4, @@ -546,7 +558,8 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, + *boundArgs)) public override fun bind( p5: P5, @@ -554,30 +567,35 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, + *boundArgs)) public override fun bind( p6: P6, p7: P7, p8: P8, p9: P9, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, + *boundArgs)) public override fun bind( p7: P7, p8: P8, p9: P9, - ) = LambdaCallable7(container, arrayOf(p7, p8, p9)) + ) = LambdaCallable7(container, arrayOf(p7, p8, p9, + *boundArgs)) public override fun bind(p8: P8, p9: P9) = - LambdaCallable8(container, arrayOf(p8, p9)) + LambdaCallable8(container, arrayOf(p8, p9, + *boundArgs)) public override fun bind(p9: P9) = - LambdaCallable9(container, arrayOf(p9)) + LambdaCallable9(container, arrayOf(p9, + *boundArgs)) } -public inline fun callable10(noinline function: ( +public inline fun callable10(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -591,8 +609,8 @@ public inline fun R) = LambdaCallable10(LambdaContainer10(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -609,7 +627,8 @@ public class LambdaCallable11 @P constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable11 { +) : LambdaCallable(container, boundArgs), + Callable11 { public override fun bind( p0: P0, p1: P1, @@ -622,7 +641,8 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p1: P1, @@ -635,7 +655,8 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p2: P2, @@ -647,7 +668,8 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p3: P3, @@ -658,7 +680,8 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p4: P4, @@ -668,7 +691,8 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p5: P5, @@ -677,7 +701,8 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p6: P6, @@ -685,30 +710,35 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10, + *boundArgs)) public override fun bind( p7: P7, p8: P8, p9: P9, p10: P10, - ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10)) + ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10, + *boundArgs)) public override fun bind( p8: P8, p9: P9, p10: P10, - ) = LambdaCallable8(container, arrayOf(p8, p9, p10)) + ) = LambdaCallable8(container, arrayOf(p8, p9, p10, + *boundArgs)) public override fun bind(p9: P9, p10: P10) = - LambdaCallable9(container, arrayOf(p9, p10)) + LambdaCallable9(container, arrayOf(p9, p10, + *boundArgs)) public override fun bind(p10: P10) = - LambdaCallable10(container, arrayOf(p10)) + LambdaCallable10(container, arrayOf(p10, + *boundArgs)) } -public inline fun callable11(noinline function: ( +public inline fun callable11(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -723,8 +753,8 @@ public inline fun R) = LambdaCallable11(LambdaContainer11(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -742,7 +772,8 @@ public class LambdaCallable12, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), Callable12 { +) : LambdaCallable(container, boundArgs), + Callable12 { public override fun bind( p0: P0, p1: P1, @@ -756,7 +787,8 @@ public class LambdaCallable12(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p1: P1, @@ -770,7 +802,8 @@ public class LambdaCallable12(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p2: P2, @@ -783,7 +816,8 @@ public class LambdaCallable12(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p3: P3, @@ -795,7 +829,8 @@ public class LambdaCallable12(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p4: P4, @@ -806,7 +841,8 @@ public class LambdaCallable12(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p5: P5, @@ -816,7 +852,8 @@ public class LambdaCallable12(container, arrayOf(p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p6: P6, @@ -825,7 +862,8 @@ public class LambdaCallable12(container, arrayOf(p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p7: P7, @@ -833,31 +871,36 @@ public class LambdaCallable12(container, arrayOf(p7, p8, p9, p10, p11)) + ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10, p11, + *boundArgs)) public override fun bind( p8: P8, p9: P9, p10: P10, p11: P11, - ) = LambdaCallable8(container, arrayOf(p8, p9, p10, p11)) + ) = LambdaCallable8(container, arrayOf(p8, p9, p10, p11, + *boundArgs)) public override fun bind( p9: P9, p10: P10, p11: P11, - ) = LambdaCallable9(container, arrayOf(p9, p10, p11)) + ) = LambdaCallable9(container, arrayOf(p9, p10, p11, + *boundArgs)) public override fun bind(p10: P10, p11: P11) = - LambdaCallable10(container, arrayOf(p10, p11)) + LambdaCallable10(container, arrayOf(p10, p11, + *boundArgs)) public override fun bind(p11: P11) = - LambdaCallable11(container, arrayOf(p11)) + LambdaCallable11(container, arrayOf(p11, + *boundArgs)) } -public inline fun callable12(noinline - function: ( +public inline fun + callable12(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -873,8 +916,8 @@ public inline fun R) = LambdaCallable12(LambdaContainer12(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -893,7 +936,7 @@ public class LambdaCallable13, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), +) : LambdaCallable(container, boundArgs), Callable13 { public override fun bind( p0: P0, @@ -909,7 +952,8 @@ public class LambdaCallable13(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable0(container, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p1: P1, @@ -924,7 +968,8 @@ public class LambdaCallable13(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable1(container, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p2: P2, @@ -938,7 +983,8 @@ public class LambdaCallable13(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable2(container, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p3: P3, @@ -951,7 +997,8 @@ public class LambdaCallable13(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable3(container, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p4: P4, @@ -963,7 +1010,8 @@ public class LambdaCallable13(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable4(container, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p5: P5, @@ -974,7 +1022,8 @@ public class LambdaCallable13(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable5(container, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p6: P6, @@ -984,7 +1033,8 @@ public class LambdaCallable13(container, arrayOf(p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable6(container, + arrayOf(p6, p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p7: P7, @@ -993,7 +1043,8 @@ public class LambdaCallable13(container, arrayOf(p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable7(container, + arrayOf(p7, p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p8: P8, @@ -1001,30 +1052,35 @@ public class LambdaCallable13(container, arrayOf(p8, p9, p10, p11, p12)) + ) = LambdaCallable8(container, + arrayOf(p8, p9, p10, p11, p12, *boundArgs)) public override fun bind( p9: P9, p10: P10, p11: P11, p12: P12, - ) = LambdaCallable9(container, arrayOf(p9, p10, p11, p12)) + ) = LambdaCallable9(container, + arrayOf(p9, p10, p11, p12, *boundArgs)) public override fun bind( p10: P10, p11: P11, p12: P12, - ) = LambdaCallable10(container, arrayOf(p10, p11, p12)) + ) = LambdaCallable10(container, + arrayOf(p10, p11, p12, *boundArgs)) public override fun bind(p11: P11, p12: P12) = - LambdaCallable11(container, arrayOf(p11, p12)) + LambdaCallable11(container, + arrayOf(p11, p12, *boundArgs)) public override fun bind(p12: P12) = - LambdaCallable12(container, arrayOf(p12)) + LambdaCallable12(container, + arrayOf(p12, *boundArgs)) } -public inline fun +public inline fun callable13(noinline function: ( p0: P0, p1: P1, @@ -1042,8 +1098,8 @@ public inline fun R) = LambdaCallable13(LambdaContainer13(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1063,7 +1119,7 @@ public class LambdaCallable14, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), +) : LambdaCallable(container, boundArgs), Callable14 { public override fun bind( p0: P0, @@ -1081,7 +1137,7 @@ public class LambdaCallable14(container, - arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p1: P1, @@ -1098,7 +1154,7 @@ public class LambdaCallable14(container, - arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p2: P2, @@ -1114,7 +1170,7 @@ public class LambdaCallable14(container, - arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p3: P3, @@ -1129,7 +1185,7 @@ public class LambdaCallable14(container, - arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p4: P4, @@ -1143,7 +1199,7 @@ public class LambdaCallable14(container, - arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p5: P5, @@ -1156,7 +1212,7 @@ public class LambdaCallable14(container, - arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p6: P6, @@ -1168,7 +1224,7 @@ public class LambdaCallable14(container, - arrayOf(p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p7: P7, @@ -1179,7 +1235,7 @@ public class LambdaCallable14(container, - arrayOf(p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p7, p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p8: P8, @@ -1189,7 +1245,7 @@ public class LambdaCallable14(container, - arrayOf(p8, p9, p10, p11, p12, p13)) + arrayOf(p8, p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p9: P9, @@ -1198,7 +1254,7 @@ public class LambdaCallable14(container, - arrayOf(p9, p10, p11, p12, p13)) + arrayOf(p9, p10, p11, p12, p13, *boundArgs)) public override fun bind( p10: P10, @@ -1206,27 +1262,27 @@ public class LambdaCallable14(container, - arrayOf(p10, p11, p12, p13)) + arrayOf(p10, p11, p12, p13, *boundArgs)) public override fun bind( p11: P11, p12: P12, p13: P13, ) = LambdaCallable11(container, - arrayOf(p11, p12, p13)) + arrayOf(p11, p12, p13, *boundArgs)) public override fun bind(p12: P12, p13: P13) = LambdaCallable12(container, - arrayOf(p12, p13)) + arrayOf(p12, p13, *boundArgs)) public override fun bind(p13: P13) = LambdaCallable13(container, - arrayOf(p13)) + arrayOf(p13, *boundArgs)) } -public inline fun callable14(noinline function: ( +public inline fun callable14(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1244,9 +1300,9 @@ public inline fun R) = LambdaCallable14(LambdaContainer14(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1267,7 +1323,7 @@ public class LambdaCallable15, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), +) : LambdaCallable(container, boundArgs), Callable15 { public override fun bind( p0: P0, @@ -1286,7 +1342,7 @@ public class LambdaCallable15(container, - arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p1: P1, @@ -1304,7 +1360,7 @@ public class LambdaCallable15(container, - arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p2: P2, @@ -1321,7 +1377,7 @@ public class LambdaCallable15(container, - arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p3: P3, @@ -1337,7 +1393,7 @@ public class LambdaCallable15(container, - arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p4: P4, @@ -1352,7 +1408,7 @@ public class LambdaCallable15(container, - arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p5: P5, @@ -1366,7 +1422,7 @@ public class LambdaCallable15(container, - arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p6: P6, @@ -1379,7 +1435,7 @@ public class LambdaCallable15(container, - arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p7: P7, @@ -1391,7 +1447,7 @@ public class LambdaCallable15(container, - arrayOf(p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p8: P8, @@ -1402,7 +1458,7 @@ public class LambdaCallable15(container, - arrayOf(p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p8, p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p9: P9, @@ -1412,7 +1468,7 @@ public class LambdaCallable15(container, - arrayOf(p9, p10, p11, p12, p13, p14)) + arrayOf(p9, p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p10: P10, @@ -1421,7 +1477,7 @@ public class LambdaCallable15(container, - arrayOf(p10, p11, p12, p13, p14)) + arrayOf(p10, p11, p12, p13, p14, *boundArgs)) public override fun bind( p11: P11, @@ -1429,27 +1485,27 @@ public class LambdaCallable15(container, - arrayOf(p11, p12, p13, p14)) + arrayOf(p11, p12, p13, p14, *boundArgs)) public override fun bind( p12: P12, p13: P13, p14: P14, ) = LambdaCallable12(container, - arrayOf(p12, p13, p14)) + arrayOf(p12, p13, p14, *boundArgs)) public override fun bind(p13: P13, p14: P14) = LambdaCallable13(container, - arrayOf(p13, p14)) + arrayOf(p13, p14, *boundArgs)) public override fun bind(p14: P14) = LambdaCallable14(container, - arrayOf(p14)) + arrayOf(p14, *boundArgs)) } -public inline fun callable15(noinline function: ( +public inline fun callable15(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1468,9 +1524,9 @@ public inline fun R) = LambdaCallable15(LambdaContainer15(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1492,7 +1548,7 @@ public class LambdaCallable16 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container), +) : LambdaCallable(container, boundArgs), Callable16 { public override fun bind( p0: P0, @@ -1512,7 +1568,8 @@ public class LambdaCallable16(container, - arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, + *boundArgs)) public override fun bind( p1: P1, @@ -1531,7 +1588,7 @@ public class LambdaCallable16(container, - arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p2: P2, @@ -1549,7 +1606,7 @@ public class LambdaCallable16(container, - arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p3: P3, @@ -1566,7 +1623,7 @@ public class LambdaCallable16(container, - arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p4: P4, @@ -1582,7 +1639,7 @@ public class LambdaCallable16(container, - arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p5: P5, @@ -1597,7 +1654,7 @@ public class LambdaCallable16(container, - arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p6: P6, @@ -1611,7 +1668,7 @@ public class LambdaCallable16(container, - arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p7: P7, @@ -1624,7 +1681,7 @@ public class LambdaCallable16(container, - arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p8: P8, @@ -1636,7 +1693,7 @@ public class LambdaCallable16(container, - arrayOf(p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p9: P9, @@ -1647,7 +1704,7 @@ public class LambdaCallable16(container, - arrayOf(p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p9, p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p10: P10, @@ -1657,7 +1714,7 @@ public class LambdaCallable16(container, - arrayOf(p10, p11, p12, p13, p14, p15)) + arrayOf(p10, p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p11: P11, @@ -1666,7 +1723,7 @@ public class LambdaCallable16(container, - arrayOf(p11, p12, p13, p14, p15)) + arrayOf(p11, p12, p13, p14, p15, *boundArgs)) public override fun bind( p12: P12, @@ -1674,27 +1731,27 @@ public class LambdaCallable16(container, - arrayOf(p12, p13, p14, p15)) + arrayOf(p12, p13, p14, p15, *boundArgs)) public override fun bind( p13: P13, p14: P14, p15: P15, ) = LambdaCallable13(container, - arrayOf(p13, p14, p15)) + arrayOf(p13, p14, p15, *boundArgs)) public override fun bind(p14: P14, p15: P15) = LambdaCallable14(container, - arrayOf(p14, p15)) + arrayOf(p14, p15, *boundArgs)) public override fun bind(p15: P15) = LambdaCallable15(container, - arrayOf(p15)) + arrayOf(p15, *boundArgs)) } -public inline fun callable16(noinline function: ( +public inline fun callable16(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1714,9 +1771,9 @@ public inline fun R) = LambdaCallable16(LambdaContainer16(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!, variantMapper[P15::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt new file mode 100644 index 000000000..d19795e06 --- /dev/null +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt @@ -0,0 +1,1614 @@ +@file:Suppress( + "PackageDirectoryMismatch", "UNCHECKED_CAST", + "unused", +) + +package godot.core + +import godot.api.Object +import kotlin.Any +import kotlin.Array +import kotlin.PublishedApi +import kotlin.Suppress +import kotlin.reflect.KCallable + +public class MethodCallable0 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable0 + +public fun T.callable0(callable: T.() -> R) = + MethodCallable0(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable1 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable1 { + public override fun bind(p0: P0) = MethodCallable0(target, methodName, arrayOf(p0, + *boundArgs)) +} + +public fun T.callable1(callable: T.(p0: P0) -> R) = + MethodCallable1(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable2 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable2 { + public override fun bind(p0: P0, p1: P1) = MethodCallable0(target, methodName, + arrayOf(p0, p1, *boundArgs)) + + public override fun bind(p1: P1) = MethodCallable1(target, methodName, arrayOf(p1, + *boundArgs)) +} + +public fun T.callable2(callable: T.(p0: P0, p1: P1) -> R) = + MethodCallable2(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable3 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable3 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, *boundArgs)) + + public override fun bind(p1: P1, p2: P2) = MethodCallable1(target, methodName, + arrayOf(p1, p2, *boundArgs)) + + public override fun bind(p2: P2) = MethodCallable2(target, methodName, + arrayOf(p2, *boundArgs)) +} + +public fun T.callable3(callable: T.( + p0: P0, + p1: P1, + p2: P2, +) -> R) = MethodCallable3(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable4 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable4 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, *boundArgs)) + + public override fun bind(p2: P2, p3: P3) = MethodCallable2(target, methodName, + arrayOf(p2, p3, *boundArgs)) + + public override fun bind(p3: P3) = MethodCallable3(target, methodName, + arrayOf(p3, *boundArgs)) +} + +public fun T.callable4(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, +) -> R) = MethodCallable4(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable5 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable5 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, *boundArgs)) + + public override fun bind(p3: P3, p4: P4) = MethodCallable3(target, methodName, + arrayOf(p3, p4, *boundArgs)) + + public override fun bind(p4: P4) = MethodCallable4(target, methodName, + arrayOf(p4, *boundArgs)) +} + +public fun T.callable5(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, +) -> R) = + MethodCallable5(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable6 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable6 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, *boundArgs)) + + public override fun bind(p4: P4, p5: P5) = MethodCallable4(target, methodName, + arrayOf(p4, p5, *boundArgs)) + + public override fun bind(p5: P5) = MethodCallable5(target, methodName, + arrayOf(p5, *boundArgs)) +} + +public fun T.callable6(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, +) -> R) = + MethodCallable6(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable7 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable7 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, *boundArgs)) + + public override fun bind(p5: P5, p6: P6) = MethodCallable5(target, + methodName, arrayOf(p5, p6, *boundArgs)) + + public override fun bind(p6: P6) = MethodCallable6(target, methodName, + arrayOf(p6, *boundArgs)) +} + +public fun T.callable7(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, +) -> R) = + MethodCallable7(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable8 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable8 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable5(target, methodName, arrayOf(p5, p6, p7, + *boundArgs)) + + public override fun bind(p6: P6, p7: P7) = MethodCallable6(target, + methodName, arrayOf(p6, p7, *boundArgs)) + + public override fun bind(p7: P7) = MethodCallable7(target, + methodName, arrayOf(p7, *boundArgs)) +} + +public fun T.callable8(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, +) -> R) = + MethodCallable8(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable9 @PublishedApi internal + constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable9 + { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable5(target, methodName, arrayOf(p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable6(target, methodName, arrayOf(p6, p7, p8, + *boundArgs)) + + public override fun bind(p7: P7, p8: P8) = MethodCallable7(target, + methodName, arrayOf(p7, p8, *boundArgs)) + + public override fun bind(p8: P8) = MethodCallable8(target, + methodName, arrayOf(p8, *boundArgs)) +} + +public fun T.callable9(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, +) -> R) = + MethodCallable9(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable10 @PublishedApi internal + constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable10 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable5(target, methodName, arrayOf(p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable6(target, methodName, arrayOf(p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable7(target, methodName, arrayOf(p7, p8, p9, + *boundArgs)) + + public override fun bind(p8: P8, p9: P9) = + MethodCallable8(target, methodName, arrayOf(p8, p9, + *boundArgs)) + + public override fun bind(p9: P9) = MethodCallable9(target, + methodName, arrayOf(p9, *boundArgs)) +} + +public fun T.callable10(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, +) -> R) = + MethodCallable10(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable11 @PublishedApi internal + constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable11 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, *boundArgs)) + + public override fun bind(p9: P9, p10: P10) = + MethodCallable9(target, methodName, + arrayOf(p9, p10, *boundArgs)) + + public override fun bind(p10: P10) = + MethodCallable10(target, methodName, + arrayOf(p10, *boundArgs)) +} + +public fun T.callable11(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, +) -> R) = + MethodCallable11(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable12 @PublishedApi + internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable12 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, *boundArgs)) + + public override fun bind(p10: P10, p11: P11) = + MethodCallable10(target, methodName, + arrayOf(p10, p11, *boundArgs)) + + public override fun bind(p11: P11) = + MethodCallable11(target, methodName, + arrayOf(p11, *boundArgs)) +} + +public fun + T.callable12(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, +) -> R) = + MethodCallable12(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable13 + @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable13 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, *boundArgs)) + + public override fun bind(p11: P11, p12: P12) = + MethodCallable11(target, methodName, + arrayOf(p11, p12, *boundArgs)) + + public override fun bind(p12: P12) = + MethodCallable12(target, methodName, + arrayOf(p12, *boundArgs)) +} + +public fun + T.callable13(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, +) -> R) = + MethodCallable13(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable14 + @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable14 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable11(target, methodName, + arrayOf(p11, p12, p13, *boundArgs)) + + public override fun bind(p12: P12, p13: P13) = + MethodCallable12(target, methodName, + arrayOf(p12, p13, *boundArgs)) + + public override fun bind(p13: P13) = + MethodCallable13(target, methodName, + arrayOf(p13, *boundArgs)) +} + +public fun + T.callable14(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, +) -> R) = + MethodCallable14(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable15 + @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable15 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable11(target, methodName, + arrayOf(p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable12(target, methodName, + arrayOf(p12, p13, p14, *boundArgs)) + + public override fun bind(p13: P13, p14: P14) = + MethodCallable13(target, methodName, + arrayOf(p13, p14, *boundArgs)) + + public override fun bind(p14: P14) = + MethodCallable14(target, + methodName, arrayOf(p14, *boundArgs)) +} + +public fun + T.callable15(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, +) -> R) = + MethodCallable15(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable16 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable16 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable11(target, methodName, + arrayOf(p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable12(target, methodName, + arrayOf(p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable13(target, methodName, + arrayOf(p13, p14, p15, *boundArgs)) + + public override fun bind(p14: P14, p15: P15) = + MethodCallable14(target, + methodName, arrayOf(p14, p15, *boundArgs)) + + public override fun bind(p15: P15) = + MethodCallable15(target, + methodName, arrayOf(p15, *boundArgs)) +} + +public fun + T.callable16(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, +) -> R) = + MethodCallable16(this, (callable as KCallable).name.toGodotName()) diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt index bb8449fe0..51761a21b 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt @@ -10,7 +10,7 @@ import godot.internal.memory.TransferContext open class LambdaCallable internal constructor( protected val container: LambdaContainer, - private var boundArgs: Array = emptyArray() + protected var boundArgs: Array = emptyArray() ) : Callable { override fun getBoundArguments() = boundArgs.toList() diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt index d5e8e9666..e8d225b37 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt @@ -6,10 +6,10 @@ import godot.api.Object import godot.core.Callable.Bridge import godot.internal.memory.MemoryManager -class MethodCallable internal constructor( - private val target: Object, - private val methodName: StringName, - private var boundArgs: Array +open class MethodCallable internal constructor( + protected val target: Object, + protected val methodName: StringName, + protected var boundArgs: Array = emptyArray() ) : Callable { constructor(target: Object, methodName: StringName) : this(target, methodName, emptyArray()) diff --git a/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt b/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt index 525397f68..18719f2e2 100644 --- a/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt +++ b/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt @@ -255,6 +255,7 @@ val GODOT_LAMBDA_CALLABLE = ClassName(godotCorePackage, GodotKotlinJvmTypes.lamb val GODOT_DICTIONARY = ClassName(godotCorePackage, GodotKotlinJvmTypes.dictionary) val GODOT_OBJECT = ClassName(godotApiPackage, GodotKotlinJvmTypes.obj) val KT_OBJECT = ClassName(godotCorePackage, GodotKotlinJvmTypes.ktObject) +val STRING_NAME = ClassName(godotCorePackage, GodotKotlinJvmTypes.stringName) val VARIANT_PARSER_NIL = ClassName(variantParserPackage, "NIL") val VARIANT_PARSER_BOOL = ClassName(variantParserPackage, "BOOL") From 4605685be8f77cafd7ddf7d4c92a63780a0ba9c3 Mon Sep 17 00:00:00 2001 From: CedNaru Date: Sun, 11 May 2025 05:30:24 +0200 Subject: [PATCH 3/3] SignalX can now safely connect to CallableX --- .../services/impl/SignalGenerationService.kt | 38 +++- .../src/main/kotlin/gen/godot/core/Signals.kt | 195 +++++++++++++----- .../src/main/kotlin/godot/core/Variant.kt | 12 +- .../main/kotlin/godot/core/callback/Signal.kt | 5 - 4 files changed, 180 insertions(+), 70 deletions(-) diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt index f4e0bf9c1..342d5475e 100644 --- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt +++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt @@ -17,24 +17,31 @@ import godot.codegen.poet.GenericClassNameInfo import godot.codegen.services.ISignalGenerationService import godot.common.constants.Constraints import godot.tools.common.constants.GODOT_OBJECT +import godot.tools.common.constants.STRING_NAME +import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION import godot.tools.common.constants.godotCorePackage import godot.tools.common.constants.kotlinReflectPackage import java.io.File object SignalGenerationService : ISignalGenerationService { - + private const val CALLABLE_NAME = "Callable" private const val SIGNAL_CLASS_NAME = "Signal" + private const val INSTANCE_PARAMETER = "instance" private const val NAME_PARAMETER = "name" private const val PROPERTY_PARAMETER = "property" private const val THIS_REF_PARAMETER_NAME = "thisRef" + private const val CONNECT_PARAMETER_NAME = "connect" private const val EMIT_METHOD_NAME = "emit" + private const val CONNECT_METHOD_NAME = "connect" private const val SIGNAL_METHOD_NAME = "signal" + private const val FLAGS_PARAMETER_NAME = "flags" private const val UNSAFE_SUFFIX = "Unsafe" private const val DELEGATE_PROPERTY_NAME = "delegate" + private val connectFlagClassName = ClassName(godotCorePackage, "Object.ConnectFlags") private val propertyClassname = ClassName(kotlinReflectPackage, "KProperty").parameterizedBy(STAR) private val readOnlyPropertyClassName = ClassName("kotlin.properties", "ReadOnlyProperty") @@ -67,7 +74,7 @@ object SignalGenerationService : ISignalGenerationService { } private fun generateSignalClass(argCount: Int, genericClassNameInfo: GenericClassNameInfo): TypeSpec { - + val callableClassName = ClassName(godotCorePackage, CALLABLE_NAME + argCount) return genericClassNameInfo .toTypeSpecBuilder() .superclass(ClassName(godotCorePackage, SIGNAL_CLASS_NAME)) @@ -77,7 +84,7 @@ object SignalGenerationService : ISignalGenerationService { .addParameters( listOf( ParameterSpec.builder(INSTANCE_PARAMETER, GODOT_OBJECT).build(), - ParameterSpec.builder(NAME_PARAMETER, STRING).build() + ParameterSpec.builder(NAME_PARAMETER, STRING_NAME).build() ) ) .addAnnotation(PublishedApi::class) @@ -105,6 +112,25 @@ object SignalGenerationService : ISignalGenerationService { ) ) .build(), + FunSpec.builder(CONNECT_METHOD_NAME) + .returns(UNIT) + .addParameters( + listOf( + ParameterSpec.builder( + CONNECT_PARAMETER_NAME, + callableClassName.parameterizedBy(listOf(STAR) + genericClassNameInfo.genericTypes) + ).build(), + ParameterSpec.builder(FLAGS_PARAMETER_NAME, connectFlagClassName) + .defaultValue("%T.%L", connectFlagClassName, "DEFAULT") + .build() + ) + ) + .addCode( + CodeBlock.of( + "connectUnsafe($CONNECT_PARAMETER_NAME, $FLAGS_PARAMETER_NAME)" + ) + ) + .build(), ) ) .addType(generateSignalCompanion(argCount, genericClassNameInfo)) @@ -139,8 +165,9 @@ object SignalGenerationService : ISignalGenerationService { .returns(genericClassNameInfo.genericClassName) .addCode( CodeBlock.of( - "return·%T(thisRef,·property.name)", + "return·%T(thisRef,·property.%M())", genericClassNameInfo.className, + TO_GODOT_NAME_UTIL_FUNCTION ) ) .build() @@ -157,8 +184,9 @@ object SignalGenerationService : ISignalGenerationService { .addParameter(ParameterSpec.builder("signalName", STRING).build()) .addCode( CodeBlock.of( - "return·%T(this,·signalName)", + "return·%T(this,·signalName.%M())", genericClassNameInfo.genericClassName, + TO_GODOT_NAME_UTIL_FUNCTION ) ) .addAnnotation( diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt index d49bf1a4f..f6dad3f26 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt @@ -18,71 +18,88 @@ import kotlin.reflect.KProperty public class Signal0 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit(): Unit { emitUnsafe() } + public fun connect(connect: Callable0<*>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal0 = - Signal0(thisRef, property.name) + Signal0(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") -public inline fun Object.Signal0(signalName: String) = Signal0(this, signalName) +public inline fun Object.Signal0(signalName: String) = Signal0(this, signalName.toGodotName()) public inline fun Object.signal0() = Signal0.delegate public class Signal1 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit(p0: P0): Unit { emitUnsafe(p0) } + public fun connect(connect: Callable1<*, P0>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal1 = Signal1(thisRef, property.name) + Signal1 = Signal1(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") -public inline fun Object.Signal1(signalName: String) = Signal1(this, signalName) +public inline fun Object.Signal1(signalName: String) = + Signal1(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal1() = Signal1.delegate as ReadOnlyProperty> public class Signal2 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit(p0: P0, p1: P1): Unit { emitUnsafe(p0, p1) } + public fun connect(connect: Callable2<*, P0, P1>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal2 = Signal2(thisRef, property.name) + Signal2 = Signal2(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") -public inline fun Object.Signal2(signalName: String) = Signal2(this, signalName) +public inline fun Object.Signal2(signalName: String) = + Signal2(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal2() = @@ -90,7 +107,7 @@ public inline fun Object.signal2() = public class Signal3 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -100,19 +117,24 @@ public class Signal3 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2) } + public fun connect(connect: Callable3<*, P0, P1, P2>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal3 = Signal3(thisRef, property.name) + Signal3 = Signal3(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal3(signalName: String) = - Signal3(this, signalName) + Signal3(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal3() = @@ -120,7 +142,7 @@ public inline fun Object.signal3() = public class Signal4 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -131,19 +153,25 @@ public class Signal4 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2, p3) } + public fun connect(connect: Callable4<*, P0, P1, P2, P3>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, - `property`: KProperty<*>): Signal4 = Signal4(thisRef, property.name) + `property`: KProperty<*>): Signal4 = + Signal4(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal4(signalName: String) = - Signal4(this, signalName) + Signal4(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal4() = @@ -151,7 +179,7 @@ public inline fun Object.signal4() = public class Signal5 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -163,6 +191,11 @@ public class Signal5 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2, p3, p4) } + public fun connect(connect: Callable5<*, P0, P1, P2, P3, P4>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = @@ -170,13 +203,13 @@ public class Signal5 @PublishedApi internal constructor( public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal5 = - Signal5(thisRef, property.name) + Signal5(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal5(signalName: String) = - Signal5(this, signalName) + Signal5(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal5() = @@ -184,7 +217,7 @@ public inline fun Object.signal5() = public class Signal6 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -197,6 +230,11 @@ public class Signal6 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2, p3, p4, p5) } + public fun connect(connect: Callable6<*, P0, P1, P2, P3, P4, P5>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = @@ -204,13 +242,13 @@ public class Signal6 @PublishedApi internal constructor( public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal6 = - Signal6(thisRef, property.name) + Signal6(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal6(signalName: String) = - Signal6(this, signalName) + Signal6(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal6() = @@ -218,7 +256,7 @@ public inline fun Object.signal6() = public class Signal7 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -232,6 +270,11 @@ public class Signal7 @PublishedApi internal construc emitUnsafe(p0, p1, p2, p3, p4, p5, p6) } + public fun connect(connect: Callable7<*, P0, P1, P2, P3, P4, P5, P6>, flags: Object.ConnectFlags + = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -240,13 +283,13 @@ public class Signal7 @PublishedApi internal construc public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal7 = - Signal7(thisRef, property.name) + Signal7(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal7(signalName: String) = - Signal7(this, signalName) + Signal7(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal7() = @@ -254,7 +297,7 @@ public inline fun Object.signal7() = public class Signal8 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -269,6 +312,11 @@ public class Signal8 @PublishedApi internal cons emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) } + public fun connect(connect: Callable8<*, P0, P1, P2, P3, P4, P5, P6, P7>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -277,13 +325,13 @@ public class Signal8 @PublishedApi internal cons public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal8 = - Signal8(thisRef, property.name) + Signal8(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal8(signalName: String) = - Signal8(this, signalName) + Signal8(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal8() = @@ -291,7 +339,7 @@ public inline fun Object.signal8() = public class Signal9 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -307,6 +355,11 @@ public class Signal9 @PublishedApi internal emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) } + public fun connect(connect: Callable9<*, P0, P1, P2, P3, P4, P5, P6, P7, P8>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -315,13 +368,13 @@ public class Signal9 @PublishedApi internal public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal9 = - Signal9(thisRef, property.name) + Signal9(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal9(signalName: String) = - Signal9(this, signalName) + Signal9(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal9() = @@ -329,7 +382,7 @@ public inline fun Object.signal9() = public class Signal10 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -346,6 +399,11 @@ public class Signal10 @PublishedApi inte emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) } + public fun connect(connect: Callable10<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -354,13 +412,14 @@ public class Signal10 @PublishedApi inte public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal10 = Signal10(thisRef, property.name) + Signal10 = + Signal10(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal10(signalName: String) = - Signal10(this, signalName) + Signal10(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal10() = @@ -369,7 +428,7 @@ public inline fun Object.signal10() = public class Signal11 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -387,6 +446,11 @@ public class Signal11 @PublishedApi emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) } + public fun connect(connect: Callable11<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -396,13 +460,13 @@ public class Signal11 @PublishedApi public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal11 = - Signal11(thisRef, property.name) + Signal11(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal11(signalName: String) - = Signal11(this, signalName) + = Signal11(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal11() = @@ -411,7 +475,7 @@ public inline fun Object.signal11( public class Signal12 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -430,6 +494,11 @@ public class Signal12 @Publish emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) } + public fun connect(connect: Callable12<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -439,14 +508,14 @@ public class Signal12 @Publish public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal12 = - Signal12(thisRef, property.name) + Signal12(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal12(signalName: String) = - Signal12(this, signalName) + Signal12(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal12() = @@ -455,7 +524,7 @@ public inline fun Object.sign public class Signal13 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -475,6 +544,12 @@ public class Signal13 @Pu emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) } + public + fun connect(connect: Callable13<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -484,14 +559,14 @@ public class Signal13 @Pu public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal13 = - Signal13(thisRef, property.name) + Signal13(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal13(signalName: String) = - Signal13(this, signalName) + Signal13(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal13() = @@ -500,7 +575,7 @@ public inline fun Object public class Signal14 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -521,6 +596,12 @@ public class Signal14, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -530,14 +611,14 @@ public class Signal14 getValue(thisRef: Object, `property`: KProperty<*>): Signal14 = - Signal14(thisRef, property.name) + Signal14(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal14(signalName: String) = - Signal14(this, signalName) + Signal14(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal14() = @@ -546,7 +627,7 @@ public inline fun O public class Signal15 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -568,6 +649,12 @@ public class Signal15, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -577,14 +664,14 @@ public class Signal15 getValue(thisRef: Object, `property`: KProperty<*>): Signal15 = - Signal15(thisRef, property.name) + Signal15(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal15(signalName: String) = - Signal15(this, signalName) + Signal15(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun @@ -594,7 +681,7 @@ public inline fun @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -617,6 +704,12 @@ public class Signal16, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -626,14 +719,14 @@ public class Signal16 getValue(thisRef: Object, `property`: KProperty<*>): Signal16 = - Signal16(thisRef, property.name) + Signal16(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal16(signalName: String) = - Signal16(this, signalName) + Signal16(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt index 358667182..8f4f5c732 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt @@ -5,7 +5,6 @@ import godot.common.interop.ObjectID import godot.common.interop.VariantConverter import godot.common.interop.nullptr import godot.common.util.toRealT -import godot.core.Signal import godot.internal.memory.LongStringQueue import java.nio.ByteBuffer @@ -373,14 +372,9 @@ enum class VariantParser(override val id: Int) : VariantConverter { CALLABLE(25) { override fun toUnsafeKotlin(buffer: ByteBuffer) = VariantCallable(buffer.long) override fun toUnsafeGodot(buffer: ByteBuffer, any: Any?) { - if (any is VariantCallable) { - buffer.putLong(any.ptr) - } else { - require(any is LambdaCallable<*> || any is MethodCallable) - // Be careful that ::toNativeCallable doesn't itself use the shared buffer. - val ptr = any.toNativeCallable().ptr - buffer.putLong(ptr) - } + require(any is Callable) + // Be careful that ::toNativeCallable doesn't itself use the shared buffer. + buffer.putLong(any.toNativeCallable().ptr) } }, SIGNAL(26) { diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt index 4230fad72..cdd830a58 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt @@ -12,11 +12,6 @@ open class Signal internal constructor( val name: StringName ) : CoreType { - internal constructor(instance: Object, jvmName: String) : this( - instance, - jvmName.convertToSnakeCase().asStringName() - ) - fun emitUnsafe(vararg args: Any?) { godotObject.emitSignal(name, *args) }