From 2866bd84a1736bb684e23d0a93190564bad4ea6c Mon Sep 17 00:00:00 2001
From: Dmitriy Novozhilov <novodmit.2x@yandex.ru>
Date: Mon, 24 Sep 2018 13:47:51 +0300
Subject: [PATCH] Reformat BaseDiagnosticTest according to code style

---
 .../kotlin/checkers/BaseDiagnosticsTest.kt    | 210 ++++++++++--------
 1 file changed, 112 insertions(+), 98 deletions(-)

diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt
index 19e4f4cfb7b..4cadfd146ad 100644
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt
@@ -62,15 +62,15 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
     }
 
     override fun createTestModule(name: String): TestModule =
-            TestModule(name)
+        TestModule(name)
 
     override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Map<String, String>): TestFile =
-            TestFile(module, fileName, text, directives)
+        TestFile(module, fileName, text, directives)
 
     override fun doMultiFileTest(
-            file: File,
-            modules: @JvmSuppressWildcards Map<String, ModuleAndDependencies>,
-            testFiles: List<TestFile>
+        file: File,
+        modules: @JvmSuppressWildcards Map<String, ModuleAndDependencies>,
+        testFiles: List<TestFile>
     ) {
         for (moduleAndDependencies in modules.values) {
             moduleAndDependencies.module.getDependencies().addAll(moduleAndDependencies.dependencies.map { name ->
@@ -120,10 +120,10 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
     }
 
     inner class TestFile(
-            val module: TestModule?,
-            val fileName: String,
-            textWithMarkers: String,
-            val directives: Map<String, String>
+        val module: TestModule?,
+        val fileName: String,
+        textWithMarkers: String,
+        val directives: Map<String, String>
     ) {
         private val diagnosedRanges: List<CheckerTestUtil.DiagnosedRange> = ArrayList()
         val actualDiagnostics: MutableList<ActualDiagnostic> = ArrayList()
@@ -150,14 +150,14 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             this.declareFlexibleType = EXPLICIT_FLEXIBLE_TYPES_DIRECTIVE in directives
             this.markDynamicCalls = MARK_DYNAMIC_CALLS_DIRECTIVE in directives
             this.withNewInferenceDirective = WITH_NEW_INFERENCE_DIRECTIVE in directives
-            this.newInferenceEnabled = customLanguageVersionSettings?.supportsFeature(LanguageFeature.NewInference) ?: shouldUseNewInferenceForTests()
+            this.newInferenceEnabled = customLanguageVersionSettings?.supportsFeature(LanguageFeature.NewInference) ?:
+                    shouldUseNewInferenceForTests()
             if (fileName.endsWith(".java")) {
                 // TODO: check there are no syntax errors in .java sources
                 this.createKtFile = lazyOf(null)
                 this.clearText = textWithMarkers
                 this.expectedText = this.clearText
-            }
-            else {
+            } else {
                 this.expectedText = textWithMarkers
                 this.clearText = CheckerTestUtil.parseDiagnosedRanges(addExtras(expectedText), diagnosedRanges)
                 this.createKtFile = lazy { TestCheckerUtil.createCheckAndReturnPsiFile(fileName, clearText, project) }
@@ -181,7 +181,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             get() = "/*extras*/\n$imports/*extras*/\n\n"
 
         private fun addExtras(text: String): String =
-                addImports(text, extras)
+            addImports(text, extras)
 
         private fun stripExtras(actualText: StringBuilder) {
             val extras = extras
@@ -198,8 +198,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             if (matcher.find()) {
                 // add imports after the package directive
                 result = result.substring(0, matcher.end()) + imports + result.substring(matcher.end())
-            }
-            else {
+            } else {
                 // add imports at the beginning
                 result = imports + result
             }
@@ -212,10 +211,10 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         }
 
         fun getActualText(
-                bindingContext: BindingContext,
-                implementingModulesBindings: List<Pair<MultiTargetPlatform, BindingContext>>,
-                actualText: StringBuilder,
-                skipJvmSignatureDiagnostics: Boolean
+            bindingContext: BindingContext,
+            implementingModulesBindings: List<Pair<MultiTargetPlatform, BindingContext>>,
+            actualText: StringBuilder,
+            skipJvmSignatureDiagnostics: Boolean
         ): Boolean {
             val ktFile = this.ktFile
             if (ktFile == null) {
@@ -235,10 +234,10 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             val ok = booleanArrayOf(true)
             val withNewInference = newInferenceEnabled && withNewInferenceDirective && !USE_OLD_INFERENCE_DIAGNOSTICS_FOR_NI
             val diagnostics = ContainerUtil.filter(
-                    CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(
-                            bindingContext, implementingModulesBindings, ktFile, markDynamicCalls, dynamicCallDescriptors, newInferenceEnabled
-                    ) + jvmSignatureDiagnostics,
-                    { whatDiagnosticsToConsider.value(it.diagnostic) }
+                CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(
+                    bindingContext, implementingModulesBindings, ktFile, markDynamicCalls, dynamicCallDescriptors, newInferenceEnabled
+                ) + jvmSignatureDiagnostics,
+                { whatDiagnosticsToConsider.value(it.diagnostic) }
             )
 
             actualDiagnostics.addAll(diagnostics)
@@ -247,56 +246,64 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             val inferenceCompatibilityOfTest = asInferenceCompatibility(withNewInference)
             val invertedInferenceCompatibilityOfTest = asInferenceCompatibility(!withNewInference)
 
-            val diagnosticToExpectedDiagnostic = CheckerTestUtil.diagnosticsDiff(diagnosedRanges, diagnostics, object : CheckerTestUtil.DiagnosticDiffCallbacks {
-                override fun missingDiagnostic(diagnostic: CheckerTestUtil.TextDiagnostic, expectedStart: Int, expectedEnd: Int) {
-                    if (withNewInferenceDirective && diagnostic.inferenceCompatibility != inferenceCompatibilityOfTest) {
-                        updateUncheckedDiagnostics(diagnostic, expectedStart, expectedEnd)
-                        return
+            val diagnosticToExpectedDiagnostic =
+                CheckerTestUtil.diagnosticsDiff(diagnosedRanges, diagnostics, object : CheckerTestUtil.DiagnosticDiffCallbacks {
+                    override fun missingDiagnostic(diagnostic: CheckerTestUtil.TextDiagnostic, expectedStart: Int, expectedEnd: Int) {
+                        if (withNewInferenceDirective && diagnostic.inferenceCompatibility != inferenceCompatibilityOfTest) {
+                            updateUncheckedDiagnostics(diagnostic, expectedStart, expectedEnd)
+                            return
+                        }
+
+                        val message = "Missing " + diagnostic.description + PsiDiagnosticUtils.atLocation(
+                            ktFile,
+                            TextRange(expectedStart, expectedEnd)
+                        )
+                        System.err.println(message)
+                        ok[0] = false
                     }
 
-                    val message = "Missing " + diagnostic.description + PsiDiagnosticUtils.atLocation(
-                        ktFile,
-                        TextRange(expectedStart, expectedEnd)
-                    )
-                    System.err.println(message)
-                    ok[0] = false
-                }
-
-                override fun wrongParametersDiagnostic(
+                    override fun wrongParametersDiagnostic(
                         expectedDiagnostic: CheckerTestUtil.TextDiagnostic,
                         actualDiagnostic: CheckerTestUtil.TextDiagnostic,
                         start: Int,
                         end: Int
-                ) {
-                    val message = "Parameters of diagnostic not equal at position " +
-                            PsiDiagnosticUtils.atLocation(ktFile, TextRange(start, end)) +
-                                  ". Expected: ${expectedDiagnostic.asString()}, actual: $actualDiagnostic"
-                    System.err.println(message)
-                    ok[0] = false
-                }
-
-                override fun unexpectedDiagnostic(diagnostic: CheckerTestUtil.TextDiagnostic, actualStart: Int, actualEnd: Int) {
-                    if (withNewInferenceDirective && diagnostic.inferenceCompatibility != inferenceCompatibilityOfTest) {
-                        updateUncheckedDiagnostics(diagnostic, actualStart, actualEnd)
-                        return
+                    ) {
+                        val message = "Parameters of diagnostic not equal at position " +
+                                PsiDiagnosticUtils.atLocation(ktFile, TextRange(start, end)) +
+                                ". Expected: ${expectedDiagnostic.asString()}, actual: $actualDiagnostic"
+                        System.err.println(message)
+                        ok[0] = false
                     }
 
-                    val message = "Unexpected ${diagnostic.description}${PsiDiagnosticUtils.atLocation(
-                        ktFile,
-                        TextRange(actualStart, actualEnd)
-                    )}"
-                    System.err.println(message)
-                    ok[0] = false
-                }
+                    override fun unexpectedDiagnostic(diagnostic: CheckerTestUtil.TextDiagnostic, actualStart: Int, actualEnd: Int) {
+                        if (withNewInferenceDirective && diagnostic.inferenceCompatibility != inferenceCompatibilityOfTest) {
+                            updateUncheckedDiagnostics(diagnostic, actualStart, actualEnd)
+                            return
+                        }
 
-                fun updateUncheckedDiagnostics(diagnostic: CheckerTestUtil.TextDiagnostic, start: Int, end: Int) {
-                    diagnostic.enhanceInferenceCompatibility(invertedInferenceCompatibilityOfTest)
-                    uncheckedDiagnostics.add(PositionalTextDiagnostic(diagnostic, start, end))
-                }
-            })
+                        val message = "Unexpected ${diagnostic.description}${PsiDiagnosticUtils.atLocation(
+                            ktFile,
+                            TextRange(actualStart, actualEnd)
+                        )}"
+                        System.err.println(message)
+                        ok[0] = false
+                    }
 
-            actualText.append(CheckerTestUtil.addDiagnosticMarkersToText(
-                    ktFile, diagnostics, diagnosticToExpectedDiagnostic, { file -> file.text }, uncheckedDiagnostics, withNewInferenceDirective)
+                    fun updateUncheckedDiagnostics(diagnostic: CheckerTestUtil.TextDiagnostic, start: Int, end: Int) {
+                        diagnostic.enhanceInferenceCompatibility(invertedInferenceCompatibilityOfTest)
+                        uncheckedDiagnostics.add(PositionalTextDiagnostic(diagnostic, start, end))
+                    }
+                })
+
+            actualText.append(
+                CheckerTestUtil.addDiagnosticMarkersToText(
+                    ktFile,
+                    diagnostics,
+                    diagnosticToExpectedDiagnostic,
+                    { file -> file.text },
+                    uncheckedDiagnostics,
+                    withNewInferenceDirective
+                )
             )
 
             stripExtras(actualText)
@@ -315,8 +322,10 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             val jvmSignatureDiagnostics = HashSet<ActualDiagnostic>()
             val declarations = PsiTreeUtil.findChildrenOfType(ktFile, KtDeclaration::class.java)
             for (declaration in declarations) {
-                val diagnostics = getJvmSignatureDiagnostics(declaration, bindingContext.diagnostics,
-                                                             GlobalSearchScope.allScope(project)) ?: continue
+                val diagnostics = getJvmSignatureDiagnostics(
+                    declaration, bindingContext.diagnostics,
+                    GlobalSearchScope.allScope(project)
+                ) ?: continue
                 jvmSignatureDiagnostics.addAll(diagnostics.forElement(declaration).map { ActualDiagnostic(it, null, newInferenceEnabled) })
             }
             return jvmSignatureDiagnostics
@@ -329,32 +338,32 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         val DIAGNOSTICS_DIRECTIVE = "DIAGNOSTICS"
         val DIAGNOSTICS_PATTERN: Pattern = Pattern.compile("([\\+\\-!])(\\w+)\\s*")
         val DIAGNOSTICS_TO_INCLUDE_ANYWAY: Set<DiagnosticFactory<*>> = setOf(
-                Errors.UNRESOLVED_REFERENCE,
-                Errors.UNRESOLVED_REFERENCE_WRONG_RECEIVER,
-                CheckerTestUtil.SyntaxErrorDiagnosticFactory.INSTANCE,
-                CheckerTestUtil.DebugInfoDiagnosticFactory.ELEMENT_WITH_ERROR_TYPE,
-                CheckerTestUtil.DebugInfoDiagnosticFactory.MISSING_UNRESOLVED,
-                CheckerTestUtil.DebugInfoDiagnosticFactory.UNRESOLVED_WITH_TARGET
+            Errors.UNRESOLVED_REFERENCE,
+            Errors.UNRESOLVED_REFERENCE_WRONG_RECEIVER,
+            CheckerTestUtil.SyntaxErrorDiagnosticFactory.INSTANCE,
+            CheckerTestUtil.DebugInfoDiagnosticFactory.ELEMENT_WITH_ERROR_TYPE,
+            CheckerTestUtil.DebugInfoDiagnosticFactory.MISSING_UNRESOLVED,
+            CheckerTestUtil.DebugInfoDiagnosticFactory.UNRESOLVED_WITH_TARGET
         )
 
         val DEFAULT_DIAGNOSTIC_TESTS_FEATURES = mapOf(
-                LanguageFeature.Coroutines to LanguageFeature.State.ENABLED
+            LanguageFeature.Coroutines to LanguageFeature.State.ENABLED
         )
 
         val CHECK_TYPE_DIRECTIVE = "CHECK_TYPE"
         val CHECK_TYPE_PACKAGE = "tests._checkType"
         private val CHECK_TYPE_DECLARATIONS = "\npackage " + CHECK_TYPE_PACKAGE +
-                                              "\nfun <T> checkSubtype(t: T) = t" +
-                                              "\nclass Inv<T>" +
-                                              "\nfun <E> Inv<E>._() {}" +
-                                              "\ninfix fun <T> T.checkType(f: Inv<T>.() -> Unit) {}"
+                "\nfun <T> checkSubtype(t: T) = t" +
+                "\nclass Inv<T>" +
+                "\nfun <E> Inv<E>._() {}" +
+                "\ninfix fun <T> T.checkType(f: Inv<T>.() -> Unit) {}"
         val CHECK_TYPE_IMPORT = "import $CHECK_TYPE_PACKAGE.*"
 
         val EXPLICIT_FLEXIBLE_TYPES_DIRECTIVE = "EXPLICIT_FLEXIBLE_TYPES"
         val EXPLICIT_FLEXIBLE_PACKAGE = InternalFlexibleTypeTransformer.FLEXIBLE_TYPE_CLASSIFIER.packageFqName.asString()
         val EXPLICIT_FLEXIBLE_CLASS_NAME = InternalFlexibleTypeTransformer.FLEXIBLE_TYPE_CLASSIFIER.relativeClassName.asString()
         private val EXPLICIT_FLEXIBLE_TYPES_DECLARATIONS = "\npackage " + EXPLICIT_FLEXIBLE_PACKAGE +
-                                                           "\npublic class " + EXPLICIT_FLEXIBLE_CLASS_NAME + "<L, U>"
+                "\npublic class " + EXPLICIT_FLEXIBLE_CLASS_NAME + "<L, U>"
         private val EXPLICIT_FLEXIBLE_TYPES_IMPORT = "import $EXPLICIT_FLEXIBLE_PACKAGE.$EXPLICIT_FLEXIBLE_CLASS_NAME"
         val CHECK_LAZY_LOG_DIRECTIVE = "CHECK_LAZY_LOG"
         val CHECK_LAZY_LOG_DEFAULT = "true" == System.getProperty("check.lazy.logs", "false")
@@ -366,20 +375,23 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         // Change it to "true" to load diagnostics for old inference to test new inference (ignore diagnostics with <NI; prefix)
         val USE_OLD_INFERENCE_DIAGNOSTICS_FOR_NI = false
 
-        private fun parseDiagnosticFilterDirective(directiveMap: Map<String, String>, allowUnderscoreUsage: Boolean): Condition<Diagnostic> {
+        private fun parseDiagnosticFilterDirective(
+            directiveMap: Map<String, String>,
+            allowUnderscoreUsage: Boolean
+        ): Condition<Diagnostic> {
             val directives = directiveMap[DIAGNOSTICS_DIRECTIVE]
             val initialCondition =
-                    if (allowUnderscoreUsage)
-                        Condition<Diagnostic> { it.factory.name != "UNDERSCORE_USAGE_WITHOUT_BACKTICKS" }
-                    else
-                        Conditions.alwaysTrue()
+                if (allowUnderscoreUsage)
+                    Condition<Diagnostic> { it.factory.name != "UNDERSCORE_USAGE_WITHOUT_BACKTICKS" }
+                else
+                    Conditions.alwaysTrue()
 
             if (directives == null) {
                 // If "!API_VERSION" is present, disable the NEWER_VERSION_IN_SINCE_KOTLIN diagnostic.
                 // Otherwise it would be reported in any non-trivial test on the @SinceKotlin value.
                 if (API_VERSION_DIRECTIVE in directiveMap) {
-                    return Conditions.and(initialCondition, Condition {
-                        diagnostic -> diagnostic.factory !== Errors.NEWER_VERSION_IN_SINCE_KOTLIN
+                    return Conditions.and(initialCondition, Condition { diagnostic ->
+                        diagnostic.factory !== Errors.NEWER_VERSION_IN_SINCE_KOTLIN
                     })
                 }
                 return initialCondition
@@ -388,13 +400,15 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
             var condition = initialCondition
             val matcher = DIAGNOSTICS_PATTERN.matcher(directives)
             if (!matcher.find()) {
-                Assert.fail("Wrong syntax in the '// !$DIAGNOSTICS_DIRECTIVE: ...' directive:\n" +
+                Assert.fail(
+                    "Wrong syntax in the '// !$DIAGNOSTICS_DIRECTIVE: ...' directive:\n" +
                             "found: '$directives'\n" +
                             "Must be '([+-!]DIAGNOSTIC_FACTORY_NAME|ERROR|WARNING|INFO)+'\n" +
                             "where '+' means 'include'\n" +
                             "      '-' means 'exclude'\n" +
                             "      '!' means 'exclude everything but this'\n" +
-                            "directives are applied in the order of appearance, i.e. !FOO +BAR means include only FOO and BAR")
+                            "directives are applied in the order of appearance, i.e. !FOO +BAR means include only FOO and BAR"
+                )
             }
 
             var first = true
@@ -403,18 +417,19 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
                 val name = matcher.group(2)
 
                 val newCondition: Condition<Diagnostic> =
-                        if (name in setOf("ERROR", "WARNING", "INFO")) {
-                            Condition { diagnostic -> diagnostic.severity == Severity.valueOf(name) }
-                        }
-                        else {
-                            Condition { diagnostic -> name == diagnostic.factory.name }
-                        }
+                    if (name in setOf("ERROR", "WARNING", "INFO")) {
+                        Condition { diagnostic -> diagnostic.severity == Severity.valueOf(name) }
+                    } else {
+                        Condition { diagnostic -> name == diagnostic.factory.name }
+                    }
 
                 when (operation) {
                     "!" -> {
                         if (!first) {
-                            Assert.fail("'$operation$name' appears in a position rather than the first one, " +
-                                        "which effectively cancels all the previous filters in this directive")
+                            Assert.fail(
+                                "'$operation$name' appears in a position rather than the first one, " +
+                                        "which effectively cancels all the previous filters in this directive"
+                            )
                         }
                         condition = newCondition
                     }
@@ -422,13 +437,12 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
                     "-" -> condition = Conditions.and(condition, Conditions.not(newCondition))
                 }
                 first = false
-            }
-            while (matcher.find())
+            } while (matcher.find())
 
             // We always include UNRESOLVED_REFERENCE and SYNTAX_ERROR because they are too likely to indicate erroneous test data
             return Conditions.or(
-                    condition,
-                    Condition { diagnostic -> diagnostic.factory in DIAGNOSTICS_TO_INCLUDE_ANYWAY }
+                condition,
+                Condition { diagnostic -> diagnostic.factory in DIAGNOSTICS_TO_INCLUDE_ANYWAY }
             )
         }
     }