Extract directive map to separate class

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt

@@ -242,7 +242,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             file.name,
             expectedText,
             object : TestFiles.TestFileFactoryNoModules<TestFile>() {
-                override fun create(fileName: String, text: String, directives: Map<String, String>): TestFile {
+                override fun create(fileName: String, text: String, directives: Directives): TestFile {
                     return TestFile(fileName, text, directives)
                 }
             }, false,

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -105,7 +105,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
         val srcFiles = TestFiles.createTestFiles(
             javaFile.name, FileUtil.loadFile(javaFile, true),
             object : TestFiles.TestFileFactoryNoModules<File>() {
-                override fun create(fileName: String, text: String, directives: Map<String, String>): File {
+                override fun create(fileName: String, text: String, directives: Directives): File {
                     var currentDir = javaFilesDir
                     if ("/" !in fileName) {
                         val packageFqName =

compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt

@@ -19,13 +19,10 @@ package org.jetbrains.kotlin.asJava
 import com.intellij.psi.PsiClass
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
-import org.jetbrains.kotlin.test.KotlinBaseTest
 import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.test.ConfigurationKind
+import org.jetbrains.kotlin.test.*
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.util.KotlinFrontEndException
 import org.junit.Assert
 import java.io.File
@@ -57,7 +54,7 @@ abstract class AbstractCompilerLightClassTest : KotlinMultiFileTestWithJava<Kotl
         module: TestModule?,
         fileName: String,
         text: String,
-        directives: Map<String, String?>
+        directives: Directives
     ): TestFile = TestFile(fileName, text, directives)
 
     companion object {

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt

@@ -20,7 +20,6 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Condition
 import com.intellij.openapi.util.Conditions
 import com.intellij.openapi.util.TextRange
-import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.util.containers.ContainerUtil
@@ -52,10 +51,10 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl
+import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.InTextDirectivesUtils.isDirectiveDefined
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinBaseTest
-import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.junit.Assert
 import java.io.File
@@ -83,7 +82,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
     ): TestModule =
         TestModule(name, dependencies, friends)
 
-    override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Map<String, String?>): TestFile =
+    override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Directives): TestFile =
         TestFile(module, fileName, text, directives)
 
 
@@ -138,7 +137,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         val module: TestModule?,
         val fileName: String,
         textWithMarkers: String,
-        directives: Map<String, String?>
+        directives: Directives
     ) : KotlinBaseTest.TestFile(fileName, textWithMarkers, directives) {
         val diagnosedRanges: MutableList<DiagnosedRange> = mutableListOf()
         private val diagnosedRangesToDiagnosticNames: MutableMap<IntRange, MutableSet<String>> = mutableMapOf()
@@ -411,7 +410,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         val DIAGNOSTIC_IN_TESTDATA_PATTERN = Regex("<!>|<!(.*?(\\(\".*?\"\\)|\\(\\))??)+(?<!<)!>")
 
         fun parseDiagnosticFilterDirective(
-            directiveMap: Map<String, String?>,
+            directiveMap: Directives,
             allowUnderscoreUsage: Boolean
         ): Condition<Diagnostic> {
             val directives = directiveMap[DIAGNOSTICS_DIRECTIVE]
@@ -499,7 +498,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
         }
     }
 
-    private fun parseJvmTarget(directiveMap: Map<String, String?>) = directiveMap[JVM_TARGET]?.let { JvmTarget.fromString(it) }
+    private fun parseJvmTarget(directiveMap: Directives) = directiveMap[JVM_TARGET]?.let { JvmTarget.fromString(it) }
 
     protected fun parseModulePlatformByName(moduleName: String): TargetPlatform? {
         val nameSuffix = moduleName.substringAfterLast("-", "").toUpperCase()

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.checkers
 
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.junit.Assert
 import java.io.File
@@ -50,10 +51,10 @@ private fun specificFeaturesForTests(): Map<LanguageFeature, LanguageFeature.Sta
         emptyMap()
 }
 
-fun parseLanguageVersionSettingsOrDefault(directiveMap: Map<String, String>): CompilerTestLanguageVersionSettings =
+fun parseLanguageVersionSettingsOrDefault(directiveMap: Directives): CompilerTestLanguageVersionSettings =
     parseLanguageVersionSettings(directiveMap) ?: defaultLanguageVersionSettings()
 
-fun parseLanguageVersionSettings(directives: Map<String, String?>): CompilerTestLanguageVersionSettings? {
+fun parseLanguageVersionSettings(directives: Directives): CompilerTestLanguageVersionSettings? {
     val apiVersionString = directives[API_VERSION_DIRECTIVE]
     val languageFeaturesString = directives[LANGUAGE_DIRECTIVE]
 
@@ -93,9 +94,9 @@ fun defaultLanguageVersionSettings(): CompilerTestLanguageVersionSettings =
     CompilerTestLanguageVersionSettings(emptyMap(), ApiVersion.LATEST_STABLE, LanguageVersion.LATEST_STABLE)
 
 fun languageVersionSettingsFromText(fileTexts: List<String>): LanguageVersionSettings {
-    val allDirectives = HashMap<String, String>()
+    val allDirectives = Directives()
     for (fileText in fileTexts) {
-        allDirectives.putAll(KotlinTestUtils.parseDirectives(fileText))
+        KotlinTestUtils.parseDirectives(fileText, allDirectives)
     }
     return parseLanguageVersionSettingsOrDefault(allDirectives)
 }

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt

@@ -119,7 +119,7 @@ abstract class KotlinMultiFileTestWithJava<M : KotlinBaseTest.TestModule, F : Ko
 
     protected abstract fun createTestModule(name: String, dependencies: List<String>, friends: List<String>): M?
 
-    protected abstract fun createTestFile(module: M?, fileName: String, text: String, directives: Map<String, String?>): F
+    protected abstract fun createTestFile(module: M?, fileName: String, text: String, directives: Directives): F
 
     protected open fun createTestFiles(
         file: File,
@@ -131,7 +131,7 @@ abstract class KotlinMultiFileTestWithJava<M : KotlinBaseTest.TestModule, F : Ko
                 module: M?,
                 fileName: String,
                 text: String,
-                directives: Map<String, String>
+                directives: Directives
             ): F? {
                 if (fileName.endsWith(".java")) {
                     writeSourceFile(fileName, text, javaFilesDir!!)

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java

@@ -161,7 +161,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
         List<String> kotlinConfigurationFlags = new ArrayList<>(0);
         for (TestFile testFile : testFilesWithConfigurationDirectives) {
             String content = testFile.content;
-            Map<String, String> directives = usePreparsedDirectives ? testFile.directives : parseDirectivesAndFlags(content);
+            Directives directives = usePreparsedDirectives ? testFile.directives : parseDirectivesAndFlags(content);
 
             String configurationFlags = directives.get("KOTLIN_CONFIGURATION_FLAGS");
             if (configurationFlags != null) {
@@ -185,8 +185,8 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
                 );
             }
 
-            if (directives.containsKey("COMMON_COROUTINES_TEST")) {
+            if (directives.contains("COMMON_COROUTINES_TEST")) {
-                assert !directives.containsKey("COROUTINES_PACKAGE") : "Must replace COROUTINES_PACKAGE prior to tests compilation";
+                assert !directives.contains("COROUTINES_PACKAGE") : "Must replace COROUTINES_PACKAGE prior to tests compilation";
                 if (DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString().equals(coroutinesPackage)) {
                     disableReleaseCoroutines = true;
                     includeCompatExperimentalCoroutines = true;
@@ -779,7 +779,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest<KotlinBaseTest.Test
         List testFiles = TestFiles.createTestFiles(file.getName(), expectedText, new TestFiles.TestFileFactoryNoModules<TestFile>() {
             @NotNull
             @Override
-            public TestFile create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
+            public TestFile create(@NotNull String fileName, @NotNull String text, @NotNull Directives directives) {
                 return new TestFile(fileName, text, directives);
             }
         }, false, coroutinesPackage, parseDirectivesPerFiles());

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt

@@ -42,7 +42,7 @@ object InlineTestUtil {
         assert(notInlinedCalls.isEmpty()) { "All inline methods should be inlined but:\n" + notInlinedCalls.joinToString("\n") }
 
         val skipParameterChecking = files.any {
-            it.directives.containsKey("NO_CHECK_LAMBDA_INLINING")
+            "NO_CHECK_LAMBDA_INLINING" in it.directives
         } || !doLambdaInliningCheck(outputFiles, inlineInfo)
 
         if (!skipParameterChecking) {

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirOldFrontendDiagnosticsTest.kt

@@ -25,7 +25,7 @@ abstract class AbstractFirOldFrontendDiagnosticsTest : AbstractFirDiagnosticsTes
     }
 
     override fun runAnalysis(testDataFile: File, testFiles: List<TestFile>, firFilesPerSession: Map<FirSession, List<FirFile>>) {
-        if (testFiles.any { it.directives.containsKey("FIR_IGNORE") }) return
+        if (testFiles.any { "FIR_IGNORE" in it.directives }) return
         val failure: AssertionError? = try {
             for ((_, firFiles) in firFilesPerSession) {
                 doFirResolveTestBench(firFiles, FirTotalResolveTransformer().transformers, gc = false)
@@ -45,7 +45,7 @@ abstract class AbstractFirOldFrontendDiagnosticsTest : AbstractFirDiagnosticsTes
                 compareAndMergeFirFileAndOldFrontendFile(oldFrontendTestDataFile, testDataFile)
             }
 
-            val needDump = testFiles.any { it.directives.containsKey("FIR_DUMP") }
+            val needDump = testFiles.any { "FIR_DUMP" in it.directives }
             if (needDump) {
                 checkFir(testDataFile, allFirFiles)
             }

compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -163,7 +163,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
     }
 
     public static void updateConfigurationWithDirectives(String content, CompilerConfiguration configuration) {
-        Map<String, String> directives = KotlinTestUtils.parseDirectives(content);
+        Directives directives = KotlinTestUtils.parseDirectives(content);
         LanguageVersionSettings languageVersionSettings = CompilerTestLanguageVersionSettingsKt.parseLanguageVersionSettings(directives);
         if (languageVersionSettings == null) {
             languageVersionSettings = CompilerTestLanguageVersionSettingsKt.defaultLanguageVersionSettings();
@@ -284,7 +284,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 new TestFiles.TestFileFactoryNoModules<File>() {
                     @NotNull
                     @Override
-                    public File create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
+                    public File create(@NotNull String fileName, @NotNull String text, @NotNull Directives directives) {
                         File targetFile = new File(srcDir, fileName);
                         try {
                             FileUtil.writeToFile(targetFile, text);

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.test.*;
 
 import java.io.File;
 import java.util.List;
-import java.util.Map;
 
 public abstract class ExtensibleResolveTestCase extends KotlinTestWithEnvironment {
     private ExpectedResolveData expectedResolveData;
@@ -48,7 +47,7 @@ public abstract class ExtensibleResolveTestCase extends KotlinTestWithEnvironmen
         List<KtFile> files = TestFiles.createTestFiles("file.kt", text, new TestFiles.TestFileFactoryNoModules<KtFile>() {
             @NotNull
             @Override
-            public KtFile create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
+            public KtFile create(@NotNull String fileName, @NotNull String text, @NotNull Directives directives) {
                 return expectedResolveData.createFileFromMarkedUpText(fileName, text);
             }
         }, "");

compiler/tests-common/tests/org/jetbrains/kotlin/test/Directives.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.test
+
+class Directives {
+
+    private val directives = mutableMapOf<String, String?>()
+
+    operator fun contains(key: String): Boolean {
+        return key in directives
+    }
+
+    operator fun get(key: String): String? {
+        return directives[key]
+    }
+
+    fun put(key: String, value: String?): String? {
+        return directives.put(key, value)
+    }
+
+    public fun asMapOfSingleValues(): Map<String, String?> {
+        return directives.entries.associate { it.key to it.value?.single() }
+    }
+}

compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt

@@ -73,7 +73,7 @@ abstract class KotlinBaseTest<F : KotlinBaseTest.TestFile> : KtUsefulTestCase()
     open class TestFile @JvmOverloads constructor(
         @JvmField val name: String,
         @JvmField val content: String,
-        @JvmField val directives: Map<String, String?> = emptyMap()
+        @JvmField val directives: Directives = Directives()
     ) : Comparable<TestFile> {
         override operator fun compareTo(other: TestFile): Int {
             return name.compareTo(other.name)

compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java

@@ -525,12 +525,16 @@ public class KotlinTestUtils {
     }
 
     @NotNull
-    public static Map<String, String> parseDirectives(String expectedText) {
+    public static Directives parseDirectives(String expectedText) {
-        Map<String, String> directives = new HashMap<>();
+        return parseDirectives(expectedText, new Directives());
+    }
+
+    @NotNull
+    public static Directives parseDirectives(String expectedText, @NotNull Directives directives) {
         return parseByRegexp(DIRECTIVE_PATTERN, expectedText, directives);
     }
 
-    private static Map<String, String> parseByRegexp(Pattern pattern, String expectedText, Map<String, String> directives) {
+    private static Directives parseByRegexp(Pattern pattern, String expectedText, Directives directives) {
         Matcher directiveMatcher = pattern.matcher(expectedText);
         while (directiveMatcher.find()) {
             String name = directiveMatcher.group(1);
@@ -542,8 +546,8 @@ public class KotlinTestUtils {
     }
 
     @NotNull
-    public static Map<String, String> parseDirectivesAndFlags(String expectedText) {
+    public static Directives parseDirectivesAndFlags(String expectedText) {
-        Map<String, String> directiveAndFlags = parseDirectives(expectedText);
+        Directives directiveAndFlags = parseDirectives(expectedText);
         parseByRegexp(BACKEND_DIRECTIVE_PATTERN, expectedText, directiveAndFlags);
         return directiveAndFlags;
     }
@@ -561,7 +565,7 @@ public class KotlinTestUtils {
         List<String> files = TestFiles.createTestFiles("", content, new TestFiles.TestFileFactoryNoModules<String>() {
             @NotNull
             @Override
-            public String create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
+            public String create(@NotNull String fileName, @NotNull String text, @NotNull Directives directives) {
                 int firstLineEnd = text.indexOf('\n');
                 return StringUtil.trimTrailing(text.substring(firstLineEnd + 1));
             }

compiler/tests-common/tests/org/jetbrains/kotlin/test/TestFiles.java

@@ -71,7 +71,7 @@ public class TestFiles {
             commonPrefixOrWholeFile = expectedText;
         }
         else {
-            Map<String, String> allFilesOrCommonPrefixDirectives = parseDirectivesPerFile ? null : parseDirectivesAndFlags(expectedText);
+            Directives allFilesOrCommonPrefixDirectives = parseDirectivesPerFile ? null : parseDirectivesAndFlags(expectedText);
             int processedChars = 0;
             M module = null;
             boolean firstFileProcessed = false;
@@ -190,7 +190,7 @@ public class TestFiles {
     }
 
     public interface TestFileFactory<M, F> {
-        F createFile(@Nullable M module, @NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives);
+        F createFile(@Nullable M module, @NotNull String fileName, @NotNull String text, @NotNull Directives directives);
         M createModule(@NotNull String name, @NotNull List<String> dependencies, @NotNull List<String> friends);
     }
 
@@ -200,13 +200,13 @@ public class TestFiles {
                 @Nullable KotlinBaseTest.TestModule module,
                 @NotNull String fileName,
                 @NotNull String text,
-                @NotNull Map<String, String> directives
+                @NotNull Directives directives
         ) {
             return create(fileName, text, directives);
         }
 
         @NotNull
-        public abstract F create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives);
+        public abstract F create(@NotNull String fileName, @NotNull String text, @NotNull Directives directives);
 
         @Override
         public KotlinBaseTest.TestModule createModule(@NotNull String name, @NotNull List<String> dependencies, @NotNull List<String> friends) {

compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/AbstractVisualizer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.visualizer
 
 import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinBaseTest
 import java.io.File
 
@@ -20,7 +21,7 @@ abstract class AbstractVisualizer : KotlinMultiFileTestWithJava<KotlinBaseTest.T
     ): TestModule? = null
 
 
-    override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Map<String, String?>): TestFile =
+    override fun createTestFile(module: TestModule?, fileName: String, text: String, directives: Directives): TestFile =
         TestFile(fileName, text, directives)
 
 

core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt

@@ -117,7 +117,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() {
                     fileName,
                     text,
                     object : TestFileFactoryNoModules<File>() {
-                        override fun create(fileName: String, text: String, directives: Map<String, String>): File {
+                        override fun create(fileName: String, text: String, directives: Directives): File {
                             val targetFile = File(tmpdir, fileName)
                             targetFile.writeText(adaptJavaSource(text))
                             return targetFile

idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinDescriptorTestCase.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.idea.debugger.test.util.KotlinOutputChecker
 import org.jetbrains.kotlin.idea.debugger.test.util.LogPropagator
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinBaseTest.TestFile
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestMetadata
@@ -129,7 +130,7 @@ abstract class KotlinDescriptorTestCase : DescriptorTestCase() {
             wholeFile.name,
             wholeFileContents,
             object : org.jetbrains.kotlin.test.TestFiles.TestFileFactoryNoModules<TestFile>() {
-                override fun create(fileName: String, text: String, directives: Map<String, String?>): TestFile {
+                override fun create(fileName: String, text: String, directives: Directives): TestFile {
                     return TestFile(fileName, text, directives)
                 }
             }

idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java

@@ -77,7 +77,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro
         String fileName = file.getName();
 
         String fileData = KotlinTestUtils.doLoadFile(file);
-        Map<String,String> directives = KotlinTestUtils.parseDirectives(fileData);
+        Directives directives = KotlinTestUtils.parseDirectives(fileData);
         int diagnosticNumber = getDiagnosticNumber(directives);
         final Set<DiagnosticFactory<?>> diagnosticFactories = getDiagnosticFactories(directives);
         MessageType messageType = getMessageTypeDirective(directives);
@@ -149,7 +149,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro
         return result;
     }
 
-    private static int getDiagnosticNumber(Map<String, String> directives) {
+    private static int getDiagnosticNumber(Directives directives) {
         String diagnosticsNumber = directives.get(DIAGNOSTICS_NUMBER_DIRECTIVE);
         assert diagnosticsNumber != null : DIAGNOSTICS_NUMBER_DIRECTIVE + " should be present.";
         try {
@@ -161,7 +161,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro
     }
 
     @NotNull
-    private Set<DiagnosticFactory<?>> getDiagnosticFactories(Map<String, String> directives) {
+    private Set<DiagnosticFactory<?>> getDiagnosticFactories(Directives directives) {
         String diagnosticsData = directives.get(DIAGNOSTICS_DIRECTIVE);
         assert diagnosticsData != null : DIAGNOSTICS_DIRECTIVE + " should be present.";
         Set<DiagnosticFactory<?>> diagnosticFactories = new HashSet<>();
@@ -206,7 +206,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro
     }
 
     @Nullable
-    private static MessageType getMessageTypeDirective(Map<String, String> directives) {
+    private static MessageType getMessageTypeDirective(Directives directives) {
         String messageType = directives.get(MESSAGE_TYPE_DIRECTIVE);
         if (messageType == null) return null;
         try {

idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestFiles
 import org.jetbrains.kotlin.test.testFramework.runWriteAction
@@ -113,7 +114,7 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
             "single.kt",
             multiFileText,
             object : TestFiles.TestFileFactoryNoModules<TestFile>() {
-                override fun create(fileName: String, text: String, directives: Map<String, String>): TestFile {
+                override fun create(fileName: String, text: String, directives: Directives): TestFile {
                     val linesWithoutDirectives = text.lines().filter {
                         !it.startsWith("// LANGUAGE_VERSION") && !it.startsWith("// FILE")
                     }

j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt

@@ -10,7 +10,6 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.codeStyle.CodeStyleManager
-import com.intellij.testFramework.LightPlatformTestCase
 import org.jetbrains.kotlin.idea.j2k.IdeaJavaToKotlinServices
 import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
@@ -38,7 +37,7 @@ abstract class AbstractJavaToKotlinConverterSingleFileTest : AbstractJavaToKotli
 
         val settings = ConverterSettings.defaultSettings.copy()
         val directives = KotlinTestUtils.parseDirectives(javaCode)
-        for ((name, value) in directives) {
+        for ((name, value) in directives.asMapOfSingleValues()) {
             when (name) {
                 "forceNotNullTypes" -> settings.forceNotNullTypes = value.toBoolean()
                 "specifyLocalVariableTypeByDefault" -> settings.specifyLocalVariableTypeByDefault = value.toBoolean()

js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt

@@ -30,10 +30,7 @@ import org.jetbrains.kotlin.js.test.utils.LineOutputToStringVisitor
 import org.jetbrains.kotlin.js.util.TextOutputImpl
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.js.ModuleKind
-import org.jetbrains.kotlin.test.KotlinBaseTest
+import org.jetbrains.kotlin.test.*
-import org.jetbrains.kotlin.test.KotlinTestUtils
-import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
-import org.jetbrains.kotlin.test.TestFiles
 import org.jetbrains.kotlin.utils.DFS
 import java.io.ByteArrayOutputStream
 import java.io.Closeable
@@ -140,7 +137,7 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() {
         private val tmpDir = KotlinTestUtils.tmpDir("js-tests")
         private val defaultModule = TestModule(BasicBoxTest.TEST_MODULE, emptyList(), emptyList())
 
-        override fun createFile(module: TestModule?, fileName: String, text: String, directives: Map<String, String>): TestFile? {
+        override fun createFile(module: TestModule?, fileName: String, text: String, directives: Directives): TestFile? {
             val currentModule = module ?: defaultModule
 
             val temporaryFile = File(tmpDir, "${currentModule.name}/$fileName")
@@ -165,7 +162,7 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() {
         val files = mutableListOf<TestFile>()
     }
 
-    private class TestFile(val fileName: String, content: String, val module: TestModule, directives: Map<String, String?>) :
+    private class TestFile(val fileName: String, content: String, val module: TestModule, directives: Directives) :
         KotlinBaseTest.TestFile(fileName, content, directives) {
         init {
             module.files += this

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt

@@ -778,7 +778,7 @@ abstract class BasicBoxTest(
         val defaultModule = TestModule(TEST_MODULE, emptyList(), emptyList())
         var languageVersionSettings: LanguageVersionSettings? = null
 
-        override fun createFile(module: TestModule?, fileName: String, text: String, directives: Map<String, String>): TestFile? {
+        override fun createFile(module: TestModule?, fileName: String, text: String, directives: Directives): TestFile? {
             val currentModule = module ?: defaultModule
 
             val ktFile = KtPsiFactory(project).createFile(text)

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicWasmBoxTest.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.TestFiles
@@ -158,7 +159,7 @@ abstract class BasicWasmBoxTest(
     }
 
     private inner class TestFileFactoryImpl : TestFiles.TestFileFactoryNoModules<TestFile>(), Closeable {
-        override fun create(fileName: String, text: String, directives: MutableMap<String, String>): TestFile {
+        override fun create(fileName: String, text: String, directives: Directives): TestFile {
             val ktFile = KtPsiFactory(project).createFile(text)
             val boxFunction = ktFile.declarations.find { it is KtNamedFunction && it.name == TEST_FUNCTION }
             if (boxFunction != null) {