Use assert with lazy message in project instead of eager one

compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt

@@ -16,17 +16,17 @@
 
 package org.jetbrains.kotlin.resolve.constants.evaluate
 
-import org.jetbrains.kotlin.resolve.annotation.AbstractAnnotationDescriptorResolveTest
-import org.jetbrains.kotlin.resolve.BindingContext
-import java.io.File
 import com.intellij.openapi.util.io.FileUtil
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import kotlin.test.assertNotNull
-import java.util.regex.Pattern
-import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.annotation.AbstractAnnotationDescriptorResolveTest
 import org.jetbrains.kotlin.resolve.constants.IntegerValueConstant
+import org.jetbrains.kotlin.resolve.constants.StringValue
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.test.JetTestUtils
+import java.io.File
+import java.util.regex.Pattern
+import kotlin.test.assertNotNull
 
 public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescriptorResolveTest() {
 
@@ -92,7 +92,7 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
 
         var actualFileText = fileText
         for ((expected, actual) in expectedActual) {
-            assert(actualFileText.contains(expected), "File text should contains $expected")
+            assert(actualFileText.contains(expected)) { "File text should contain $expected" }
             actualFileText = actualFileText.replace(expected, actual)
         }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt

@@ -16,30 +16,31 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectRootModificationTracker
+import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.PsiModificationTracker
+import com.intellij.util.containers.SLRUCache
+import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.idea.project.AnalyzerFacadeProvider
+import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
+import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.idea.project.TargetPlatform.JS
+import org.jetbrains.kotlin.idea.project.TargetPlatform.JVM
+import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
+import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.psi.JetCodeFragment
+import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.JetFile
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analyzer.AnalysisResult
-import com.intellij.openapi.diagnostic.Logger
-import com.intellij.util.containers.SLRUCache
-import com.intellij.psi.util.PsiModificationTracker
-import com.intellij.psi.util.CachedValueProvider
 import org.jetbrains.kotlin.resolve.BindingContext
-import com.intellij.openapi.components.ServiceManager
-import org.jetbrains.kotlin.idea.project.AnalyzerFacadeProvider
-import org.jetbrains.kotlin.idea.project.TargetPlatform
-import org.jetbrains.kotlin.idea.project.TargetPlatform.*
-import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
-import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.utils.keysToMap
-import com.intellij.openapi.roots.ProjectRootModificationTracker
-import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.utils.keysToMap
 import kotlin.platform.platformStatic
 
 private val LOG = Logger.getInstance(javaClass<KotlinCacheService>())
@@ -226,7 +227,9 @@ public class KotlinCacheService(val project: Project) {
         val thisInfo = elements.first().getModuleInfo()
         elements.forEach {
             val extraFileInfo = it.getModuleInfo()
-            assert(extraFileInfo == thisInfo, "All files under analysis should be in the same module.\nExpected: $thisInfo\nWas:${extraFileInfo}")
+            assert(extraFileInfo == thisInfo) {
+                "All files under analysis should be in the same module.\nExpected: $thisInfo\nWas:$extraFileInfo"
+            }
         }
     }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -16,58 +16,35 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
-import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analyzer.AnalysisResult
-import com.intellij.psi.util.CachedValuesManager
-import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
-import com.intellij.util.containers.SLRUCache
-import com.intellij.psi.util.PsiModificationTracker
-import com.intellij.openapi.project.DumbService
-import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
-import org.jetbrains.kotlin.context.SimpleGlobalContext
-import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters
 import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.psi.util.CachedValueProvider
+import com.intellij.openapi.project.DumbService
-import org.jetbrains.kotlin.asJava.LightClassUtil
-import org.jetbrains.kotlin.resolve.LibrarySourceHacks
-import org.jetbrains.kotlin.idea.project.TargetPlatform
-import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
-import java.util.HashMap
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetClassInitializer
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetImportDirective
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.JetTypeConstraint
-import org.jetbrains.kotlin.psi.JetPackageDirective
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.resolve.CompositeBindingContext
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetDelegationSpecifierList
-import org.jetbrains.kotlin.psi.JetTypeParameter
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.analyzer.analyzeInContext
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.resolve.scopes.ChainedScope
-import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
-import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
-import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import com.intellij.openapi.project.IndexNotReadyException
-import org.jetbrains.kotlin.psi.JetBlockExpression
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.CachedValuesManager
+import com.intellij.psi.util.PsiModificationTracker
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.containers.SLRUCache
+import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.analyzer.analyzeInContext
+import org.jetbrains.kotlin.asJava.LightClassUtil
+import org.jetbrains.kotlin.context.SimpleGlobalContext
+import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
+import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
+import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
+import org.jetbrains.kotlin.resolve.scopes.ChainedScope
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.TypeUtils
+import java.util.HashMap
 
 public trait CacheExtension<T> {
     public val platform: TargetPlatform
@@ -152,7 +129,7 @@ private class PerFileAnalysisCache(val file: JetFile, val resolveSession: Resolv
     }
 
     fun getAnalysisResults(element: JetElement): AnalysisResult {
-        assert (element.getContainingJetFile() == file, "Wrong file. Expected $file, but was ${element.getContainingJetFile()}")
+        assert (element.getContainingJetFile() == file) { "Wrong file. Expected $file, but was ${element.getContainingJetFile()}" }
 
         val analyzableParent = KotlinResolveDataProvider.findAnalyzableParent(element)
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt

@@ -36,7 +36,6 @@ import org.jetbrains.kotlin.serialization.deserialization.DeserializationCompone
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import java.util.Collections
 
 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
     val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
@@ -55,12 +54,12 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
     override fun resolveTopLevelClass(classId: ClassId) = deserializationComponents.deserializeClass(classId)
 
     override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor> {
-        assert(packageFqName == directoryPackageFqName, "Was called for $packageFqName but only $directoryPackageFqName is expected.")
+        assert(packageFqName == directoryPackageFqName) { "Was called for $packageFqName but only $directoryPackageFqName is expected" }
         val binaryClassForPackageClass = classFinder.findKotlinClass(PackageClassUtils.getPackageClassId(packageFqName))
         val annotationData = binaryClassForPackageClass?.getClassHeader()?.annotationData
         if (annotationData == null) {
             LOG.error("Could not read annotation data for $packageFqName from ${binaryClassForPackageClass?.getClassId()}")
-            return Collections.emptyList()
+            return emptyList()
         }
         val packageData = JvmProtoBufUtil.readPackageDataFrom(annotationData)
         val membersScope = DeserializedPackageMemberScope(
@@ -68,7 +67,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
                 packageData.getPackageProto(),
                 packageData.getNameResolver(),
                 deserializationComponents
-        ) { listOf() }
+        ) { emptyList() }
         return membersScope.getDescriptors()
     }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt

@@ -289,7 +289,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 val typeArgumentsForFakeFunction = callableInfo.typeParameterInfos
                         .map {
                             val typeCandidates = computeTypeCandidates(it)
-                            assert (typeCandidates.size == 1, "Ambiguous type candidates for type parameter $it: $typeCandidates")
+                            assert (typeCandidates.size() == 1) { "Ambiguous type candidates for type parameter $it: $typeCandidates" }
                             typeCandidates.first().theType
                         }
                         .subtract(substitutionMap.keySet())
@@ -336,7 +336,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 return receiverClassDescriptor.getScopeForMemberDeclarationResolution()
             }
 
-            assert (receiverClassDescriptor is JavaClassDescriptor, "Unexpected receiver class: ${receiverClassDescriptor}")
+            assert (receiverClassDescriptor is JavaClassDescriptor) { "Unexpected receiver class: $receiverClassDescriptor" }
 
             val typeParamScope = with(
                     WritableScopeImpl(

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt

@@ -16,17 +16,16 @@
 
 package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createCallable
 
-import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.core.refactoring.chooseContainerElementIfNecessary
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.psi.*
 import java.util.Collections
@@ -42,13 +41,13 @@ public class CreateCallableFromUsageFix(
                 isExtension: Boolean) : this(originalExpression, Collections.singletonList(callableInfo), isExtension) { }
 
     init {
-        assert (callableInfos.isNotEmpty(), "No CallableInfos: ${JetPsiUtil.getElementTextWithContext(originalElement)}")
+        assert (callableInfos.isNotEmpty()) { "No CallableInfos: ${JetPsiUtil.getElementTextWithContext(originalElement)}" }
-        if (callableInfos.size > 1) {
+        if (callableInfos.size() > 1) {
             val receiverSet = callableInfos.mapTo(HashSet<TypeInfo>()) { it.receiverTypeInfo }
-            if (receiverSet.size > 1) throw AssertionError("All functions must have common receiver: $receiverSet")
+            if (receiverSet.size() > 1) throw AssertionError("All functions must have common receiver: $receiverSet")
 
             val possibleContainerSet = callableInfos.mapTo(HashSet<List<JetElement>>()) { it.possibleContainers }
-            if (possibleContainerSet.size > 1) throw AssertionError("All functions must have common containers: $possibleContainerSet")
+            if (possibleContainerSet.size() > 1) throw AssertionError("All functions must have common containers: $possibleContainerSet")
         }
     }
 
@@ -132,7 +131,9 @@ public class CreateCallableFromUsageFix(
             }
         }
         else {
-            assert(callableInfo.receiverTypeInfo is TypeInfo.Empty, "No receiver type candidates: ${element.getText()} in ${file.getText()}")
+            assert(callableInfo.receiverTypeInfo is TypeInfo.Empty) {
+                "No receiver type candidates: ${element.getText()} in ${file.getText()}"
+            }
 
             chooseContainerElementIfNecessary(callableInfo.possibleContainers, editor, popupTitle, true, { it }) {
                 val container = if (it is JetClassBody) it.getParent() as JetClassOrObject else it

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt

@@ -16,31 +16,28 @@
 
 package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass
 
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
+import com.intellij.ide.util.DirectoryChooserUtil
-import org.jetbrains.kotlin.psi.JetElement
+import com.intellij.openapi.application.ApplicationManager
-import org.jetbrains.kotlin.idea.JetBundle
-import com.intellij.openapi.project.Project
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetFile
+import com.intellij.openapi.module.ModuleUtilCore
-import com.intellij.psi.PsiElement
+import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiDirectory
+import com.intellij.psi.*
+import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import java.util.Collections
-import com.intellij.openapi.command.CommandProcessor
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.*
-import com.intellij.psi.PsiPackage
-import com.intellij.openapi.module.ModuleUtilCore
-import com.intellij.ide.util.DirectoryChooserUtil
-import java.util.HashMap
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.psi.PsiMember
-import com.intellij.psi.PsiClass
-import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.core.refactoring.getOrCreateKotlinFile
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.ENUM_ENTRY
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.OBJECT
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.PLAIN_CLASS
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.TRAIT
 import org.jetbrains.kotlin.idea.util.application.executeCommand
+import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.JetFile
+import java.util.Collections
+import java.util.HashMap
 
 enum class ClassKind(val keyword: String, val description: String) {
     PLAIN_CLASS: ClassKind("class", "class")
@@ -83,7 +80,7 @@ public class CreateClassFromUsageFix(
     override fun invoke(project: Project, editor: Editor, file: JetFile) {
         fun createFileByPackage(psiPackage: PsiPackage): JetFile? {
             val directories = psiPackage.getDirectories().filter { it.canRefactor() }
-            assert (directories.isNotEmpty(), "Package '${psiPackage.getQualifiedName() ?: ""}' must be refactorable")
+            assert (directories.isNotEmpty()) { "Package '${psiPackage.getQualifiedName()}' must be refactorable" }
 
             val currentModule = ModuleUtilCore.findModuleForPsiElement(file)
             val preferredDirectory =

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt

@@ -114,11 +114,11 @@ fun createNameCounterpartMap(from: JetElement, to: JetElement): Map<JetSimpleNam
 
     val fromOffset = from.getTextRange()!!.getStartOffset()
     from.accept(
-            object: JetTreeVisitorVoid() {
+            object : JetTreeVisitorVoid() {
                 override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
                     val offset = expression.getTextRange()!!.getStartOffset() - fromOffset
                     val newExpression = to.findElementAt(offset)?.getNonStrictParentOfType<JetSimpleNameExpression>()
-                    assert(newExpression!= null, "Couldn't find expression at $offset in '${to.getText()}'")
+                    assert(newExpression != null) { "Couldn't find expression at $offset in '${to.getText()}'" }
 
                     map[expression] = newExpression!!
                 }
@@ -437,7 +437,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
          */
         for ((offsetInBody, resolveResult) in descriptor.extractionData.refOffsetToDeclaration.entrySet().sortDescendingBy { it.key }) {
             val expr = file.findElementAt(bodyOffset + offsetInBody)?.getNonStrictParentOfType<JetSimpleNameExpression>()
-            assert(expr != null, "Couldn't find expression at $offsetInBody in '${body.getText()}'")
+            assert(expr != null) { "Couldn't find expression at $offsetInBody in '${body.getText()}'" }
 
             originalOffsetByExpr[expr!!] = offsetInBody
 

idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractSmartStepIntoTest.kt

@@ -16,16 +16,16 @@
 
 package org.jetbrains.kotlin.idea.debugger
 
-import com.intellij.debugger.actions.SmartStepTarget
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import com.intellij.debugger.actions.MethodSmartStepTarget
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import com.intellij.debugger.actions.SmartStepTarget
-import com.intellij.psi.util.PsiFormatUtil
 import com.intellij.psi.PsiSubstitutor
+import com.intellij.psi.util.PsiFormatUtil
 import com.intellij.psi.util.PsiFormatUtilBase
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
 
 public abstract class AbstractSmartStepIntoTest : JetLightCodeInsightFixtureTestCase() {
     private val fixture: JavaCodeInsightTestFixture
@@ -44,11 +44,15 @@ public abstract class AbstractSmartStepIntoTest : JetLightCodeInsightFixtureTest
         val expected = InTextDirectivesUtils.findListWithPrefixes(fixture.getFile()?.getText()!!.replace("\\,", "+++"), "// EXISTS: ").map { it.replace("+++", ",") }
 
         for (actualTargetName in actual) {
-            assert(expected.contains(actualTargetName), "Unexpected step into target was found: ${actualTargetName}\n${renderTableWithResults(expected, actual)}")
+            assert(actualTargetName in expected) {
+                "Unexpected step into target was found: $actualTargetName\n${renderTableWithResults(expected, actual)}"
+            }
         }
 
         for (expectedTargetName in expected) {
-            assert(actual.contains(expectedTargetName), "Missed step into target: ${expectedTargetName}\n${renderTableWithResults(expected, actual)}")
+            assert(expectedTargetName in actual) {
+                "Missed step into target: $expectedTargetName\n${renderTableWithResults(expected, actual)}"
+            }
         }
     }
 

idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt

@@ -17,54 +17,47 @@
 package org.jetbrains.kotlin.idea.debugger.evaluate
 
 import com.intellij.debugger.DebuggerInvocationUtil
-import com.intellij.debugger.engine.evaluation.expression.EvaluatorBuilderImpl
+import com.intellij.debugger.DebuggerManagerEx
-import com.intellij.debugger.engine.evaluation.TextWithImportsImpl
+import com.intellij.debugger.SourcePosition
-import com.intellij.debugger.engine.evaluation.CodeFragmentKind
 import com.intellij.debugger.engine.ContextUtil
+import com.intellij.debugger.engine.SourcePositionProvider
 import com.intellij.debugger.engine.SuspendContextImpl
-import org.jetbrains.kotlin.idea.debugger.*
+import com.intellij.debugger.engine.evaluation.CodeFragmentKind
-import org.junit.Assert
-import org.jetbrains.kotlin.idea.JetFileType
-import com.intellij.openapi.util.io.FileUtil
-import java.io.File
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
-import org.jetbrains.eval4j.jdi.asValue
-import org.jetbrains.eval4j.Value
-import org.jetbrains.eval4j.ObjectValue
-import com.sun.jdi.ObjectReference
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import java.util.Collections
 import com.intellij.debugger.engine.evaluation.EvaluateException
-import com.intellij.execution.process.ProcessOutputTypes
+import com.intellij.debugger.engine.evaluation.TextWithImports
-import org.apache.log4j.AppenderSkeleton
+import com.intellij.debugger.engine.evaluation.TextWithImportsImpl
-import org.apache.log4j.spi.LoggingEvent
+import com.intellij.debugger.engine.evaluation.expression.EvaluatorBuilderImpl
-import org.apache.log4j.Level
+import com.intellij.debugger.settings.NodeRendererSettings
-import org.apache.log4j.Logger
 import com.intellij.debugger.ui.impl.FrameVariablesTree
-import com.intellij.openapi.util.Disposer
+import com.intellij.debugger.ui.impl.watch.*
-import com.intellij.debugger.ui.impl.watch.DebuggerTree
+import com.intellij.debugger.ui.tree.FieldDescriptor
-import com.intellij.debugger.ui.impl.watch.DebuggerTreeNodeImpl
-import com.intellij.debugger.ui.impl.watch.DefaultNodeDescriptor
-import com.intellij.xdebugger.impl.ui.XDebuggerUIConstants
 import com.intellij.debugger.ui.tree.LocalVariableDescriptor
 import com.intellij.debugger.ui.tree.StackFrameDescriptor
 import com.intellij.debugger.ui.tree.StaticDescriptor
-import com.intellij.debugger.ui.impl.watch.ThisDescriptorImpl
+import com.intellij.execution.process.ProcessOutputTypes
-import com.intellij.debugger.ui.tree.FieldDescriptor
-import com.intellij.debugger.ui.impl.watch.NodeDescriptorImpl
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.psi.search.FilenameIndex
-import com.intellij.psi.PsiManager
-import com.intellij.debugger.DebuggerManagerEx
-import com.intellij.psi.PsiDocumentManager
 import com.intellij.openapi.application.ModalityState
-import com.intellij.debugger.settings.NodeRendererSettings
+import com.intellij.openapi.util.Disposer
-import com.intellij.debugger.SourcePosition
+import com.intellij.openapi.util.io.FileUtil
-import com.intellij.debugger.engine.SourcePositionProvider
+import com.intellij.psi.PsiDocumentManager
-import com.intellij.debugger.engine.evaluation.TextWithImports
+import com.intellij.psi.PsiManager
-import com.intellij.debugger.ui.impl.watch.WatchItemDescriptor
+import com.intellij.psi.search.FilenameIndex
+import com.intellij.xdebugger.impl.ui.XDebuggerUIConstants
+import com.sun.jdi.ObjectReference
+import org.apache.log4j.AppenderSkeleton
+import org.apache.log4j.Level
+import org.apache.log4j.Logger
+import org.apache.log4j.spi.LoggingEvent
+import org.jetbrains.eval4j.ObjectValue
+import org.jetbrains.eval4j.Value
+import org.jetbrains.eval4j.jdi.asValue
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.debugger.KotlinDebuggerTestBase
+import org.jetbrains.kotlin.idea.debugger.KotlinFrameExtraVariablesProvider
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import java.util.regex.Matcher
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.junit.Assert
+import java.io.File
+import java.util.Collections
 import java.util.regex.Pattern
 
 public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestBase() {
@@ -188,7 +181,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
         val breakpoints = InTextDirectivesUtils.findLinesWithPrefixesRemoved(fileText, "// ADDITIONAL_BREAKPOINT: ")
         for (breakpoint in breakpoints) {
             val position = breakpoint.split(".kt:")
-            assert(position.size() == 2, "Couldn't parse position from test directive: directive = ${breakpoint}")
+            assert(position.size() == 2) { "Couldn't parse position from test directive: directive = $breakpoint" }
             createBreakpoint(position[0], position[1])
         }
     }
@@ -200,7 +193,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
                     it.contentsToByteArray().toString("UTF-8").contains(lineMarker)
         }
 
-        assert(sourceFiles.size() == 1, "One source file should be found: name = $fileName, sourceFiles = $sourceFiles")
+        assert(sourceFiles.size() == 1) { "One source file should be found: name = $fileName, sourceFiles = $sourceFiles" }
 
         val runnable = Runnable() {
             val psiSourceFile = PsiManager.getInstance(project).findFile(sourceFiles.first())!!

idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt

@@ -82,14 +82,11 @@ public class NavigateFromLibrarySourcesTest: LightCodeInsightFixtureTestCase() {
                 assertEquals(expectedFqName, element.getQualifiedName())
             }
             is JetClass -> {
-                val name = element.getFqName()
+                assertEquals(expectedFqName, element.getFqName()!!.asString())
-                assert(name != null)
-                assertEquals(expectedFqName, name!!.asString())
             }
             else -> {
                 fail("Navigation element should be JetClass or PsiClass: " + element.javaClass + ", " + element.getText())
             }
         }
     }
-
 }

idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractJetExtractionTest.kt

@@ -18,18 +18,9 @@ package org.jetbrains.kotlin.idea.refactoring.introduce
 
 import com.intellij.ide.DataManager
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.psi.PsiComment
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiWhiteSpace
-import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.refactoring.BaseRefactoringProcessor.ConflictsInTestsException
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ExtractKotlinFunctionHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
@@ -37,9 +28,12 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.Introd
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.KotlinIntroduceParameterHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceProperty.KotlinIntroducePropertyHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinIntroduceVariableHandler
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
+import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.util.findElementByComment
@@ -201,7 +195,7 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
         try {
             action(file)
 
-            assert(!conflictFile.exists(), "Conflict file $conflictFile should not exist")
+            assert(!conflictFile.exists()) { "Conflict file $conflictFile should not exist" }
             JetTestUtils.assertEqualsToFile(afterFile, file.getText()!!)
         }
         catch(e: Exception) {