Reflection: add API for declaration modifiers

#KT-10447 Fixed

compiler/testData/codegen/box/reflection/modifiers/callableModality.kt

@@ -0,0 +1,51 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+interface Interface {
+    open fun openFun() {}
+    abstract fun abstractFun()
+}
+
+abstract class AbstractClass {
+    final val finalVal = Unit
+    open val openVal = Unit
+    abstract var abstractVar: Unit
+}
+
+fun box(): String {
+    assertFalse(Interface::openFun.isFinal)
+    assertTrue(Interface::openFun.isOpen)
+    assertFalse(Interface::openFun.isAbstract)
+
+    assertFalse(Interface::abstractFun.isFinal)
+    assertFalse(Interface::abstractFun.isOpen)
+    assertTrue(Interface::abstractFun.isAbstract)
+
+    assertTrue(AbstractClass::finalVal.isFinal)
+    assertFalse(AbstractClass::finalVal.isOpen)
+    assertFalse(AbstractClass::finalVal.isAbstract)
+    assertTrue(AbstractClass::finalVal.getter.isFinal)
+    assertFalse(AbstractClass::finalVal.getter.isOpen)
+    assertFalse(AbstractClass::finalVal.getter.isAbstract)
+
+    assertFalse(AbstractClass::openVal.isFinal)
+    assertTrue(AbstractClass::openVal.isOpen)
+    assertFalse(AbstractClass::openVal.isAbstract)
+    assertFalse(AbstractClass::openVal.getter.isFinal)
+    assertTrue(AbstractClass::openVal.getter.isOpen)
+    assertFalse(AbstractClass::openVal.getter.isAbstract)
+
+    assertFalse(AbstractClass::abstractVar.isFinal)
+    assertFalse(AbstractClass::abstractVar.isOpen)
+    assertTrue(AbstractClass::abstractVar.isAbstract)
+    assertFalse(AbstractClass::abstractVar.getter.isFinal)
+    assertFalse(AbstractClass::abstractVar.getter.isOpen)
+    assertTrue(AbstractClass::abstractVar.getter.isAbstract)
+    assertFalse(AbstractClass::abstractVar.setter.isFinal)
+    assertFalse(AbstractClass::abstractVar.setter.isOpen)
+    assertTrue(AbstractClass::abstractVar.setter.isAbstract)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/modifiers/classModality.kt

@@ -0,0 +1,56 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+class FinalClass {
+    companion object Companion
+}
+open class OpenClass
+abstract class AbstractClass
+interface Interface
+enum class EnumClass
+enum class EnumClassWithAbstractMember { ; abstract fun foo() }
+annotation class AnnotationClass
+object Object
+
+fun box(): String {
+    assertTrue(FinalClass::class.isFinal)
+    assertFalse(FinalClass::class.isOpen)
+    assertFalse(FinalClass::class.isAbstract)
+
+    assertTrue(FinalClass.Companion::class.isFinal)
+    assertFalse(FinalClass.Companion::class.isOpen)
+    assertFalse(FinalClass.Companion::class.isAbstract)
+
+    assertFalse(OpenClass::class.isFinal)
+    assertTrue(OpenClass::class.isOpen)
+    assertFalse(OpenClass::class.isAbstract)
+
+    assertFalse(AbstractClass::class.isFinal)
+    assertFalse(AbstractClass::class.isOpen)
+    assertTrue(AbstractClass::class.isAbstract)
+
+    assertFalse(Interface::class.isFinal)
+    assertFalse(Interface::class.isOpen)
+    assertTrue(Interface::class.isAbstract)
+
+    assertTrue(EnumClass::class.isFinal)
+    assertFalse(EnumClass::class.isOpen)
+    assertFalse(EnumClass::class.isAbstract)
+
+    assertTrue(EnumClassWithAbstractMember::class.isFinal)
+    assertFalse(EnumClassWithAbstractMember::class.isOpen)
+    assertFalse(EnumClassWithAbstractMember::class.isAbstract)
+
+    // Note that unlike in JVM, annotation classes are final in Kotlin
+    assertTrue(AnnotationClass::class.isFinal)
+    assertFalse(AnnotationClass::class.isOpen)
+    assertFalse(AnnotationClass::class.isAbstract)
+
+    assertTrue(Object::class.isFinal)
+    assertFalse(Object::class.isOpen)
+    assertFalse(Object::class.isAbstract)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/modifiers/classes.kt

@@ -0,0 +1,43 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+sealed class S {
+    data class DataClass(val x: Int) : S()
+    inner class InnerClass
+    companion object
+    object NonCompanionObject
+}
+
+fun box(): String {
+    assertTrue(S::class.isSealed)
+    assertFalse(S::class.isFinal)
+    assertFalse(S::class.isOpen)
+    assertFalse(S::class.isAbstract)
+    assertFalse(S::class.isData)
+    assertFalse(S::class.isInner)
+    assertFalse(S::class.isCompanion)
+
+    assertFalse(S.DataClass::class.isSealed)
+    assertTrue(S.DataClass::class.isData)
+    assertFalse(S.DataClass::class.isInner)
+    assertFalse(S.DataClass::class.isCompanion)
+
+    assertFalse(S.InnerClass::class.isSealed)
+    assertFalse(S.InnerClass::class.isData)
+    assertTrue(S.InnerClass::class.isInner)
+    assertFalse(S.InnerClass::class.isCompanion)
+
+    assertFalse(S.Companion::class.isSealed)
+    assertFalse(S.Companion::class.isData)
+    assertFalse(S.Companion::class.isInner)
+    assertTrue(S.Companion::class.isCompanion)
+
+    assertFalse(S.NonCompanionObject::class.isSealed)
+    assertFalse(S.NonCompanionObject::class.isData)
+    assertFalse(S.NonCompanionObject::class.isInner)
+    assertFalse(S.NonCompanionObject::class.isCompanion)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/modifiers/functions.kt

@@ -0,0 +1,71 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+inline fun inline() {}
+class External { external fun external() }
+operator fun Unit.invoke() {}
+infix fun Unit.infix(unit: Unit) {}
+tailrec fun tailrec() { tailrec() }
+class Suspend { suspend fun suspend(c: Continuation<Unit>) {} }
+
+val externalGetter = Unit
+    external get
+
+inline var inlineProperty: Unit
+    get() = Unit
+    set(value) {}
+
+fun box(): String {
+    assertTrue(::inline.isInline)
+    assertFalse(::inline.isExternal)
+    assertFalse(::inline.isOperator)
+    assertFalse(::inline.isInfix)
+    assertFalse(::inline.isTailrec)
+    assertFalse(::inline.isSuspend)
+
+    assertFalse(External::external.isInline)
+    assertTrue(External::external.isExternal)
+    assertFalse(External::external.isOperator)
+    assertFalse(External::external.isInfix)
+    assertFalse(External::external.isTailrec)
+    assertFalse(External::external.isSuspend)
+
+    assertFalse(Unit::invoke.isInline)
+    assertFalse(Unit::invoke.isExternal)
+    assertTrue(Unit::invoke.isOperator)
+    assertFalse(Unit::invoke.isInfix)
+    assertFalse(Unit::invoke.isTailrec)
+    assertFalse(Unit::invoke.isSuspend)
+
+    assertFalse(Unit::infix.isInline)
+    assertFalse(Unit::infix.isExternal)
+    assertFalse(Unit::infix.isOperator)
+    assertTrue(Unit::infix.isInfix)
+    assertFalse(Unit::infix.isTailrec)
+    assertFalse(Unit::infix.isSuspend)
+
+    assertFalse(::tailrec.isInline)
+    assertFalse(::tailrec.isExternal)
+    assertFalse(::tailrec.isOperator)
+    assertFalse(::tailrec.isInfix)
+    assertTrue(::tailrec.isTailrec)
+    assertFalse(::tailrec.isSuspend)
+
+    assertFalse(Suspend::suspend.isInline)
+    assertFalse(Suspend::suspend.isExternal)
+    assertFalse(Suspend::suspend.isOperator)
+    assertFalse(Suspend::suspend.isInfix)
+    assertFalse(Suspend::suspend.isTailrec)
+    assertTrue(Suspend::suspend.isSuspend)
+
+    assertTrue(::externalGetter.getter.isExternal)
+    assertFalse(::externalGetter.getter.isInline)
+
+    assertFalse(::inlineProperty.getter.isExternal)
+    assertTrue(::inlineProperty.getter.isInline)
+    assertTrue(::inlineProperty.setter.isInline)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/modifiers/parameters.kt

@@ -0,0 +1,36 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+inline fun Unit.foo(
+        crossinline crossinline: () -> Unit,
+        noinline coroutine x: Unit.() -> Continuation<Unit>,
+        vararg vararg: Unit
+) {}
+
+fun box(): String {
+    val p = Unit::foo.parameters
+
+    assertFalse(p[0].isNoinline)
+    assertFalse(p[0].isCrossinline)
+    assertFalse(p[0].isVararg)
+    assertFalse(p[0].isCoroutine)
+
+    assertFalse(p[1].isNoinline)
+    assertTrue(p[1].isCrossinline)
+    assertFalse(p[1].isVararg)
+    assertFalse(p[1].isCoroutine)
+
+    assertTrue(p[2].isNoinline)
+    assertFalse(p[2].isCrossinline)
+    assertFalse(p[2].isVararg)
+    assertTrue(p[2].isCoroutine)
+
+    assertFalse(p[3].isNoinline)
+    assertFalse(p[3].isCrossinline)
+    assertTrue(p[3].isVararg)
+    assertFalse(p[3].isCoroutine)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/modifiers/properties.kt

@@ -0,0 +1,22 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+const val const = "const"
+val nonConst = "nonConst"
+
+class A {
+    lateinit var lateinit: Unit
+    var nonLateinit = Unit
+}
+
+fun box(): String {
+    assertTrue(::const.isConst)
+    assertFalse(::nonConst.isConst)
+
+    assertTrue(A::lateinit.isLateinit)
+    assertFalse(A::nonLateinit.isLateinit)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/modifiers/typeParameters.kt

@@ -0,0 +1,15 @@
+// WITH_REFLECT
+
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+class A {
+    fun <T> nonReified(): T = null!!
+    inline fun <reified U> reified(): U = null!!
+}
+
+fun box(): String {
+    assertFalse(A::class.members.single { it.name == "nonReified" }.typeParameters.single().isReified)
+    assertTrue(A::class.members.single { it.name == "reified" }.typeParameters.single().isReified)
+    return "OK"
+}