What does an `annotation class` compile to on the JVM, and why does its 'implicitly public, no-body' shape matter for interop and tooling?

## What it becomes on the JVM When you write: ```kotlin annotation class Loggable ``` the Kotlin compiler emits, for the JVM target, a **Java annotation type**: an `@interface Loggable` that implicitly extends `java.lang.annotation.Annotation`. This is the same construct Java's `public @interface Loggable {}` produces. That is why a Kotlin-declared annotation can be applied to **Java** code and a Java-declared annotation can be applied to **Kotlin** code seamlessly. ## Why 'implicitly public' matters Kotlin makes annotation classes **public by default**. On the JVM, annotation types you intend tools and other modules to read must be visible to them. A public type: - can be referenced from any module/package that depends on it, - is discoverable by reflection and annotation processors, - matches Java's expectation that annotation types are broadly accessible. Making it anything narrower would defeat the purpose of a marker meant to be consumed elsewhere. ## Why 'no body' matters The JVM annotation model only supports **annotation members** (which map to constructor params in Kotlin) — not arbitrary methods, fields, or init logic. By forbidding a behavioral body, Kotlin guarantees the declaration maps cleanly onto that model. There is no place for runtime behavior in a JVM annotation, so the language doesn't let you write one. ## Reflection on both sides ```kotlin import kotlin.reflect.full.findAnnotation annotation class Loggable @Loggable class Service fun main() { val present = Service::class.findAnnotation<Loggable>() != null println(present) // true } ``` - **Kotlin reflection** (`kotlin-reflect`) exposes annotations via `KClass`, `KFunction`, etc. - **Java reflection** sees the same type through `Class.getAnnotation(...)` because it is a real Java annotation type. (Actually *reading* annotations reflectively is a sibling topic; the point here is that the compiled shape makes both reflection worlds work.) ## Practical interop notes - A Kotlin annotation used from Java: `@Loggable` works in `.java` files when the class is on the classpath and public. - Whether the annotation survives to runtime for reflection depends on retention (sibling topic), but the *type* itself is always a proper JVM annotation type. ## Takeaway The 'implicitly public, no-body' design is not arbitrary: it is exactly the shape required to compile to a standard JVM annotation type, giving Kotlin annotations first-class interop with Java and the entire JVM tooling ecosystem.