JavacWrapper: remove code duplication around getVisibility

compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/utils.kt

@@ -36,21 +36,22 @@ internal val Element.isStatic: Boolean
 internal val Element.isFinal: Boolean
     get() = modifiers.contains(Modifier.FINAL)
 
-internal fun Element.getVisibility(): Visibility = modifiers.let { modifiers ->
+internal fun Element.getVisibility(): Visibility = modifiers.getVisibility()
+
+internal fun Set<Modifier>.getVisibility(): Visibility =
     when {
-        Modifier.PUBLIC in modifiers -> Visibilities.PUBLIC
+        Modifier.PUBLIC in this -> Visibilities.PUBLIC
-        Modifier.PRIVATE in modifiers -> Visibilities.PRIVATE
+        Modifier.PRIVATE in this -> Visibilities.PRIVATE
-        Modifier.PROTECTED in modifiers -> {
+        Modifier.PROTECTED in this -> {
-            if (Modifier.STATIC in modifiers) {
+            if (Modifier.STATIC in this) {
                 JavaVisibilities.PROTECTED_STATIC_VISIBILITY
-            }
+            } else {
-            else {
                 JavaVisibilities.PROTECTED_AND_PACKAGE
             }
         }
         else -> JavaVisibilities.PACKAGE_VISIBILITY
     }
-}
+
 
 internal fun TypeElement.computeClassId(): ClassId? {
     val enclosingElement = enclosingElement
@@ -63,20 +64,23 @@ internal fun TypeElement.computeClassId(): ClassId? {
 }
 
 internal fun ExecutableElement.valueParameters(javac: JavacWrapper): List<JavaValueParameter> =
-        parameters.let { parameters ->
+    parameters.let { parameters ->
-            val isVarArgs = isVarArgs
+        val isVarArgs = isVarArgs
-            val lastIndex = parameters.lastIndex
+        val lastIndex = parameters.lastIndex
-            parameters.mapIndexed { index, parameter ->
+        parameters.mapIndexed { index, parameter ->
-                val simpleName = parameter.simpleName.toString()
+            val simpleName = parameter.simpleName.toString()
-                SymbolBasedValueParameter(parameter,
+            SymbolBasedValueParameter(
-                                          if (!simpleName.contentEquals("arg$index")) simpleName else "p$index",
+                parameter,
-                                          index == lastIndex && isVarArgs,
+                if (!simpleName.contentEquals("arg$index")) simpleName else "p$index",
-                                          javac)
+                index == lastIndex && isVarArgs,
-            }
+                javac
+            )
         }
+    }
 
-internal fun AnnotatedConstruct.findAnnotation(fqName: FqName,
+internal fun AnnotatedConstruct.findAnnotation(
-                                               javac: JavacWrapper) =
+    fqName: FqName,
-        annotationMirrors.find {
+    javac: JavacWrapper
-            (it.annotationType.asElement() as TypeElement).qualifiedName.toString() == fqName.asString()
+) = annotationMirrors.find {
-        }?.let { SymbolBasedAnnotation(it, javac) }
+    (it.annotationType.asElement() as TypeElement).qualifiedName.toString() == fqName.asString()
+}?.let { SymbolBasedAnnotation(it, javac) }

compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/utils.kt

@@ -17,11 +17,10 @@
 package org.jetbrains.kotlin.javac.wrappers.trees
 
 import com.sun.tools.javac.tree.JCTree
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedArrayAnnotationArgument
 import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedReferenceAnnotationArgument
-import org.jetbrains.kotlin.load.java.JavaVisibilities
+import org.jetbrains.kotlin.javac.wrappers.symbols.getVisibility
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -41,17 +40,7 @@ internal val JCTree.JCModifiers.hasDefaultModifier: Boolean
     get() = Modifier.DEFAULT in getFlags()
 
 internal val JCTree.JCModifiers.visibility: Visibility
-    get() = getFlags().let {
+    get() = getFlags().getVisibility()
-        when {
-            Modifier.PUBLIC in it -> Visibilities.PUBLIC
-            Modifier.PRIVATE in it -> Visibilities.PRIVATE
-            Modifier.PROTECTED in it -> {
-                if (Modifier.STATIC in it) JavaVisibilities.PROTECTED_STATIC_VISIBILITY
-                else JavaVisibilities.PROTECTED_AND_PACKAGE
-            }
-            else -> JavaVisibilities.PACKAGE_VISIBILITY
-        }
-    }
 
 internal fun JCTree.annotations(): Collection<JCTree.JCAnnotation> = when (this) {
     is JCTree.JCMethodDecl -> mods?.annotations
@@ -71,12 +60,13 @@ fun Collection<JavaAnnotation>.filterTypeAnnotations(): Collection<JavaAnnotatio
 
         when (elementTypeArg) {
             is SymbolBasedArrayAnnotationArgument -> {
-                elementTypeArg.args.find { (it as? SymbolBasedReferenceAnnotationArgument)?.element?.simpleName?.contentEquals("TYPE_USE") ?: false }
+                elementTypeArg.args.find {
-                        ?.let { filteredAnnotations.add(annotation) }
+                    (it as? SymbolBasedReferenceAnnotationArgument)?.element?.simpleName?.contentEquals("TYPE_USE") ?: false
+                }?.let { filteredAnnotations.add(annotation) }
             }
             is SymbolBasedReferenceAnnotationArgument -> {
                 elementTypeArg.element.simpleName.takeIf { it.contentEquals("TYPE_USE") }
-                        ?.let { filteredAnnotations.add(annotation) }
+                    ?.let { filteredAnnotations.add(annotation) }
             }
             is TreeBasedArrayAnnotationArgument -> {
                 elementTypeArg.args.find {