Is there any way to anotate a class in common module with java-only lib anotations? expected/actual didnt work because the anotation has enum inside and i couldnt get it to work

The main issue are the other platforms, you'd need to implement the actual enum and annotation classes which are only dummys. I wonder if there was a way around it for your case, but interesting problem nonetheless.

Move enum expect out of annotation class and then typealias it on jvm? e.g. typealias MyEnum = Annotation.Enum

I assumed @Lucas still wants to pass arguments in the Common code and that the source code for the JVM enum is an external dependency. For that the enum must be defined in common code.

// ## Common source

@JvmJsonProperty(required = false, access = JsonPropertyAccess.WRITE_ONLY)

You can still do that as long as you typealias it properly on jvm

Could you please provide examples of what you mean? Cause I think one of us is missing something and there's something to learn here 😅 The JVM implementation is concrete and defined in a JVM library. Let's say it's like:

// Some External JVM Library that it's being used in the JVM
annotation class LibAnnotation(val enum: LibEnum)

enum class LibEnum { A, B }

Now, in the common code, we need to call the

LibAnnotation

constructor with the

LibEnum

parameter. Can't do that directly, so expect/actual needed.

// Common Code

/**
 * An annotation that will only affect JVM targets
 */
expect annotation class JvmLibAnnotation(val enum: ???)

// This way it can be used like so:
@JvmLibAnnotation(enum = ???)


// JVM Code
actual typealias JvmLibAnnotation = JsonProperty

What to put in the

???

expect enum class LibEnum actual typealias LibEnum = LibAnnotation.LibEnum

It's not possible to pass the arguments in the common code like that.

// Common Code

@JvmLibAnnotation(enum = LibEnum.A) // A is not defined in common, only in JVM

Of course you can. You use the expect declarations instead

So I really don't get what was the difference between your suggestion and mine

Just re-read it. Missing actual for enum threw me off.

When talking about expec/actual annotations - is there any way to have default values for annotation parameters when type aliasing to jvm annotations?

Thanks! I couldnt get it to work exactly the way you did, the line

actual typealias JvmJsonProperty = JsonProperty

had errors, but anottating it with @OptionalExpectation and removing the arguments worked. At least it doesnt give me an error, still have to test it. Thanks a lot @Vitor Hugo Schwaab and @Big Chungus

Could you share the errors and the code?

But reading the error i think the expect class just needs more params on the constructor

Yep, that should be it. I didn't know there were more possible parameters 🙂 I just wrote a dummy annotation on my machine for JVM and worked with that. If the JVM annotation has more parameters, then you need to implement those too, possibly implement multiple constructors too! (If default arguments aren't enough)

This compiles for me (but I haven't run the app) Common code:

@OptIn(ExperimentalMultiplatform::class)
@OptionalExpectation
expect annotation class JsonProperty(
    val value: String,
    val namespace: String,
    val required: Boolean,
    val index: Int,
    val defaultValue: String,
    val access: Access
)

expect enum class Access {
    AUTO, READ_ONLY, WRITE_ONLY, READ_WRITE;
}

// annotation usage (default values not working)
@JsonProperty(value = "", namespace = "", required = true, index = -1, defaultValue = "", access = Access.AUTO)

JVM code:

actual typealias Access = JsonProperty.Access
actual typealias JsonProperty = com.fasterxml.jackson.annotation.JsonProperty

Yeah, i got to the same thing, same problem with default values That is annoying

Hey @Lucas, did you figure out a way?

Not really, only what is on this thread