Kotlin is developing a reflection API that will work for both Kotlin and Java code. Metadata is represented using annotations stored in class files. There are challenges representing Kotlin features in Java reflection and discrepancies between Kotlin and Java representations of concepts like nullability. Reflection literals provide a syntax to access metadata at compile time, but generics pose difficulties. Expression trees could allow compiling Kotlin code to other languages like JavaScript.

1. KOTLIN
GETS
REFLECTION
Andrey.Breslav@JetBrains.com

2. Introspection is examination of
one's own conscious thoughts
and feelings.
Schultz, D. P.; Schultz, S. E. (2012).
A history of modern psychology (10th ed.)

3. LEGAL
Takeiteasy

4. DON’T JUDGE
STRICTLY

5. OUTLINE
• Intro
• Ways of Introspection
• Reflection API
• Reflection Literals
• Expression Trees
• Conclusion

6. USE CASES
Dependency Injection
Data binding
Convention over
configuration
Hacks
Workarounds
Black Magic

7. INTROSPECTION
Instances
- what is your class?
Classes & Types
- what are your members? supertypes? create an instance
Methods/Fields
- what are your parameters/types/etc? run with these args.
Expressions
- ???

8. JAVA.LANG.REFLECT?
Top-level functions
Default arguments
Properties
Nullable types
Special types (Nothing, (Mutable)List, etc)
…
+ modules (classes in a package)

9. METADATA
*.kt
*.class
(kotlin)
*.jar
(kotlin)
kotlin
symbols
kotlin
symbols
kotlin
symbols
java
symbols
kotlinc

10. HOW TO STORE
METADATA?
*.class
Custom
attributes
Annotations
Annotate each
symbol
One big
annotation

11. ONE BIG ANNOTATION
*.class
@KotlinClass(“data”)
val/var types defaults …
Java definitions
erased generic annotations …

12. RE-USE
j.l.Class
*.kt
*.class
AST
@KotlinClass
Symbols

13. DISCREPANCY 1
java.lang.annotation.Annotation
vs
org.jetbrains.kotlin.internal….AnnotationDescriptor

14. PURE JAVA CLASSES?
j.l.Class
*.kt
*.class
AST
@KotlinClass
Symbols
*.java
java2k

15. DISCREPANCY 2
// Java
class Foo {
@NotNull
String getFirstName() { … }
String getMiddleName() { … }
}
// Corresponding Kotlin
class Foo {
fun getFirstName(): String
fun getMiddleName(): String?
}

16. DISCREPANCY 2
j.l.Class
*.class Symbols
*.java
java2k
annotations.xml

17. SUMMARY 1
Kotlin-specific reflection API
- works for Java as well
Metadata representation
- one big annotation
- re-use code from the compiler
Problems
- representing annotations
- nullable/mutable types

18. ENTRY
POINTS

19. SYNTAX (TENTATIVE)
Foo::class
expr::class
List<String>::member
org.sample.bar::member
expr::member
expr::type (maybe)

20. USE CASES:
PASSING CODE AROUND
list.filter(Item::isValid)
* Why not a lambda?
foo {a, b, c -> bar(a, b, c) }

21. USE CASES:
CONSTRUCTORS
fun <T: Tag> tag(
create: () -> T, init: T.() -> Unit
) { … }
tag(::DIV) { // kara.tags::DIV
…
}

22. USE CASES:
DATA BINDING
class Model {
var userName: String by observable()
}
bind(view.textField, model::userName)

23. GENERICS?
fun foo(s: String): Foo
::foo : (String) -> Foo
fun <T> foo(t: T): T { … }
::foo : ∀T.(T) -> T

24. RANK-2
POLYMORPHISM
interface Function1<P1, R> {
R invoke(P1 p1);
}
vs
interface GenericFunction1_1<P1, R> {
<T> R<T> invoke(P1<T> p1);
}

25. ENCODING FOR
FUNCTIONS
f: (Foo) -> Bar is Function1<Foo, Bar>
interface Function1<P1, R> {
R invoke(P1 p1);
}

26. GENERIC FUNCTIONS
f: <T>(List<T>) -> T
• GenericFunction<List<T>, T> ???
• GenericFunction<T, List<T>, T> ???
interface GenericFunction1_1<P1, R> {
<T> R<T> invoke(P1<T> p1);
}
+ Kinds

27. GENERICS
class Foo<T> {
fun <R> bar(t: T): R { … }
}
Foo<T’>::bar<R’> : (T’) -> R’

28. EXPR::TYPE
val x: Any = listOf(1, 2, 3)
x::class -> java.util.ArrayList
x::type -> java.util.ArrayList<Unknown>
vs
val x = listOf(1, 2, 3) // x: List<Int>
x::class -> java.util.ArrayList
x::type -> java.util.ArrayList<Int>

29. DELEGATED
PROPERTIES
val foos: List<Foo> by Lazy { foos.find(…) }
class Lazy<T>(compute: () -> T) {
private var value: T? = null
fun get(me: Any, p: PropertyMetadata): T {
if (value == null) value = compute()
return value
}
}

30. DELEGATED
PROPERTIES
val foos: List<Foo> by Lazy { foos.find(…) }
::foos::delegate : Lazy<Foo>
::foos : Property<List<Foo>>
or
::foos.delegate : Lazy<Foo>
::foos : DelegatedProperty<
List<Foo>,
Lazy<Foo>
>

31. SUMMARY 2
Reflection literals
- Static name lookup & typing
- Generics are hard, as usual

32. CODE
INTROSPECTION
I told you!

33. USE CASES: LINQ
db
.selectFrom(::User)
.where { lastName.startsWith(“A”) }
.orderBy { lastName + firstName }

34. server
client
server
USE CASES: WEB
html {
body {
onLoad {
...
}
...
}
}

35. EXPRESSION TREES
fun onLoad(ast: Expression<() -> Unit>) {
...
}
onLoad {
... // compiled to factory calls
}
At run time the tree can be translated to JS

36. SUMMARY
Kotlin’s introspection facilities
- Reflection API
- Java interop is the hardest issue
- Reflection literals
- Issues with generics
- Expression trees
- Compiler as a service