Formatting: IR test classes

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractClosureAnnotatorTestCase.kt

@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.ir
 
+import org.jetbrains.kotlin.backend.common.AbstractClosureAnnotator
+import org.jetbrains.kotlin.backend.common.Closure
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.test.KotlinTestUtils
-import org.jetbrains.kotlin.backend.common.AbstractClosureAnnotator
-import org.jetbrains.kotlin.backend.common.Closure
 import java.io.File
 import java.io.PrintWriter
 import java.io.StringWriter
@@ -57,8 +57,7 @@ abstract class AbstractClosureAnnotatorTestCase : AbstractIrGeneratorTestCase()
             override fun recordFunctionClosure(functionDescriptor: FunctionDescriptor, closure: Closure) {
                 if (functionDescriptor is ConstructorDescriptor) {
                     actualOut.println("Closure for constructor ${functionDescriptor.containingDeclaration.name}:")
-                }
+                } else {
-                else {
                     actualOut.println("Closure for function ${functionDescriptor.name}:")
                 }
                 printClosure(closure)

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt

@@ -69,10 +69,10 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
         }
 
         val configuration = createConfiguration(
-                configurationKind, jdkKind,
+            configurationKind, jdkKind,
-                listOf<File>(getAnnotationsJar()),
+            listOf<File>(getAnnotationsJar()),
-                arrayOf(javaFilesDir).filterNotNull(),
+            arrayOf(javaFilesDir).filterNotNull(),
-                files
+            files
         )
 
         myEnvironment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
@@ -96,7 +96,7 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
         private val IGNORE_ERRORS_PATTERN = Regex("""// !IGNORE_ERRORS""")
 
         internal fun shouldIgnoreErrors(wholeFile: File): Boolean =
-                IGNORE_ERRORS_PATTERN.containsMatchIn(wholeFile.readText())
+            IGNORE_ERRORS_PATTERN.containsMatchIn(wholeFile.readText())
 
         internal fun createExpectedTextFile(testFile: TestFile, dir: File, fileName: String): File {
             val textFile = File(dir, fileName)
@@ -110,10 +110,10 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
         }
 
         fun generateIrModule(
-                ktFilesToAnalyze: List<KtFile>,
+            ktFilesToAnalyze: List<KtFile>,
-                environment: KotlinCoreEnvironment,
+            environment: KotlinCoreEnvironment,
-                psi2ir: Psi2IrTranslator,
+            psi2ir: Psi2IrTranslator,
-                shouldGenerate: (KtFile) -> Boolean
+            shouldGenerate: (KtFile) -> Boolean
         ): IrModuleFragment {
             val analysisResult = JvmResolveUtil.analyze(ktFilesToAnalyze, environment)
             if (!psi2ir.configuration.ignoreErrors) {
@@ -124,11 +124,21 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
             return generateIrModule(fileToGenerate, analysisResult.moduleDescriptor, analysisResult.bindingContext, psi2ir)
         }
 
-        fun generateIrModule(ktFiles: List<KtFile>, moduleDescriptor: ModuleDescriptor, bindingContext: BindingContext, ignoreErrors: Boolean = false) =
+        fun generateIrModule(
-                generateIrModule(ktFiles, moduleDescriptor, bindingContext, Psi2IrTranslator(Psi2IrConfiguration(ignoreErrors)))
+            ktFiles: List<KtFile>,
+            moduleDescriptor: ModuleDescriptor,
+            bindingContext: BindingContext,
+            ignoreErrors: Boolean = false
+        ) =
+            generateIrModule(ktFiles, moduleDescriptor, bindingContext, Psi2IrTranslator(Psi2IrConfiguration(ignoreErrors)))
 
-        fun generateIrModule(ktFiles: List<KtFile>, moduleDescriptor: ModuleDescriptor, bindingContext: BindingContext, psi2ir: Psi2IrTranslator) =
+        fun generateIrModule(
-                psi2ir.generateModule(moduleDescriptor, ktFiles, bindingContext)
+            ktFiles: List<KtFile>,
+            moduleDescriptor: ModuleDescriptor,
+            bindingContext: BindingContext,
+            psi2ir: Psi2IrTranslator
+        ) =
+            psi2ir.generateModule(moduleDescriptor, ktFiles, bindingContext)
     }
 }
 

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrSourceRangesTestCase.kt

@@ -36,13 +36,13 @@ abstract class AbstractIrSourceRangesTestCase : AbstractIrGeneratorTestCase() {
     }
 
     private fun IrElement.dumpWithSourceLocations(fileEntry: SourceManager.FileEntry): String =
-            StringBuilder().also {
+        StringBuilder().also {
-                acceptVoid(DumpSourceLocations(it, fileEntry))
+            acceptVoid(DumpSourceLocations(it, fileEntry))
-            }.toString()
+        }.toString()
 
     private class DumpSourceLocations(
-            out: Appendable,
+        out: Appendable,
-            val fileEntry: SourceManager.FileEntry
+        val fileEntry: SourceManager.FileEntry
     ) : IrElementVisitorVoid {
         val printer = Printer(out, "  ")
         val elementRenderer = RenderIrElementVisitor()
@@ -56,9 +56,9 @@ abstract class AbstractIrSourceRangesTestCase : AbstractIrGeneratorTestCase() {
         }
 
         private fun SourceRangeInfo.render() =
-                if (startLineNumber == endLineNumber)
+            if (startLineNumber == endLineNumber)
-                    "$startLineNumber:$startColumnNumber..$endColumnNumber"
+                "$startLineNumber:$startColumnNumber..$endColumnNumber"
-                else
+            else
-                    "$startLineNumber:$startColumnNumber..$endLineNumber:$endColumnNumber"
+                "$startLineNumber:$startColumnNumber..$endLineNumber:$endColumnNumber"
     }
 }

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractPsi2IrBoxTestCase.kt

@@ -25,8 +25,8 @@ abstract class AbstractPsi2IrBoxTestCase : AbstractIrGeneratorTestCase() {
         val irModule = generateIrModule(false)
         val irModuleDump = irModule.dump()
         val expectedPath = wholeFile.canonicalPath
-                // .replace("/codegen/box/", "/ir/irTextBox/")
+            // .replace("/codegen/box/", "/ir/irTextBox/")
-                .replace(".kt", ".txt")
+            .replace(".kt", ".txt")
         val expectedFile = File(expectedPath)
         KotlinTestUtils.assertEqualsToFile(expectedFile, irModuleDump)
     }

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractPsi2IrDiagnosticsTest.kt

@@ -25,11 +25,11 @@ import java.io.File
 
 abstract class AbstractPsi2IrDiagnosticsTest : AbstractDiagnosticsTest() {
     override fun performAdditionalChecksAfterDiagnostics(
-            testDataFile: File,
+        testDataFile: File,
-            testFiles: List<TestFile>,
+        testFiles: List<TestFile>,
-            moduleFiles: Map<TestModule?, List<TestFile>>,
+        moduleFiles: Map<TestModule?, List<TestFile>>,
-            moduleDescriptors: Map<TestModule?, ModuleDescriptorImpl>,
+        moduleDescriptors: Map<TestModule?, ModuleDescriptorImpl>,
-            moduleBindings: Map<TestModule?, BindingContext>
+        moduleBindings: Map<TestModule?, BindingContext>
     ) {
         val actualIrDump = StringBuilder()
         for (module in moduleFiles.keys) {