Clean up some code in compiler.resolution.common.jvm

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt

@@ -25,11 +25,11 @@ import org.jetbrains.org.objectweb.asm.*
 import java.lang.reflect.Array
 
 internal class AnnotationsAndParameterCollectorMethodVisitor(
-        private val member: BinaryJavaMethodBase,
+    private val member: BinaryJavaMethodBase,
-        private val context: ClassifierResolutionContext,
+    private val context: ClassifierResolutionContext,
-        private val signatureParser: BinaryClassSignatureParser,
+    private val signatureParser: BinaryClassSignatureParser,
-        private val parametersToSkipNumber: Int,
+    private val parametersToSkipNumber: Int,
-        private val parametersCountInMethodDesc: Int
+    private val parametersCountInMethodDesc: Int
 ) : MethodVisitor(ASM_API_VERSION_FOR_CLASS_READING) {
     private var parameterIndex = 0
 
@@ -106,17 +106,17 @@ internal class AnnotationsAndParameterCollectorMethodVisitor(
 }
 
 class BinaryJavaAnnotation private constructor(
-        desc: String,
+    desc: String,
-        private val context: ClassifierResolutionContext,
+    private val context: ClassifierResolutionContext,
-        override val arguments: Collection<JavaAnnotationArgument>
+    override val arguments: Collection<JavaAnnotationArgument>
 ) : JavaAnnotation {
 
     companion object {
 
         fun createAnnotationAndVisitor(
-                desc: String,
+            desc: String,
-                context: ClassifierResolutionContext,
+            context: ClassifierResolutionContext,
-                signatureParser: BinaryClassSignatureParser
+            signatureParser: BinaryClassSignatureParser
         ): Pair<JavaAnnotation, AnnotationVisitor> {
             val arguments = mutableListOf<JavaAnnotationArgument>()
             val annotation = BinaryJavaAnnotation(desc, context, arguments)
@@ -155,9 +155,9 @@ class BinaryJavaAnnotation private constructor(
         context.resolveByInternalName(Type.getType(desc).internalName)
     }
 
-    override val classId: ClassId?
+    override val classId: ClassId
         get() = classifierResolutionResult.classifier.safeAs<JavaClass>()?.classId
-                ?: ClassId.topLevel(FqName(classifierResolutionResult.qualifiedName))
+            ?: ClassId.topLevel(FqName(classifierResolutionResult.qualifiedName))
 
     override fun resolve() = classifierResolutionResult.classifier as? JavaClass
 }
@@ -224,37 +224,37 @@ abstract class PlainJavaAnnotationArgument(name: String?) : JavaAnnotationArgume
 }
 
 class PlainJavaLiteralAnnotationArgument(
-        name: String?,
+    name: String?,
-        override val value: Any?
+    override val value: Any?
 ) : PlainJavaAnnotationArgument(name), JavaLiteralAnnotationArgument
 
 class PlainJavaClassObjectAnnotationArgument(
-        name: String?,
+    name: String?,
-        private val type: Type,
+    private val type: Type,
-        private val signatureParser: BinaryClassSignatureParser,
+    private val signatureParser: BinaryClassSignatureParser,
-        private val context: ClassifierResolutionContext
+    private val context: ClassifierResolutionContext
 ) : PlainJavaAnnotationArgument(name), JavaClassObjectAnnotationArgument {
     override fun getReferencedType() = signatureParser.mapAsmType(type, context)
 }
 
 class PlainJavaArrayAnnotationArgument(
-        name: String?,
+    name: String?,
-        private val elements: List<JavaAnnotationArgument>
+    private val elements: List<JavaAnnotationArgument>
 ) : PlainJavaAnnotationArgument(name), JavaArrayAnnotationArgument {
     override fun getElements(): List<JavaAnnotationArgument> = elements
 }
 
 class PlainJavaAnnotationAsAnnotationArgument(
-        name: String?,
+    name: String?,
-        private val annotation: JavaAnnotation
+    private val annotation: JavaAnnotation
 ) : PlainJavaAnnotationArgument(name), JavaAnnotationAsAnnotationArgument {
     override fun getAnnotation() = annotation
 }
 
 class PlainJavaEnumValueAnnotationArgument(
-        name: String?,
+    name: String?,
-        override val enumClassId: ClassId,
+    override val enumClassId: ClassId,
-        entryName: String
+    entryName: String
 ) : PlainJavaAnnotationArgument(name), JavaEnumValueAnnotationArgument {
     override val entryName = Name.identifier(entryName)
 }

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt

@@ -105,8 +105,8 @@ class BinaryClassSignatureParser {
     }
 
     private fun parseParameterizedClassRefSignature(
-            signature: CharacterIterator,
+        signature: CharacterIterator,
-            context: ClassifierResolutionContext
+        context: ClassifierResolutionContext
     ): JavaClassifierType {
         val canonicalName = StringBuilder()
 
@@ -120,12 +120,10 @@ class BinaryClassSignatureParser {
                 signature.next()
                 do {
                     group.add(parseClassOrTypeVariableElement(signature, context))
-                }
+                } while (signature.current() != '>')
-                while (signature.current() != '>')
 
                 argumentGroups.add(group)
-            }
+            } else if (c != ' ') {
-            else if (c != ' ') {
                 canonicalName.append(c)
             }
             signature.next()
@@ -199,21 +197,21 @@ class BinaryClassSignatureParser {
     fun mapAsmType(type: Type, context: ClassifierResolutionContext) = parseTypeString(StringCharacterIterator(type.descriptor), context)
 
     private fun parseTypeWithoutVarianceAndArray(signature: CharacterIterator, context: ClassifierResolutionContext) =
-            when (signature.current()) {
+        when (signature.current()) {
-                'L' -> parseParameterizedClassRefSignature(signature, context)
+            'L' -> parseParameterizedClassRefSignature(signature, context)
-                'T' -> parseTypeVariableRefSignature(signature, context)
+            'T' -> parseTypeVariableRefSignature(signature, context)
 
-                'B' -> parsePrimitiveType(signature, PrimitiveType.BYTE)
+            'B' -> parsePrimitiveType(signature, PrimitiveType.BYTE)
-                'C' -> parsePrimitiveType(signature, PrimitiveType.CHAR)
+            'C' -> parsePrimitiveType(signature, PrimitiveType.CHAR)
-                'D' -> parsePrimitiveType(signature, PrimitiveType.DOUBLE)
+            'D' -> parsePrimitiveType(signature, PrimitiveType.DOUBLE)
-                'F' -> parsePrimitiveType(signature, PrimitiveType.FLOAT)
+            'F' -> parsePrimitiveType(signature, PrimitiveType.FLOAT)
-                'I' -> parsePrimitiveType(signature, PrimitiveType.INT)
+            'I' -> parsePrimitiveType(signature, PrimitiveType.INT)
-                'J' -> parsePrimitiveType(signature, PrimitiveType.LONG)
+            'J' -> parsePrimitiveType(signature, PrimitiveType.LONG)
-                'Z' -> parsePrimitiveType(signature, PrimitiveType.BOOLEAN)
+            'Z' -> parsePrimitiveType(signature, PrimitiveType.BOOLEAN)
-                'S' -> parsePrimitiveType(signature, PrimitiveType.SHORT)
+            'S' -> parsePrimitiveType(signature, PrimitiveType.SHORT)
-                'V' -> parsePrimitiveType(signature, null)
+            'V' -> parsePrimitiveType(signature, null)
-                else -> null
+            else -> null
-            }
+        }
 
     private fun parsePrimitiveType(signature: CharacterIterator, primitiveType: PrimitiveType?): JavaType {
         signature.next()