Reflection: add KVisibility, KClass.visibility, KCallable.visibility

core/builtins/src/kotlin/reflect/KCallable.kt

@@ -63,6 +63,11 @@ public interface KCallable<out R> : KAnnotatedElement {
      */
     public fun callBy(args: Map<KParameter, Any?>): R
 
+    /**
+     * Visibility of this callable, or `null` if its visibility cannot be represented in Kotlin.
+     */
+    public val visibility: KVisibility?
+
     /**
      * `true` if this callable is `final`.
      */

core/builtins/src/kotlin/reflect/KClass.kt

@@ -73,6 +73,11 @@ public interface KClass<T : Any> : KDeclarationContainer, KAnnotatedElement, KCl
      */
     public val supertypes: List<KType>
 
+    /**
+     * Visibility of this class, or `null` if its visibility cannot be represented in Kotlin.
+     */
+    public val visibility: KVisibility?
+
     /**
      * `true` if this class is `final`.
      */

core/builtins/src/kotlin/reflect/KVisibility.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlin.reflect
+
+/**
+ * Visibility is an aspect of a Kotlin declaration regulating where that declaration is accessible in the source code.
+ * Visibility can be changed with one of the following modifiers: `public`, `protected`, `internal`, `private`.
+ *
+ * Note that some Java visibilities such as package-private and protected (which also gives access to items from the same package)
+ * cannot be represented in Kotlin, so there's no [KVisibility] value corresponding to them.
+ *
+ * See the [Kotlin language documentation](https://kotlinlang.org/docs/reference/visibility-modifiers.html)
+ * for more information.
+ */
+enum class KVisibility {
+    /**
+     * Visibility of declarations marked with the `public` modifier, or with no modifier at all.
+     */
+    PUBLIC,
+
+    /**
+     * Visibility of declarations marked with the `protected` modifier.
+     */
+    PROTECTED,
+
+    /**
+     * Visibility of declarations marked with the `internal` modifier.
+     */
+    INTERNAL,
+
+    /**
+     * Visibility of declarations marked with the `private` modifier.
+     */
+    PRIVATE,
+}

core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt

@@ -63,6 +63,9 @@ internal interface KCallableImpl<out R> : KCallable<R>, KAnnotatedElementImpl {
     override val typeParameters: List<KTypeParameter>
         get() = descriptor.typeParameters.map(::KTypeParameterImpl)
 
+    override val visibility: KVisibility?
+        get() = descriptor.visibility.toKVisibility()
+
     override val isFinal: Boolean
         get() = descriptor.modality == Modality.FINAL
 

core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt

@@ -170,6 +170,9 @@ internal class KClassImpl<T : Any>(override val jClass: Class<T>) :
             }
         }
 
+    override val visibility: KVisibility?
+        get() = descriptor.visibility.toKVisibility()
+
     override val isFinal: Boolean
         get() = descriptor.modality == Modality.FINAL
 

core/reflection.jvm/src/kotlin/reflect/jvm/internal/util.kt

@@ -17,6 +17,8 @@
 package kotlin.reflect.jvm.internal
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.load.java.components.RuntimeSourceElementFactory
 import org.jetbrains.kotlin.load.java.reflect.tryLoadClass
 import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaClass
@@ -30,6 +32,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import kotlin.jvm.internal.FunctionReference
 import kotlin.jvm.internal.PropertyReference
 import kotlin.reflect.IllegalCallableAccessException
+import kotlin.reflect.KVisibility
 
 internal val JVM_STATIC = FqName("kotlin.jvm.JvmStatic")
 
@@ -73,6 +76,15 @@ internal fun loadClass(classLoader: ClassLoader, packageName: String, className:
     return classLoader.tryLoadClass("$packageName.${className.replace('.', '$')}")
 }
 
+internal fun Visibility.toKVisibility(): KVisibility? =
+        when (this) {
+            Visibilities.PUBLIC -> KVisibility.PUBLIC
+            Visibilities.PROTECTED -> KVisibility.PROTECTED
+            Visibilities.INTERNAL -> KVisibility.INTERNAL
+            Visibilities.PRIVATE, Visibilities.PRIVATE_TO_THIS -> KVisibility.PRIVATE
+            else -> null
+        }
+
 // TODO: wrap other exceptions
 internal inline fun <R> reflectionCall(block: () -> R): R =
         try {

core/runtime.jvm/src/kotlin/jvm/internal/CallableReference.java

@@ -19,6 +19,7 @@ package kotlin.jvm.internal;
 import kotlin.jvm.KotlinReflectionNotSupportedError;
 import kotlin.reflect.*;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.lang.annotation.Annotation;
 import java.util.List;
@@ -99,6 +100,12 @@ public abstract class CallableReference implements KCallable {
         return getReflected().callBy(args);
     }
 
+    @Nullable
+    @Override
+    public KVisibility getVisibility() {
+        return getReflected().getVisibility();
+    }
+
     @Override
     public boolean isFinal() {
         return getReflected().isFinal();

core/runtime.jvm/src/kotlin/jvm/internal/ClassReference.kt

@@ -48,6 +48,9 @@ class ClassReference(override val jClass: Class<*>) : KClass<Any>, ClassBasedDec
     override val supertypes: List<KType>
         get() = error()
 
+    override val visibility: KVisibility?
+        get() = error()
+
     override val isFinal: Boolean
         get() = error()
 

core/runtime.jvm/src/kotlin/jvm/internal/FunctionReference.java

@@ -19,6 +19,7 @@ package kotlin.jvm.internal;
 import kotlin.jvm.KotlinReflectionNotSupportedError;
 import kotlin.reflect.*;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.lang.annotation.Annotation;
 import java.util.List;
@@ -84,6 +85,12 @@ public class FunctionReference extends FunctionImpl implements KFunction {
         return getReflected().callBy(args);
     }
 
+    @Nullable
+    @Override
+    public KVisibility getVisibility() {
+        return getReflected().getVisibility();
+    }
+
     @Override
     public boolean isFinal() {
         return getReflected().isFinal();