Fix warnings after update to 202 platform

#KT-44069 Fixed

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBuilderRecord.kt.201

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.codegen
 
+@Suppress("UNUSED_PARAMETER", "unused")
 fun ClassBuilder.addRecordComponent(name: String, desc: String, signature: String?) {
     // newRecordComponent(name, desc, signature)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/SignatureCollectingClassBuilderFactory.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.psi.PsiElement
-import com.intellij.util.containers.LinkedMultiMap
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
@@ -49,7 +48,7 @@ abstract class SignatureCollectingClassBuilderFactory(
 
         private lateinit var classInternalName: String
 
-        private val signatures = LinkedMultiMap<RawSignature, JvmDeclarationOrigin>()
+        private val signatures = MultiMap.createLinked<RawSignature, JvmDeclarationOrigin>()
 
         override fun defineClass(origin: PsiElement?, version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array<out String>) {
             classInternalName = name

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.kt

@@ -137,7 +137,8 @@ abstract class DefaultLambda(
     override val isSuspend = parameterDescriptor.isSuspendLambda
 
     override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
-        val classReader = buildClassReaderByInternalName(sourceCompiler.state, lambdaClassType.internalName)
+        val classBytes = loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
+        val classReader = ClassReader(classBytes)
         var isPropertyReference = false
         var isFunctionReference = false
         classReader.accept(object : ClassVisitor(Opcodes.API_VERSION) {
@@ -162,12 +163,7 @@ abstract class DefaultLambda(
         }
 
         val descriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
-        val constructor = getMethodNode(
+        val constructor = getMethodNode(classBytes, "<init>", descriptor, lambdaClassType)?.node
-            classReader.b,
-            "<init>",
-            descriptor,
-            lambdaClassType
-        )?.node
 
         assert(constructor != null || capturedArgs.isEmpty()) {
             "Can't find non-default constructor <init>$descriptor for default lambda $lambdaClassType"
@@ -190,13 +186,8 @@ abstract class DefaultLambda(
 
         val signature = mapAsmSignature(sourceCompiler)
 
-        node = getMethodNode(
+        node = getMethodNode(classBytes, methodName, signature.descriptor, lambdaClassType, signatureAmbiguity = true)
-            classReader.b,
+            ?: error("Can't find method '$methodName$signature' in '${classReader.className}'")
-            methodName,
-            signature.descriptor,
-            lambdaClassType,
-            signatureAmbiguity = true
-        ) ?: error("Can't find method '$methodName$signature' in '${classReader.className}'")
 
         invokeMethod = Method(node.node.name, node.node.desc)
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt

@@ -46,9 +46,8 @@ abstract class ObjectTransformer<out T : TransformationInfo>(@JvmField val trans
         )
     }
 
-    fun createClassReader(): ClassReader {
+    fun createClassReader(): ClassReader =
-        return buildClassReaderByInternalName(state, transformationInfo.oldClassName)
+        ClassReader(loadClassBytesByInternalName(state, transformationInfo.oldClassName))
-    }
 }
 
 class WhenMappingTransformer(

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt

@@ -346,16 +346,16 @@ internal val AbstractInsnNode?.insnText: String
 internal val AbstractInsnNode?.insnOpcodeText: String
     get() = if (this == null) "null" else Printer.OPCODES[opcode]
 
-internal fun buildClassReaderByInternalName(state: GenerationState, internalName: String): ClassReader {
+internal fun loadClassBytesByInternalName(state: GenerationState, internalName: String): ByteArray {
     //try to find just compiled classes then in dependencies
-    val outputFile = state.factory.get(internalName + ".class")
+    val outputFile = state.factory.get("$internalName.class")
     if (outputFile != null) {
-        return ClassReader(outputFile.asByteArray())
+        return outputFile.asByteArray()
     }
 
-    val file = findVirtualFileImprecise(state, internalName) ?: throw RuntimeException("Couldn't find virtual file for " + internalName)
+    val file = findVirtualFileImprecise(state, internalName) ?: throw RuntimeException("Couldn't find virtual file for $internalName")
 
-    return ClassReader(file.contentsToByteArray())
+    return file.contentsToByteArray()
 }
 
 fun generateFinallyMarker(v: InstructionAdapter, depth: Int, start: Boolean) {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java

@@ -10,11 +10,10 @@ import com.intellij.codeInsight.runner.JavaMainMethodProvider;
 import com.intellij.core.JavaCoreApplicationEnvironment;
 import com.intellij.lang.MetaLanguage;
 import com.intellij.openapi.Disposable;
-import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.vfs.VirtualFileSystem;
 import com.intellij.psi.FileContextProvider;
 import com.intellij.psi.augment.PsiAugmentProvider;
-import com.intellij.psi.compiled.ClassFileDecompilers;
 import com.intellij.psi.meta.MetaDataContributor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -43,7 +42,7 @@ public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnviron
 
         registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
 
-        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(ApplicationManager.getApplication().getExtensionArea());
     }
 
     @Nullable

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -25,11 +25,11 @@ import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.lang.java.JavaParserDefinition
 import com.intellij.mock.MockProject
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.TransactionGuard
 import com.intellij.openapi.application.TransactionGuardImpl
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.diagnostic.Logger
-import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.extensions.ExtensionsArea
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
@@ -42,7 +42,6 @@ import com.intellij.openapi.vfs.impl.ZipHandler
 import com.intellij.pom.java.LanguageLevel
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
-import com.intellij.psi.compiled.ClassFileDecompilers
 import com.intellij.psi.impl.JavaClassSupersImpl
 import com.intellij.psi.impl.PsiElementFinderImpl
 import com.intellij.psi.impl.PsiTreeChangePreprocessor
@@ -530,7 +529,7 @@ class KotlinCoreEnvironment private constructor(
             registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
             // FIX ME WHEN BUNCH 202 REMOVED: this code is required to support compiler bundled to both 202 and 203.
             // Please, remove "com.intellij.psi.classFileDecompiler" EP registration once 202 is no longer supported by the compiler
-            if (!Extensions.getRootArea().hasExtensionPoint("com.intellij.psi.classFileDecompiler")) {
+            if (!ApplicationManager.getApplication().extensionArea.hasExtensionPoint("com.intellij.psi.classFileDecompiler")) {
                 registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/core.xml")
             }
 
@@ -564,7 +563,7 @@ class KotlinCoreEnvironment private constructor(
             CoreApplicationEnvironment.registerExtensionPointAndExtensions(
                 FileSystems.getDefault().getPath(pluginRoot.path),
                 configFilePath,
-                Extensions.getRootArea()
+                ApplicationManager.getApplication().extensionArea
             )
         }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42

@@ -25,11 +25,11 @@ import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.lang.java.JavaParserDefinition
 import com.intellij.mock.MockProject
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.TransactionGuard
 import com.intellij.openapi.application.TransactionGuardImpl
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.diagnostic.Logger
-import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.extensions.ExtensionsArea
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.DumbUtil
@@ -123,7 +123,7 @@ class KotlinCoreEnvironment private constructor(
         private var extensionRegistered = false
 
         override fun preregisterServices() {
-            registerProjectExtensionPoints(Extensions.getArea(project))
+            registerProjectExtensionPoints(project.extensionArea)
         }
 
         fun registerExtensionsFromPlugins(configuration: CompilerConfiguration) {
@@ -552,7 +552,7 @@ class KotlinCoreEnvironment private constructor(
             CoreApplicationEnvironment.registerExtensionPointAndExtensions(
                 FileSystems.getDefault().getPath(pluginRoot.path),
                 configFilePath,
-                Extensions.getRootArea()
+                ApplicationManager.getApplication().extensionArea
             )
         }
 
@@ -621,9 +621,9 @@ class KotlinCoreEnvironment private constructor(
         @JvmStatic
         fun registerProjectExtensionPoints(area: ExtensionsArea) {
             CoreApplicationEnvironment.registerExtensionPoint(
-                area, PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor::class.java
+                area, PsiTreeChangePreprocessor.EP.name, PsiTreeChangePreprocessor::class.java
             )
-            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP_NAME, PsiElementFinder::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP.name, PsiElementFinder::class.java)
 
             IdeaExtensionPoints.registerVersionSpecificProjectExtensionPoints(area)
         }
@@ -631,7 +631,10 @@ class KotlinCoreEnvironment private constructor(
         // made public for Upsource
         @JvmStatic
         @Deprecated("Use registerProjectServices(project) instead.", ReplaceWith("registerProjectServices(projectEnvironment.project)"))
-        fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment, messageCollector: MessageCollector?) {
+        fun registerProjectServices(
+            projectEnvironment: JavaCoreProjectEnvironment,
+            @Suppress("UNUSED_PARAMETER") messageCollector: MessageCollector?
+        ) {
             registerProjectServices(projectEnvironment.project)
         }
 
@@ -666,12 +669,15 @@ class KotlinCoreEnvironment private constructor(
                 @Suppress("UnstableApiUsage")
                 registerService(DumbUtil::class.java, KotlinCoreDumbUtil())
 
-                val area = Extensions.getArea(this)
+                // We don't pass Disposable because in some tests, we manually unregister these extensions, and that leads to LOG.error
-
+                // exception from `ExtensionPointImpl.doRegisterExtension`, because the registered extension can no longer be found
-                area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(this, kotlinAsJavaSupport))
+                // when the project is being disposed.
-                area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(
+                // For example, see the `unregisterExtension` call in `GenerationUtils.compileFilesUsingFrontendIR`.
-                    PsiElementFinderImpl(this, ServiceManager.getService(this, JavaFileManager::class.java))
+                // TODO: refactor this to avoid registering unneeded extensions in the first place, and avoid using deprecated API.
-                )
+                @Suppress("DEPRECATION")
+                PsiElementFinder.EP.getPoint(project).registerExtension(JavaElementFinder(this, kotlinAsJavaSupport))
+                @Suppress("DEPRECATION")
+                PsiElementFinder.EP.getPoint(project).registerExtension(PsiElementFinderImpl(this))
             }
         }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/index/JvmDependenciesIndexImpl.kt

@@ -45,7 +45,8 @@ class JvmDependenciesIndexImpl(_roots: List<JavaRoot>) : JvmDependenciesIndex {
         // indices of roots that are known to contain this package
         // if this list contains [1, 3, 5] then roots with indices 1, 3 and 5 are known to contain this package, 2 and 4 are known not to (no information about roots 6 or higher)
         // if this list contains maxIndex that means that all roots containing this package are known
-        val rootIndices = IntArrayList(2)
+        @Suppress("DEPRECATION") // TODO: fix deprecation
+        val rootIndices = com.intellij.util.containers.IntArrayList(2)
     }
 
     // root "Cache" object corresponds to DefaultPackage which exists in every root. Roots with non-default fqname are also listed here but

compiler/container/src/org/jetbrains/kotlin/container/Cache.kt

@@ -19,10 +19,11 @@ package org.jetbrains.kotlin.container
 import com.intellij.util.containers.ContainerUtil
 import java.lang.reflect.*
 import java.util.*
+import java.util.concurrent.ConcurrentHashMap
 
 private object ClassTraversalCache {
     private val cache =
-        if (System.getProperty("idea.system.path") != null) ContainerUtil.newConcurrentMap<Class<*>, ClassInfo>()
+        if (System.getProperty("idea.system.path") != null) ConcurrentHashMap<Class<*>, ClassInfo>()
         else ContainerUtil.createConcurrentWeakKeySoftValueMap<Class<*>, ClassInfo>()
 
     fun getClassInfo(c: Class<*>): ClassInfo {

compiler/frontend/src/org/jetbrains/kotlin/extensions/ApplicationExtensionDescriptor.kt

@@ -6,15 +6,15 @@
 package org.jetbrains.kotlin.extensions
 
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.extensions.ExtensionPoint
 import com.intellij.openapi.extensions.ExtensionPointName
-import com.intellij.openapi.extensions.Extensions
 
 open class ApplicationExtensionDescriptor<T : Any>(name: String, private val extensionClass: Class<T>) {
     val extensionPointName: ExtensionPointName<T> = ExtensionPointName.create(name)
 
     fun registerExtensionPoint() {
-        Extensions.getRootArea().registerExtensionPoint(
+        ApplicationManager.getApplication().extensionArea.registerExtensionPoint(
             extensionPointName.name,
             extensionClass.name,
             ExtensionPoint.Kind.INTERFACE
@@ -22,11 +22,11 @@ open class ApplicationExtensionDescriptor<T : Any>(name: String, private val ext
     }
 
     fun registerExtension(extension: T, disposable: Disposable) {
-        Extensions.getRootArea().getExtensionPoint(extensionPointName).registerExtension(extension, disposable)
+        ApplicationManager.getApplication().extensionArea.getExtensionPoint(extensionPointName).registerExtension(extension, disposable)
     }
 
     fun getInstances(): List<T> {
-        val projectArea = Extensions.getRootArea()
+        val projectArea = ApplicationManager.getApplication().extensionArea
         if (!projectArea.hasExtensionPoint(extensionPointName.name)) return listOf()
 
         return projectArea.getExtensionPoint(extensionPointName).extensions.toList()

compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsElementsCache.java

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.resolve.diagnostics;
 
 import com.intellij.openapi.util.AtomicNotNullLazyValue;
 import com.intellij.psi.PsiElement;
-import com.intellij.util.containers.ConcurrentMultiMap;
 import com.intellij.util.containers.MultiMap;
 import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
@@ -27,6 +26,8 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 
 import java.util.Collection;
 
+import static org.jetbrains.kotlin.utils.PlatformUtilsKt.createConcurrentMultiMap;
+
 public class DiagnosticsElementsCache {
     private final Diagnostics diagnostics;
     private final Function1<Diagnostic, Boolean> filter;
@@ -50,7 +51,7 @@ public class DiagnosticsElementsCache {
     }
 
     private static MultiMap<PsiElement, Diagnostic> buildElementToDiagnosticCache(Diagnostics diagnostics, Function1<Diagnostic, Boolean> filter) {
-        MultiMap<PsiElement, Diagnostic> elementToDiagnostic = new ConcurrentMultiMap<>();
+        MultiMap<PsiElement, Diagnostic> elementToDiagnostic = createConcurrentMultiMap();
         for (Diagnostic diagnostic : diagnostics) {
             if (diagnostic == null) {
                 throw new IllegalStateException(

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KotlinClassInnerStuffCache.kt

@@ -8,8 +8,6 @@ package org.jetbrains.kotlin.asJava.classes
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.util.SimpleModificationTracker
 import com.intellij.psi.*
-import com.intellij.psi.augment.PsiAugmentProvider
-import com.intellij.psi.impl.PsiCachedValueImpl
 import com.intellij.psi.impl.PsiClassImplUtil
 import com.intellij.psi.impl.PsiImplUtil
 import com.intellij.psi.impl.light.LightMethod
@@ -17,12 +15,9 @@ import com.intellij.psi.impl.source.PsiExtensibleClass
 import com.intellij.psi.scope.ElementClassHint
 import com.intellij.psi.scope.NameHint
 import com.intellij.psi.scope.PsiScopeProcessor
-import com.intellij.psi.util.CachedValueProvider
 import com.intellij.util.ArrayUtil
 import gnu.trove.THashMap
 import org.jetbrains.kotlin.utils.SmartList
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.locks.ReentrantLock
 
 class KotlinClassInnerStuffCache(
     private val myClass: PsiExtensibleClass,
@@ -102,19 +97,19 @@ class KotlinClassInnerStuffCache(
 
     private fun getAllFields(): Array<PsiField> {
         val own = myClass.ownFields
-        val ext = PsiAugmentProvider.collectAugments(myClass, PsiField::class.java)
+        val ext = collectAugments(myClass, PsiField::class.java)
         return ArrayUtil.mergeCollections(own, ext, PsiField.ARRAY_FACTORY)
     }
 
     private fun getAllMethods(): Array<PsiMethod> {
         val own = myClass.ownMethods
-        val ext = PsiAugmentProvider.collectAugments(myClass, PsiMethod::class.java)
+        val ext = collectAugments(myClass, PsiMethod::class.java)
         return ArrayUtil.mergeCollections(own, ext, PsiMethod.ARRAY_FACTORY)
     }
 
     private fun getAllInnerClasses(): Array<PsiClass> {
         val own = myClass.ownInnerClasses
-        val ext = PsiAugmentProvider.collectAugments(myClass, PsiClass::class.java)
+        val ext = collectAugments(myClass, PsiClass::class.java)
         return ArrayUtil.mergeCollections(own, ext, PsiClass.ARRAY_FACTORY)
     }
 

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/lightClassPlatformUtils.kt

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2010-2021 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.asJava.classes
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.augment.PsiAugmentProvider
+
+internal fun <Psi : PsiElement> collectAugments(element: PsiElement, type: Class<out Psi>): List<Psi> {
+    return PsiAugmentProvider.collectAugments(element, type, null)
+}

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/lightClassPlatformUtils.kt.201

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2010-2021 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.asJava.classes
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.augment.PsiAugmentProvider
+
+internal fun <Psi : PsiElement> collectAugments(element: PsiElement, type: Class<out Psi>): List<Psi> {
+    return PsiAugmentProvider.collectAugments(element, type)
+}

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/resolve/jvm/KotlinJavaPsiFacade.java

@@ -38,7 +38,6 @@ import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.util.CommonProcessors;
 import com.intellij.util.ConcurrencyUtil;
 import com.intellij.util.Query;
-import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.messages.MessageBusConnection;
 import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
@@ -56,6 +55,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
 public class KotlinJavaPsiFacade {
@@ -63,11 +63,11 @@ public class KotlinJavaPsiFacade {
 
     private static class PackageCache {
         // long term cache
-        final ConcurrentMap<Pair<String, GlobalSearchScope>, PsiPackage> packageInLibScopeCache = ContainerUtil.newConcurrentMap();
+        final ConcurrentMap<Pair<String, GlobalSearchScope>, PsiPackage> packageInLibScopeCache = new ConcurrentHashMap<>();
 
         // short term caches
-        final ConcurrentMap<Pair<String, GlobalSearchScope>, PsiPackage> packageInScopeCache = ContainerUtil.newConcurrentMap();
+        final ConcurrentMap<Pair<String, GlobalSearchScope>, PsiPackage> packageInScopeCache = new ConcurrentHashMap<>();
-        final ConcurrentMap<String, Boolean> hasPackageInAllScopeCache = ContainerUtil.newConcurrentMap();
+        final ConcurrentMap<String, Boolean> hasPackageInAllScopeCache = new ConcurrentHashMap<>();
 
         void clear() {
             packageInScopeCache.clear();

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

@@ -16,13 +16,12 @@
 
 package org.jetbrains.kotlin.codegen
 
-import com.intellij.openapi.util.Comparing
 import com.intellij.openapi.util.text.StringUtil
 import junit.framework.TestCase
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.org.objectweb.asm.*
-import org.junit.ComparisonFailure
+import org.junit.Assert
 import java.io.File
 import java.util.*
 import java.util.regex.Pattern
@@ -82,13 +81,7 @@ abstract class AbstractCheckLocalVariablesTableTest : CodegenTestCase() {
     ) {
         val actual = getActualVariablesAsString(actualLocalVariables)
         val expected = getExpectedVariablesAsString(testFileLines)
-        if (!Comparing.equal(expected, actual)) {
+        Assert.assertEquals(expected, actual)
-            throw ComparisonFailure(
-                "Variables differ from expected",
-                expected,
-                actual
-            )
-        }
     }
 
     private fun getActualVariablesAsString(list: List<LocalVariable>) = if (backend.isIR) {

compiler/util/src/org/jetbrains/kotlin/utils/platformUtils.kt

@@ -6,6 +6,10 @@
 package org.jetbrains.kotlin.utils
 
 import com.intellij.util.containers.Interner
+import com.intellij.util.containers.MultiMap
 
 fun createStringInterner(): Interner<String> =
     Interner.createStringInterner()
+
+fun <K, V> createConcurrentMultiMap(): MultiMap<K, V> =
+    MultiMap.createConcurrent<K, V>()

compiler/util/src/org/jetbrains/kotlin/utils/platformUtils.kt.201

@@ -5,8 +5,13 @@
 
 package org.jetbrains.kotlin.utils
 
+import com.intellij.util.containers.ConcurrentMultiMap
 import com.intellij.util.containers.Interner
+import com.intellij.util.containers.MultiMap
 import com.intellij.util.containers.StringInterner
 
 fun createStringInterner(): Interner<String> =
     StringInterner()
+
+fun <K, V> createConcurrentMultiMap(): MultiMap<K, V> =
+    ConcurrentMultiMap<K, V>()

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/definitions/KotlinScriptDefinitionProvider.kt

@@ -28,7 +28,6 @@ interface ScriptDefinitionProvider {
             ServiceManager.getService(project, ScriptDefinitionProvider::class.java)
 
         fun getServiceIfCreated(project: Project): ScriptDefinitionProvider? =
-            ServiceManager.getServiceIfCreated(project, ScriptDefinitionProvider::class.java)
+            project.getServiceIfCreated(ScriptDefinitionProvider::class.java)
     }
 }
-